@arrowsphere/api-client 3.1.0 → 3.3.0

package/CHANGELOG.md

@@ -3,6 +3,37 @@
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.3.0] - 2022-04-27
+
+### Changed
+
+- OrderProduct:
+  - Add fields isAddon, isTrial, arrowSubCategories
+- Create object ProductPrices:
+  - Add field term
+
+## [3.2.1] - 2022-04-06
+
+### Changed
+
+- OrderClient :
+  - Update type CreateOrderInputType, Fields subscription was optional
+  - Update type CreateOrderInputType, Add Fields discount and uplift
+- Endpoint List Order :
+  - add Pagination
+  - Fields Partner was optional 
+- Endpoint Get Order :
+  - Update generated URL
+  - Fields Partner was optional
+
+## [3.2.0] - 2022-04-01
+
+### Changed
+
+- Add endpoint create order
+- Add endpoint list order
+- Add endpoint get an order
+
 ## [3.1.0] - 2022-03-21
 
 ### Changed

package/build/abstractClient.d.ts

@@ -6,6 +6,8 @@ export declare enum ParameterKeys {
     API_KEY = "apiKey",
     PAGE = "page",
     PER_PAGE = "per_page",
+    SORT_BY = "sort_by",
+    ORDER_BY = "order_by",
     PER_PAGE_CAMEL = "perPage"
 }
 export declare type Parameters = Record<string, string | string[] | undefined>;

package/build/abstractClient.js

@@ -17,6 +17,8 @@ var ParameterKeys;
     ParameterKeys["API_KEY"] = "apiKey";
     ParameterKeys["PAGE"] = "page";
     ParameterKeys["PER_PAGE"] = "per_page";
+    ParameterKeys["SORT_BY"] = "sort_by";
+    ParameterKeys["ORDER_BY"] = "order_by";
     ParameterKeys["PER_PAGE_CAMEL"] = "perPage";
 })(ParameterKeys = exports.ParameterKeys || (exports.ParameterKeys = {}));
 class AbstractClient {

package/build/customers/entities/invitations/contact/invitationContact.d.ts

@@ -1,16 +1,18 @@
 import { AbstractEntity } from '../../../../abstractEntity';
-export declare enum InvitationContactFields {
-    COLUMN_FIRSTNAME = "firstName",
-    COLUMN_LASTNAME = "lastName",
-    COLUMN_EMAIL = "email",
+import { SharedContactFields, SharedContactInterface } from '../../../../shared/contact/contact';
+declare enum InvitationContactEnum {
     COLUMN_USERNAME = "username"
 }
-export declare type InvitationContactType = {
-    [InvitationContactFields.COLUMN_USERNAME]: string;
-    [InvitationContactFields.COLUMN_FIRSTNAME]: string;
-    [InvitationContactFields.COLUMN_LASTNAME]: string;
-    [InvitationContactFields.COLUMN_EMAIL]: string;
+export declare const InvitationContactFields: {
+    COLUMN_FIRSTNAME: SharedContactFields.COLUMN_FIRSTNAME;
+    COLUMN_LASTNAME: SharedContactFields.COLUMN_LASTNAME;
+    COLUMN_EMAIL: SharedContactFields.COLUMN_EMAIL;
+    COLUMN_USERNAME: InvitationContactEnum.COLUMN_USERNAME;
 };
+interface InvitationContactInterface {
+    [InvitationContactFields.COLUMN_USERNAME]: string;
+}
+export declare type InvitationContactType = InvitationContactInterface & SharedContactInterface;
 export declare class InvitationContact extends AbstractEntity<InvitationContactType> {
     #private;
     constructor(getCustomersContactDataInput: InvitationContactType);
@@ -20,3 +22,4 @@ export declare class InvitationContact extends AbstractEntity<InvitationContactT
     get email(): string;
     toJSON(): InvitationContactType;
 }
+export {};

package/build/customers/entities/invitations/contact/invitationContact.js

@@ -16,13 +16,15 @@ var _username, _firstname, _lastname, _email;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvitationContact = exports.InvitationContactFields = void 0;
 const abstractEntity_1 = require("../../../../abstractEntity");
-var InvitationContactFields;
-(function (InvitationContactFields) {
-    InvitationContactFields["COLUMN_FIRSTNAME"] = "firstName";
-    InvitationContactFields["COLUMN_LASTNAME"] = "lastName";
-    InvitationContactFields["COLUMN_EMAIL"] = "email";
-    InvitationContactFields["COLUMN_USERNAME"] = "username";
-})(InvitationContactFields = exports.InvitationContactFields || (exports.InvitationContactFields = {}));
+const contact_1 = require("../../../../shared/contact/contact");
+var InvitationContactEnum;
+(function (InvitationContactEnum) {
+    InvitationContactEnum["COLUMN_USERNAME"] = "username";
+})(InvitationContactEnum || (InvitationContactEnum = {}));
+exports.InvitationContactFields = {
+    ...InvitationContactEnum,
+    ...contact_1.SharedContactFields,
+};
 class InvitationContact extends abstractEntity_1.AbstractEntity {
     constructor(getCustomersContactDataInput) {
         super(getCustomersContactDataInput);
@@ -30,10 +32,10 @@ class InvitationContact extends abstractEntity_1.AbstractEntity {
         _firstname.set(this, void 0);
         _lastname.set(this, void 0);
         _email.set(this, void 0);
-        __classPrivateFieldSet(this, _firstname, getCustomersContactDataInput[InvitationContactFields.COLUMN_FIRSTNAME]);
-        __classPrivateFieldSet(this, _username, getCustomersContactDataInput[InvitationContactFields.COLUMN_USERNAME]);
-        __classPrivateFieldSet(this, _lastname, getCustomersContactDataInput[InvitationContactFields.COLUMN_LASTNAME]);
-        __classPrivateFieldSet(this, _email, getCustomersContactDataInput[InvitationContactFields.COLUMN_EMAIL]);
+        __classPrivateFieldSet(this, _firstname, getCustomersContactDataInput[contact_1.SharedContactFields.COLUMN_FIRSTNAME]);
+        __classPrivateFieldSet(this, _username, getCustomersContactDataInput[exports.InvitationContactFields.COLUMN_USERNAME]);
+        __classPrivateFieldSet(this, _lastname, getCustomersContactDataInput[contact_1.SharedContactFields.COLUMN_LASTNAME]);
+        __classPrivateFieldSet(this, _email, getCustomersContactDataInput[contact_1.SharedContactFields.COLUMN_EMAIL]);
     }
     get username() {
         return __classPrivateFieldGet(this, _username);
@@ -49,10 +51,10 @@ class InvitationContact extends abstractEntity_1.AbstractEntity {
     }
     toJSON() {
         return {
-            [InvitationContactFields.COLUMN_USERNAME]: this.username,
-            [InvitationContactFields.COLUMN_FIRSTNAME]: this.firstName,
-            [InvitationContactFields.COLUMN_LASTNAME]: this.lastName,
-            [InvitationContactFields.COLUMN_EMAIL]: this.email,
+            [exports.InvitationContactFields.COLUMN_USERNAME]: this.username,
+            [contact_1.SharedContactFields.COLUMN_FIRSTNAME]: this.firstName,
+            [contact_1.SharedContactFields.COLUMN_LASTNAME]: this.lastName,
+            [contact_1.SharedContactFields.COLUMN_EMAIL]: this.email,
         };
     }
 }

package/build/index.d.ts

@@ -4,8 +4,10 @@ export * from './abstractEntity';
 export * from './abstractClient';
 export * from './abstractGraphQLClient';
 export * from './catalog/';
-export * from './licenses/';
+export * from './customers/';
 export * from './general/';
+export * from './licenses/';
+export * from './orders/';
+export * from './shared/';
 export * from './subscriptions/';
-export * from './customers/';
 export * from './getResult';

package/build/index.js

@@ -16,9 +16,11 @@ __exportStar(require("./abstractEntity"), exports);
 __exportStar(require("./abstractClient"), exports);
 __exportStar(require("./abstractGraphQLClient"), exports);
 __exportStar(require("./catalog/"), exports);
-__exportStar(require("./licenses/"), exports);
+__exportStar(require("./customers/"), exports);
 __exportStar(require("./general/"), exports);
+__exportStar(require("./licenses/"), exports);
+__exportStar(require("./orders/"), exports);
+__exportStar(require("./shared/"), exports);
 __exportStar(require("./subscriptions/"), exports);
-__exportStar(require("./customers/"), exports);
 __exportStar(require("./getResult"), exports);
 //# sourceMappingURL=index.js.map

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

@@ -44,7 +44,7 @@ class LicensePriceGetResult extends abstractEntity_1.AbstractEntity {
     }
     toJSON() {
         return {
-            [LicensePriceGetFields.COLUMN_CURRENCY]: __classPrivateFieldGet(this, _currency),
+            [LicensePriceGetFields.COLUMN_CURRENCY]: this.currency,
             [LicensePriceGetFields.COLUMN_UNIT]: this.unit.toJSON(),
             [LicensePriceGetFields.COLUMN_TOTAL]: this.total.toJSON(),
         };

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

@@ -1,9 +1,9 @@
 import { ActiveSeatsFindResultData, ActiveSeatsFindResultDataKeywords, ActiveSeatsFindResultDataSortParameters, ActiveSeatsFindResult, ActiveSeatsFindResultDataFiltersParameters } from './activeSeatsFindResult';
 import { AbstractEntity } from '../../../abstractEntity';
 import { Rules } from 'validatorjs';
-import { ConfigFindResultData, ConfigFindResultDataFiltersParameters, ConfigFindResultDataKeywords, ConfigFindResultDataSortParameters } from './configFindResult';
+import { ConfigFindResult, ConfigFindResultData, ConfigFindResultDataFiltersParameters, ConfigFindResultDataKeywords, ConfigFindResultDataSortParameters } from './configFindResult';
 import { DataKeywords, FiltersParameters, SortParameters } from '../../licensesClient';
-import { WarningFindResultData, WarningFindResultDataFiltersParameters, WarningFindResultDataKeywords, WarningFindResultDataSortParameters } from './warningFindResult';
+import { WarningFindResult, WarningFindResultData, WarningFindResultDataFiltersParameters, WarningFindResultDataKeywords, WarningFindResultDataSortParameters } from './warningFindResult';
 import { PriceFindResult, PriceFindResultData, PriceFindResultDataFiltersParameters, PriceFindResultDataKeywords, PriceFindResutDataSortParameters } from './priceFindResult';
 /**
  * Highlight response object.
@@ -67,8 +67,8 @@ export declare type LicenseFindResultData = {
     [LicenseFindResultFields.COLUMN_BASE_SEAT]: number;
     [LicenseFindResultFields.COLUMN_CATEGORY]: string;
     [LicenseFindResultFields.COLUMN_CLOUD_TYPE]: string;
-    [LicenseFindResultFields.COLUMN_CONFIGS]: Array<ConfigFindResultData> | null | undefined;
-    [LicenseFindResultFields.COLUMN_WARNINGS]: Array<WarningFindResultData> | null | undefined;
+    [LicenseFindResultFields.COLUMN_CONFIGS]?: Array<ConfigFindResultData> | null;
+    [LicenseFindResultFields.COLUMN_WARNINGS]?: Array<WarningFindResultData> | null;
     [LicenseFindResultFields.COLUMN_CUSTOMER_NAME]: string;
     [LicenseFindResultFields.COLUMN_CUSTOMER_REF]: string;
     [LicenseFindResultFields.COLUMN_END_DATE]: string;
@@ -245,8 +245,8 @@ export declare class LicenseFindResult extends AbstractEntity<LicenseFindResultD
     get baseSeat(): number;
     get category(): string;
     get classification(): string;
-    get configs(): Array<ConfigFindResultData> | null | undefined;
-    get warnings(): Array<WarningFindResultData> | null | undefined;
+    get configs(): Array<ConfigFindResult> | null | undefined;
+    get warnings(): Array<WarningFindResult> | null | undefined;
     get customerName(): string;
     get customerRef(): string;
     get endDate(): string;

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

@@ -17,6 +17,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LicenseFindResult = exports.LicenseFindResultFields = void 0;
 const activeSeatsFindResult_1 = require("./activeSeatsFindResult");
 const abstractEntity_1 = require("../../../abstractEntity");
+const configFindResult_1 = require("./configFindResult");
+const warningFindResult_1 = require("./warningFindResult");
 const priceFindResult_1 = require("./priceFindResult");
 /**
  * Fields that can be present in License response and request data.
@@ -72,7 +74,7 @@ class LicenseFindResult extends abstractEntity_1.AbstractEntity {
      * @param data - License find result data from the response.
      */
     constructor(data) {
-        var _a;
+        var _a, _b, _c;
         super(data);
         this.VALIDATION_RULES = {
             [LicenseFindResultFields.COLUMN_ACCEPT_EULA]: 'present|boolean',
@@ -145,12 +147,8 @@ class LicenseFindResult extends abstractEntity_1.AbstractEntity {
         __classPrivateFieldSet(this, _baseSeat, data[LicenseFindResultFields.COLUMN_BASE_SEAT]);
         __classPrivateFieldSet(this, _category, data[LicenseFindResultFields.COLUMN_CATEGORY]);
         __classPrivateFieldSet(this, _classification, data[LicenseFindResultFields.COLUMN_CLOUD_TYPE]);
-        if (typeof data[LicenseFindResultFields.COLUMN_CONFIGS] !== 'undefined') {
-            __classPrivateFieldSet(this, _configs, data === null || data === void 0 ? void 0 : data[LicenseFindResultFields.COLUMN_CONFIGS]);
-        }
-        if (typeof data[LicenseFindResultFields.COLUMN_WARNINGS] !== 'undefined') {
-            __classPrivateFieldSet(this, _warnings, data === null || data === void 0 ? void 0 : data[LicenseFindResultFields.COLUMN_WARNINGS]);
-        }
+        __classPrivateFieldSet(this, _configs, (_a = data[LicenseFindResultFields.COLUMN_CONFIGS]) === null || _a === void 0 ? void 0 : _a.map((configData) => new configFindResult_1.ConfigFindResult(configData)));
+        __classPrivateFieldSet(this, _warnings, (_b = data[LicenseFindResultFields.COLUMN_WARNINGS]) === null || _b === void 0 ? void 0 : _b.map((warningData) => new warningFindResult_1.WarningFindResult(warningData)));
         __classPrivateFieldSet(this, _customerName, data[LicenseFindResultFields.COLUMN_CUSTOMER_NAME]);
         __classPrivateFieldSet(this, _customerRef, data[LicenseFindResultFields.COLUMN_CUSTOMER_REF]);
         __classPrivateFieldSet(this, _endDate, data[LicenseFindResultFields.COLUMN_END_DATE]);
@@ -190,7 +188,7 @@ class LicenseFindResult extends abstractEntity_1.AbstractEntity {
         __classPrivateFieldSet(this, _vendorCode, data[LicenseFindResultFields.COLUMN_VENDOR_CODE]);
         __classPrivateFieldSet(this, _vendorName, data[LicenseFindResultFields.COLUMN_VENDOR_NAME]);
         __classPrivateFieldSet(this, _vendorSubscriptionId, data[LicenseFindResultFields.COLUMN_VENDOR_SUBSCRIPTION_ID]);
-        __classPrivateFieldSet(this, _highlight, (_a = data[LicenseFindResultFields.COLUMN_HIGHLIGHT]) !== null && _a !== void 0 ? _a : {});
+        __classPrivateFieldSet(this, _highlight, (_c = data[LicenseFindResultFields.COLUMN_HIGHLIGHT]) !== null && _c !== void 0 ? _c : {});
     }
     get id() {
         return __classPrivateFieldGet(this, _id);
@@ -320,6 +318,7 @@ class LicenseFindResult extends abstractEntity_1.AbstractEntity {
      * @returns {@link LicenseData}
      */
     toJSON() {
+        var _a, _b;
         return {
             [LicenseFindResultFields.COLUMN_ACCEPT_EULA]: this.acceptEula,
             [LicenseFindResultFields.COLUMN_ACTIVE_SEATS]: this.activeSeats.toJSON(),
@@ -327,8 +326,8 @@ class LicenseFindResult extends abstractEntity_1.AbstractEntity {
             [LicenseFindResultFields.COLUMN_BASE_SEAT]: this.baseSeat,
             [LicenseFindResultFields.COLUMN_CATEGORY]: this.category,
             [LicenseFindResultFields.COLUMN_CLOUD_TYPE]: this.classification,
-            [LicenseFindResultFields.COLUMN_CONFIGS]: this.configs,
-            [LicenseFindResultFields.COLUMN_WARNINGS]: this.warnings,
+            [LicenseFindResultFields.COLUMN_CONFIGS]: (_a = this.configs) === null || _a === void 0 ? void 0 : _a.map((config) => config.toJSON()),
+            [LicenseFindResultFields.COLUMN_WARNINGS]: (_b = this.warnings) === null || _b === void 0 ? void 0 : _b.map((warning) => warning.toJSON()),
             [LicenseFindResultFields.COLUMN_CUSTOMER_NAME]: this.customerName,
             [LicenseFindResultFields.COLUMN_CUSTOMER_REF]: this.customerRef,
             [LicenseFindResultFields.COLUMN_END_DATE]: this.endDate,

package/build/orders/entities/dataListOrders.d.ts

@@ -0,0 +1,14 @@
+import { AbstractEntity } from '../../abstractEntity';
+import { Order, OrderType } from './orders/order';
+export declare enum DataListOrdersFields {
+    COLUMN_ORDERS = "orders"
+}
+export declare type DataListOrdersType = {
+    [DataListOrdersFields.COLUMN_ORDERS]: Array<OrderType>;
+};
+export declare class DataListOrders extends AbstractEntity<DataListOrdersType> {
+    #private;
+    constructor(listOrderDataInput: DataListOrdersType);
+    get orders(): Array<Order>;
+    toJSON(): DataListOrdersType;
+}

package/build/orders/entities/dataListOrders.js

@@ -0,0 +1,41 @@
+"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 _orders;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataListOrders = exports.DataListOrdersFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+const order_1 = require("./orders/order");
+var DataListOrdersFields;
+(function (DataListOrdersFields) {
+    DataListOrdersFields["COLUMN_ORDERS"] = "orders";
+})(DataListOrdersFields = exports.DataListOrdersFields || (exports.DataListOrdersFields = {}));
+class DataListOrders extends abstractEntity_1.AbstractEntity {
+    constructor(listOrderDataInput) {
+        super(listOrderDataInput);
+        _orders.set(this, void 0);
+        __classPrivateFieldSet(this, _orders, listOrderDataInput[DataListOrdersFields.COLUMN_ORDERS].map((order) => new order_1.Order(order)));
+    }
+    get orders() {
+        return __classPrivateFieldGet(this, _orders);
+    }
+    toJSON() {
+        return {
+            [DataListOrdersFields.COLUMN_ORDERS]: this.orders.map((order) => order.toJSON()),
+        };
+    }
+}
+exports.DataListOrders = DataListOrders;
+_orders = new WeakMap();
+//# sourceMappingURL=dataListOrders.js.map

package/build/orders/entities/orders/order.d.ts

@@ -0,0 +1,40 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { OrderProduct, OrderProductsType } from './products/products';
+import { OrderPartner, OrderPartnerType } from './partner/partner';
+import { ReferenceLink, ReferenceLinkType } from '../referenceLink';
+export declare enum OrderFields {
+    COLUMN_REFERENCE = "reference",
+    COLUMN_STATUS = "status",
+    COLUMN_DATESTATUS = "dateStatus",
+    COLUMN_DATECREATION = "dateCreation",
+    COLUMN_ORDER_REFERENCE = "order_reference",
+    COLUMN_PARTNER = "partner",
+    COLUMN_CUSTOMER = "customer",
+    COLUMN_PONUMBER = "ponumber",
+    COLUMN_PRODUCTS = "products"
+}
+export declare type OrderType = {
+    [OrderFields.COLUMN_REFERENCE]: string;
+    [OrderFields.COLUMN_STATUS]: string;
+    [OrderFields.COLUMN_DATESTATUS]: string;
+    [OrderFields.COLUMN_DATECREATION]: string;
+    [OrderFields.COLUMN_ORDER_REFERENCE]: string;
+    [OrderFields.COLUMN_PARTNER]?: OrderPartnerType;
+    [OrderFields.COLUMN_CUSTOMER]: ReferenceLinkType;
+    [OrderFields.COLUMN_PONUMBER]: string;
+    [OrderFields.COLUMN_PRODUCTS]: Array<OrderProductsType>;
+};
+export declare class Order extends AbstractEntity<OrderType> {
+    #private;
+    constructor(getOrderDataInput: OrderType);
+    get reference(): string;
+    get status(): string;
+    get dateStatus(): string;
+    get dateCreation(): string;
+    get order_reference(): string;
+    get partner(): OrderPartner | undefined;
+    get customer(): ReferenceLink;
+    get ponumber(): string;
+    get products(): Array<OrderProduct>;
+    toJSON(): OrderType;
+}

package/build/orders/entities/orders/order.js

@@ -0,0 +1,102 @@
+"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 _reference, _status, _dateStatus, _dateCreation, _order_reference, _partner, _customer, _ponumber, _products;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Order = exports.OrderFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const products_1 = require("./products/products");
+const partner_1 = require("./partner/partner");
+const referenceLink_1 = require("../referenceLink");
+var OrderFields;
+(function (OrderFields) {
+    OrderFields["COLUMN_REFERENCE"] = "reference";
+    OrderFields["COLUMN_STATUS"] = "status";
+    OrderFields["COLUMN_DATESTATUS"] = "dateStatus";
+    OrderFields["COLUMN_DATECREATION"] = "dateCreation";
+    OrderFields["COLUMN_ORDER_REFERENCE"] = "order_reference";
+    OrderFields["COLUMN_PARTNER"] = "partner";
+    OrderFields["COLUMN_CUSTOMER"] = "customer";
+    OrderFields["COLUMN_PONUMBER"] = "ponumber";
+    OrderFields["COLUMN_PRODUCTS"] = "products";
+})(OrderFields = exports.OrderFields || (exports.OrderFields = {}));
+class Order extends abstractEntity_1.AbstractEntity {
+    constructor(getOrderDataInput) {
+        super(getOrderDataInput);
+        _reference.set(this, void 0);
+        _status.set(this, void 0);
+        _dateStatus.set(this, void 0);
+        _dateCreation.set(this, void 0);
+        _order_reference.set(this, void 0);
+        _partner.set(this, void 0);
+        _customer.set(this, void 0);
+        _ponumber.set(this, void 0);
+        _products.set(this, void 0);
+        __classPrivateFieldSet(this, _reference, getOrderDataInput[OrderFields.COLUMN_REFERENCE]);
+        __classPrivateFieldSet(this, _status, getOrderDataInput[OrderFields.COLUMN_STATUS]);
+        __classPrivateFieldSet(this, _dateStatus, getOrderDataInput[OrderFields.COLUMN_DATESTATUS]);
+        __classPrivateFieldSet(this, _dateCreation, getOrderDataInput[OrderFields.COLUMN_DATECREATION]);
+        __classPrivateFieldSet(this, _order_reference, getOrderDataInput[OrderFields.COLUMN_ORDER_REFERENCE]);
+        __classPrivateFieldSet(this, _partner, getOrderDataInput[OrderFields.COLUMN_PARTNER]
+            ? new partner_1.OrderPartner(getOrderDataInput[OrderFields.COLUMN_PARTNER])
+            : undefined);
+        __classPrivateFieldSet(this, _customer, new referenceLink_1.ReferenceLink(getOrderDataInput[OrderFields.COLUMN_CUSTOMER]));
+        __classPrivateFieldSet(this, _ponumber, getOrderDataInput[OrderFields.COLUMN_PONUMBER]);
+        __classPrivateFieldSet(this, _products, getOrderDataInput[OrderFields.COLUMN_PRODUCTS].map((order) => new products_1.OrderProduct(order)));
+    }
+    get reference() {
+        return __classPrivateFieldGet(this, _reference);
+    }
+    get status() {
+        return __classPrivateFieldGet(this, _status);
+    }
+    get dateStatus() {
+        return __classPrivateFieldGet(this, _dateStatus);
+    }
+    get dateCreation() {
+        return __classPrivateFieldGet(this, _dateCreation);
+    }
+    get order_reference() {
+        return __classPrivateFieldGet(this, _order_reference);
+    }
+    get partner() {
+        return __classPrivateFieldGet(this, _partner);
+    }
+    get customer() {
+        return __classPrivateFieldGet(this, _customer);
+    }
+    get ponumber() {
+        return __classPrivateFieldGet(this, _ponumber);
+    }
+    get products() {
+        return __classPrivateFieldGet(this, _products);
+    }
+    toJSON() {
+        var _a;
+        return {
+            [OrderFields.COLUMN_REFERENCE]: this.reference,
+            [OrderFields.COLUMN_STATUS]: this.status,
+            [OrderFields.COLUMN_DATESTATUS]: this.dateStatus,
+            [OrderFields.COLUMN_DATECREATION]: this.dateCreation,
+            [OrderFields.COLUMN_ORDER_REFERENCE]: this.order_reference,
+            [OrderFields.COLUMN_PARTNER]: (_a = this.partner) === null || _a === void 0 ? void 0 : _a.toJSON(),
+            [OrderFields.COLUMN_CUSTOMER]: this.customer.toJSON(),
+            [OrderFields.COLUMN_PONUMBER]: this.ponumber,
+            [OrderFields.COLUMN_PRODUCTS]: this.products.map((order) => order.toJSON()),
+        };
+    }
+}
+exports.Order = Order;
+_reference = new WeakMap(), _status = new WeakMap(), _dateStatus = new WeakMap(), _dateCreation = new WeakMap(), _order_reference = new WeakMap(), _partner = new WeakMap(), _customer = new WeakMap(), _ponumber = new WeakMap(), _products = new WeakMap();
+//# sourceMappingURL=order.js.map

package/build/orders/entities/orders/partner/partner.d.ts

@@ -0,0 +1,17 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+import { SharedContactInterface } from '../../../../shared/contact/contact';
+export declare enum OrderPartnerFields {
+    COLUMN_COMPANYNAME = "companyName",
+    COLUMN_CONTACT = "contact"
+}
+export declare type OrderPartnerType = {
+    [OrderPartnerFields.COLUMN_COMPANYNAME]: string;
+    [OrderPartnerFields.COLUMN_CONTACT]: SharedContactInterface;
+};
+export declare class OrderPartner extends AbstractEntity<OrderPartnerType> {
+    #private;
+    constructor(getOrderPartnerDataInput: OrderPartnerType);
+    get companyName(): string;
+    get contact(): SharedContactInterface;
+    toJSON(): OrderPartnerType;
+}

package/build/orders/entities/orders/partner/partner.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 _companyName, _contact;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderPartner = exports.OrderPartnerFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var OrderPartnerFields;
+(function (OrderPartnerFields) {
+    OrderPartnerFields["COLUMN_COMPANYNAME"] = "companyName";
+    OrderPartnerFields["COLUMN_CONTACT"] = "contact";
+})(OrderPartnerFields = exports.OrderPartnerFields || (exports.OrderPartnerFields = {}));
+class OrderPartner extends abstractEntity_1.AbstractEntity {
+    constructor(getOrderPartnerDataInput) {
+        super(getOrderPartnerDataInput);
+        _companyName.set(this, void 0);
+        _contact.set(this, void 0);
+        __classPrivateFieldSet(this, _companyName, getOrderPartnerDataInput[OrderPartnerFields.COLUMN_COMPANYNAME]);
+        __classPrivateFieldSet(this, _contact, getOrderPartnerDataInput[OrderPartnerFields.COLUMN_CONTACT]);
+    }
+    get companyName() {
+        return __classPrivateFieldGet(this, _companyName);
+    }
+    get contact() {
+        return __classPrivateFieldGet(this, _contact);
+    }
+    toJSON() {
+        return {
+            [OrderPartnerFields.COLUMN_COMPANYNAME]: this.companyName,
+            [OrderPartnerFields.COLUMN_CONTACT]: this.contact,
+        };
+    }
+}
+exports.OrderPartner = OrderPartner;
+_companyName = new WeakMap(), _contact = new WeakMap();
+//# sourceMappingURL=partner.js.map

package/build/orders/entities/orders/products/prices/productPrices.d.ts

@@ -0,0 +1,25 @@
+import { AbstractEntity } from '../../../../../abstractEntity';
+export declare enum ProductPricesFields {
+    COLUMN_BUY = "buy",
+    COLUMN_SELL = "sell",
+    COLUMN_CURRENCY = "currency",
+    COLUMN_PERIODICITY = "periodicity",
+    COLUMN_TERM = "term"
+}
+export declare type ProductPricesType = {
+    [ProductPricesFields.COLUMN_BUY]: number;
+    [ProductPricesFields.COLUMN_SELL]: number;
+    [ProductPricesFields.COLUMN_CURRENCY]: string;
+    [ProductPricesFields.COLUMN_PERIODICITY]: string;
+    [ProductPricesFields.COLUMN_TERM]: string;
+};
+export declare class ProductPrices extends AbstractEntity<ProductPricesType> {
+    #private;
+    constructor(productPricesInput: ProductPricesType);
+    get buy(): number;
+    get sell(): number;
+    get currency(): string;
+    get periodicity(): string;
+    get term(): string;
+    toJSON(): ProductPricesType;
+}

package/build/orders/entities/orders/products/prices/productPrices.js

@@ -0,0 +1,68 @@
+"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, _currency, _periodicity, _term;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductPrices = exports.ProductPricesFields = void 0;
+const abstractEntity_1 = require("../../../../../abstractEntity");
+var ProductPricesFields;
+(function (ProductPricesFields) {
+    ProductPricesFields["COLUMN_BUY"] = "buy";
+    ProductPricesFields["COLUMN_SELL"] = "sell";
+    ProductPricesFields["COLUMN_CURRENCY"] = "currency";
+    ProductPricesFields["COLUMN_PERIODICITY"] = "periodicity";
+    ProductPricesFields["COLUMN_TERM"] = "term";
+})(ProductPricesFields = exports.ProductPricesFields || (exports.ProductPricesFields = {}));
+class ProductPrices extends abstractEntity_1.AbstractEntity {
+    constructor(productPricesInput) {
+        super(productPricesInput);
+        _buy.set(this, void 0);
+        _sell.set(this, void 0);
+        _currency.set(this, void 0);
+        _periodicity.set(this, void 0);
+        _term.set(this, void 0);
+        __classPrivateFieldSet(this, _buy, productPricesInput[ProductPricesFields.COLUMN_BUY]);
+        __classPrivateFieldSet(this, _sell, productPricesInput[ProductPricesFields.COLUMN_SELL]);
+        __classPrivateFieldSet(this, _currency, productPricesInput[ProductPricesFields.COLUMN_CURRENCY]);
+        __classPrivateFieldSet(this, _periodicity, productPricesInput[ProductPricesFields.COLUMN_PERIODICITY]);
+        __classPrivateFieldSet(this, _term, productPricesInput[ProductPricesFields.COLUMN_TERM]);
+    }
+    get buy() {
+        return __classPrivateFieldGet(this, _buy);
+    }
+    get sell() {
+        return __classPrivateFieldGet(this, _sell);
+    }
+    get currency() {
+        return __classPrivateFieldGet(this, _currency);
+    }
+    get periodicity() {
+        return __classPrivateFieldGet(this, _periodicity);
+    }
+    get term() {
+        return __classPrivateFieldGet(this, _term);
+    }
+    toJSON() {
+        return {
+            [ProductPricesFields.COLUMN_BUY]: this.buy,
+            [ProductPricesFields.COLUMN_SELL]: this.sell,
+            [ProductPricesFields.COLUMN_CURRENCY]: this.currency,
+            [ProductPricesFields.COLUMN_PERIODICITY]: this.periodicity,
+            [ProductPricesFields.COLUMN_TERM]: this.term,
+        };
+    }
+}
+exports.ProductPrices = ProductPrices;
+_buy = new WeakMap(), _sell = new WeakMap(), _currency = new WeakMap(), _periodicity = new WeakMap(), _term = new WeakMap();
+//# sourceMappingURL=productPrices.js.map

package/build/orders/entities/orders/products/products.d.ts

@@ -0,0 +1,45 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+import { ReferenceLink, ReferenceLinkType } from '../../referenceLink';
+import { ProductPrices, ProductPricesType } from './prices/productPrices';
+export declare enum OrderProductsFields {
+    COLUMN_SKU = "sku",
+    COLUMN_QUANTITY = "quantity",
+    COLUMN_STATUS = "status",
+    COLUMN_DATESTATUS = "dateStatus",
+    COLUMN_DETAILEDSTATUS = "detailedStatus",
+    COLUMN_IS_ADDON = "isAddon",
+    COLUMN_ARROWSUBCATEGORIES = "arrowSubCategories",
+    COLUMN_IS_TRIAL = "isTrial",
+    COLUMN_PRICES = "prices",
+    COLUMN_SUBSCRIPTION = "subscription",
+    COLUMN_LICENSE = "license"
+}
+export declare type OrderProductsType = {
+    [OrderProductsFields.COLUMN_SKU]: string;
+    [OrderProductsFields.COLUMN_QUANTITY]: number;
+    [OrderProductsFields.COLUMN_STATUS]: string;
+    [OrderProductsFields.COLUMN_DATESTATUS]: string;
+    [OrderProductsFields.COLUMN_DETAILEDSTATUS]: string;
+    [OrderProductsFields.COLUMN_IS_ADDON]: boolean;
+    [OrderProductsFields.COLUMN_ARROWSUBCATEGORIES]?: Array<string>;
+    [OrderProductsFields.COLUMN_IS_TRIAL]: boolean;
+    [OrderProductsFields.COLUMN_PRICES]: ProductPricesType;
+    [OrderProductsFields.COLUMN_SUBSCRIPTION]: ReferenceLinkType;
+    [OrderProductsFields.COLUMN_LICENSE]: ReferenceLinkType;
+};
+export declare class OrderProduct extends AbstractEntity<OrderProductsType> {
+    #private;
+    constructor(getOrderProducts: OrderProductsType);
+    get sku(): string;
+    get quantity(): number;
+    get status(): string;
+    get dateStatus(): string;
+    get detailedStatus(): string;
+    get isAddon(): boolean;
+    get arrowSubCategories(): Array<string> | undefined;
+    get isTrial(): boolean;
+    get prices(): ProductPrices;
+    get subscription(): ReferenceLink;
+    get license(): ReferenceLink;
+    toJSON(): OrderProductsType;
+}

package/build/orders/entities/orders/products/products.js

@@ -0,0 +1,113 @@
+"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 _sku, _quantity, _status, _dateStatus, _detailedStatus, _isAddon, _arrowSubCategories, _isTrial, _prices, _subscription, _license;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderProduct = exports.OrderProductsFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+const referenceLink_1 = require("../../referenceLink");
+const productPrices_1 = require("./prices/productPrices");
+var OrderProductsFields;
+(function (OrderProductsFields) {
+    OrderProductsFields["COLUMN_SKU"] = "sku";
+    OrderProductsFields["COLUMN_QUANTITY"] = "quantity";
+    OrderProductsFields["COLUMN_STATUS"] = "status";
+    OrderProductsFields["COLUMN_DATESTATUS"] = "dateStatus";
+    OrderProductsFields["COLUMN_DETAILEDSTATUS"] = "detailedStatus";
+    OrderProductsFields["COLUMN_IS_ADDON"] = "isAddon";
+    OrderProductsFields["COLUMN_ARROWSUBCATEGORIES"] = "arrowSubCategories";
+    OrderProductsFields["COLUMN_IS_TRIAL"] = "isTrial";
+    OrderProductsFields["COLUMN_PRICES"] = "prices";
+    OrderProductsFields["COLUMN_SUBSCRIPTION"] = "subscription";
+    OrderProductsFields["COLUMN_LICENSE"] = "license";
+})(OrderProductsFields = exports.OrderProductsFields || (exports.OrderProductsFields = {}));
+class OrderProduct extends abstractEntity_1.AbstractEntity {
+    constructor(getOrderProducts) {
+        var _a;
+        super(getOrderProducts);
+        _sku.set(this, void 0);
+        _quantity.set(this, void 0);
+        _status.set(this, void 0);
+        _dateStatus.set(this, void 0);
+        _detailedStatus.set(this, void 0);
+        _isAddon.set(this, void 0);
+        _arrowSubCategories.set(this, void 0);
+        _isTrial.set(this, void 0);
+        _prices.set(this, void 0);
+        _subscription.set(this, void 0);
+        _license.set(this, void 0);
+        __classPrivateFieldSet(this, _sku, getOrderProducts[OrderProductsFields.COLUMN_SKU]);
+        __classPrivateFieldSet(this, _quantity, getOrderProducts[OrderProductsFields.COLUMN_QUANTITY]);
+        __classPrivateFieldSet(this, _status, getOrderProducts[OrderProductsFields.COLUMN_STATUS]);
+        __classPrivateFieldSet(this, _dateStatus, getOrderProducts[OrderProductsFields.COLUMN_DATESTATUS]);
+        __classPrivateFieldSet(this, _detailedStatus, getOrderProducts[OrderProductsFields.COLUMN_DETAILEDSTATUS]);
+        __classPrivateFieldSet(this, _isAddon, getOrderProducts[OrderProductsFields.COLUMN_IS_ADDON]);
+        __classPrivateFieldSet(this, _arrowSubCategories, (_a = getOrderProducts[OrderProductsFields.COLUMN_ARROWSUBCATEGORIES]) !== null && _a !== void 0 ? _a : undefined);
+        __classPrivateFieldSet(this, _isTrial, getOrderProducts[OrderProductsFields.COLUMN_IS_TRIAL]);
+        __classPrivateFieldSet(this, _prices, new productPrices_1.ProductPrices(getOrderProducts[OrderProductsFields.COLUMN_PRICES]));
+        __classPrivateFieldSet(this, _subscription, new referenceLink_1.ReferenceLink(getOrderProducts[OrderProductsFields.COLUMN_SUBSCRIPTION]));
+        __classPrivateFieldSet(this, _license, new referenceLink_1.ReferenceLink(getOrderProducts[OrderProductsFields.COLUMN_LICENSE]));
+    }
+    get sku() {
+        return __classPrivateFieldGet(this, _sku);
+    }
+    get quantity() {
+        return __classPrivateFieldGet(this, _quantity);
+    }
+    get status() {
+        return __classPrivateFieldGet(this, _status);
+    }
+    get dateStatus() {
+        return __classPrivateFieldGet(this, _dateStatus);
+    }
+    get detailedStatus() {
+        return __classPrivateFieldGet(this, _detailedStatus);
+    }
+    get isAddon() {
+        return __classPrivateFieldGet(this, _isAddon);
+    }
+    get arrowSubCategories() {
+        return __classPrivateFieldGet(this, _arrowSubCategories);
+    }
+    get isTrial() {
+        return __classPrivateFieldGet(this, _isTrial);
+    }
+    get prices() {
+        return __classPrivateFieldGet(this, _prices);
+    }
+    get subscription() {
+        return __classPrivateFieldGet(this, _subscription);
+    }
+    get license() {
+        return __classPrivateFieldGet(this, _license);
+    }
+    toJSON() {
+        return {
+            [OrderProductsFields.COLUMN_SKU]: this.sku,
+            [OrderProductsFields.COLUMN_QUANTITY]: this.quantity,
+            [OrderProductsFields.COLUMN_STATUS]: this.status,
+            [OrderProductsFields.COLUMN_DATESTATUS]: this.dateStatus,
+            [OrderProductsFields.COLUMN_DETAILEDSTATUS]: this.detailedStatus,
+            [OrderProductsFields.COLUMN_IS_ADDON]: this.isAddon,
+            [OrderProductsFields.COLUMN_ARROWSUBCATEGORIES]: this.arrowSubCategories,
+            [OrderProductsFields.COLUMN_IS_TRIAL]: this.isTrial,
+            [OrderProductsFields.COLUMN_PRICES]: this.prices.toJSON(),
+            [OrderProductsFields.COLUMN_SUBSCRIPTION]: this.subscription.toJSON(),
+            [OrderProductsFields.COLUMN_LICENSE]: this.license.toJSON(),
+        };
+    }
+}
+exports.OrderProduct = OrderProduct;
+_sku = new WeakMap(), _quantity = new WeakMap(), _status = new WeakMap(), _dateStatus = new WeakMap(), _detailedStatus = new WeakMap(), _isAddon = new WeakMap(), _arrowSubCategories = new WeakMap(), _isTrial = new WeakMap(), _prices = new WeakMap(), _subscription = new WeakMap(), _license = new WeakMap();
+//# sourceMappingURL=products.js.map

package/build/orders/entities/referenceLink.d.ts

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

package/build/orders/entities/referenceLink.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 _reference, _link;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceLink = exports.ReferenceLinkFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+var ReferenceLinkFields;
+(function (ReferenceLinkFields) {
+    ReferenceLinkFields["COLUMN_REFERENCE"] = "reference";
+    ReferenceLinkFields["COLUMN_LINK"] = "link";
+})(ReferenceLinkFields = exports.ReferenceLinkFields || (exports.ReferenceLinkFields = {}));
+class ReferenceLink extends abstractEntity_1.AbstractEntity {
+    constructor(referenceLinkInput) {
+        super(referenceLinkInput);
+        _reference.set(this, void 0);
+        _link.set(this, void 0);
+        __classPrivateFieldSet(this, _reference, referenceLinkInput[ReferenceLinkFields.COLUMN_REFERENCE]);
+        __classPrivateFieldSet(this, _link, referenceLinkInput[ReferenceLinkFields.COLUMN_LINK]);
+    }
+    get reference() {
+        return __classPrivateFieldGet(this, _reference);
+    }
+    get link() {
+        return __classPrivateFieldGet(this, _link);
+    }
+    toJSON() {
+        return {
+            [ReferenceLinkFields.COLUMN_REFERENCE]: this.reference,
+            [ReferenceLinkFields.COLUMN_LINK]: this.link,
+        };
+    }
+}
+exports.ReferenceLink = ReferenceLink;
+_reference = new WeakMap(), _link = new WeakMap();
+//# sourceMappingURL=referenceLink.js.map

package/build/orders/index.d.ts

@@ -0,0 +1,7 @@
+export * from './entities/orders/products/prices/productPrices';
+export * from './entities/orders/products/products';
+export * from './entities/orders/partner/partner';
+export * from './entities/orders/order';
+export * from './entities/dataListOrders';
+export * from './entities/referenceLink';
+export * from './ordersClient';

package/build/orders/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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/orders/products/prices/productPrices"), exports);
+__exportStar(require("./entities/orders/products/products"), exports);
+__exportStar(require("./entities/orders/partner/partner"), exports);
+__exportStar(require("./entities/orders/order"), exports);
+__exportStar(require("./entities/dataListOrders"), exports);
+__exportStar(require("./entities/referenceLink"), exports);
+__exportStar(require("./ordersClient"), exports);
+//# sourceMappingURL=index.js.map

package/build/orders/ordersClient.d.ts

@@ -0,0 +1,53 @@
+import { AbstractClient, Parameters } from '../abstractClient';
+import { GetResult } from '../getResult';
+import { DataListOrders } from './entities/dataListOrders';
+import { ReferenceLink } from './entities/referenceLink';
+export declare enum CreateOrderInputFields {
+    COLUMN_CUSTOMER = "customer",
+    COLUMN_REFERENCE = "reference",
+    COLUMN_PO_NUMBER = "ponumber",
+    COLUMN_PRODUCTS = "products",
+    COLUMN_SKU = "sku",
+    COLUMN_QUANTITY = "quantity",
+    COLUMN_SUBSCRIPTION = "subscription",
+    COLUMN_PARENT_LICENSE_ID = "parentLicenseId",
+    COLUMN_PARENT_SKU = "parentSku",
+    COLUMN_PERIODICITY = "periodicity",
+    COLUMN_TERM = "term",
+    COLUMN_DISCOUNT = "discount",
+    COLUMN_UPLIFT = "uplift"
+}
+export declare type CreateOrderInputType = {
+    [CreateOrderInputFields.COLUMN_CUSTOMER]: {
+        [CreateOrderInputFields.COLUMN_REFERENCE]: string;
+        [CreateOrderInputFields.COLUMN_PO_NUMBER]?: string;
+    };
+    [CreateOrderInputFields.COLUMN_PRODUCTS]: Array<{
+        [CreateOrderInputFields.COLUMN_SKU]: string;
+        [CreateOrderInputFields.COLUMN_QUANTITY]: number;
+        [CreateOrderInputFields.COLUMN_SUBSCRIPTION]?: {
+            [CreateOrderInputFields.COLUMN_REFERENCE]: string;
+        };
+        [CreateOrderInputFields.COLUMN_PARENT_LICENSE_ID]?: string;
+        [CreateOrderInputFields.COLUMN_PARENT_SKU]?: string;
+        [CreateOrderInputFields.COLUMN_PERIODICITY]?: string;
+        [CreateOrderInputFields.COLUMN_TERM]?: string;
+        [CreateOrderInputFields.COLUMN_DISCOUNT]?: number;
+        [CreateOrderInputFields.COLUMN_UPLIFT]?: number;
+    }>;
+};
+export declare class OrdersClient extends AbstractClient {
+    /**
+     * The base path of the Orders API
+     *
+     * TODO: Actually we use php endpoint and we need to add "/index.php/api" before "/orders" remove "/index.php/api" when endpoint is available in nodejs
+     */
+    private ROOT_PATH;
+    /**
+     * The base path of the API
+     */
+    protected basePath: string;
+    create(postData: CreateOrderInputType, parameters?: Parameters): Promise<GetResult<ReferenceLink>>;
+    getListOrders(perPage?: number, page?: number, parameters?: Parameters): Promise<GetResult<DataListOrders>>;
+    getOrder(orderReference: string, parameters?: Parameters): Promise<GetResult<DataListOrders>>;
+}

package/build/orders/ordersClient.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrdersClient = exports.CreateOrderInputFields = void 0;
+const abstractClient_1 = require("../abstractClient");
+const getResult_1 = require("../getResult");
+const dataListOrders_1 = require("./entities/dataListOrders");
+const referenceLink_1 = require("./entities/referenceLink");
+var CreateOrderInputFields;
+(function (CreateOrderInputFields) {
+    CreateOrderInputFields["COLUMN_CUSTOMER"] = "customer";
+    CreateOrderInputFields["COLUMN_REFERENCE"] = "reference";
+    CreateOrderInputFields["COLUMN_PO_NUMBER"] = "ponumber";
+    CreateOrderInputFields["COLUMN_PRODUCTS"] = "products";
+    CreateOrderInputFields["COLUMN_SKU"] = "sku";
+    CreateOrderInputFields["COLUMN_QUANTITY"] = "quantity";
+    CreateOrderInputFields["COLUMN_SUBSCRIPTION"] = "subscription";
+    CreateOrderInputFields["COLUMN_PARENT_LICENSE_ID"] = "parentLicenseId";
+    CreateOrderInputFields["COLUMN_PARENT_SKU"] = "parentSku";
+    CreateOrderInputFields["COLUMN_PERIODICITY"] = "periodicity";
+    CreateOrderInputFields["COLUMN_TERM"] = "term";
+    CreateOrderInputFields["COLUMN_DISCOUNT"] = "discount";
+    CreateOrderInputFields["COLUMN_UPLIFT"] = "uplift";
+})(CreateOrderInputFields = exports.CreateOrderInputFields || (exports.CreateOrderInputFields = {}));
+class OrdersClient extends abstractClient_1.AbstractClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * The base path of the Orders API
+         *
+         * TODO: Actually we use php endpoint and we need to add "/index.php/api" before "/orders" remove "/index.php/api" when endpoint is available in nodejs
+         */
+        this.ROOT_PATH = '/index.php/api/orders';
+        /**
+         * The base path of the API
+         */
+        this.basePath = this.ROOT_PATH;
+    }
+    async create(postData, parameters = {}) {
+        return new getResult_1.GetResult(referenceLink_1.ReferenceLink, await this.post(postData, parameters));
+    }
+    async getListOrders(perPage = 25, page = 1, parameters = {}) {
+        this.setPerPage(perPage);
+        this.setPage(page);
+        return new getResult_1.GetResult(dataListOrders_1.DataListOrders, await this.get(parameters));
+    }
+    async getOrder(orderReference, parameters = {}) {
+        this.path = `/${orderReference}`;
+        return new getResult_1.GetResult(dataListOrders_1.DataListOrders, await this.get(parameters));
+    }
+}
+exports.OrdersClient = OrdersClient;
+//# sourceMappingURL=ordersClient.js.map

package/build/publicApiClient.d.ts

@@ -3,6 +3,7 @@ import { CheckDomainClient, WhoAmIClient } from './general';
 import { LicensesClient } from './licenses/licensesClient';
 import { SubscriptionsClient } from './subscriptions/subscriptionsClient';
 import { CustomersClient } from './customers/customersClient';
+import { OrdersClient } from './orders';
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -33,5 +34,10 @@ export declare class PublicApiClient extends AbstractClient {
      * @returns {@link SubscriptionsClient}
      */
     getSubscriptionsClient(): SubscriptionsClient;
+    /**
+     * Creates a new {@link OrdersClient} instance and returns it
+     * @returns {@link OrdersClient}
+     */
+    getOrdersClient(): OrdersClient;
 }
 export default PublicApiClient;

package/build/publicApiClient.js

@@ -6,6 +6,7 @@ const general_1 = require("./general");
 const licensesClient_1 = require("./licenses/licensesClient");
 const subscriptionsClient_1 = require("./subscriptions/subscriptionsClient");
 const customersClient_1 = require("./customers/customersClient");
+const orders_1 = require("./orders");
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -58,6 +59,15 @@ class PublicApiClient extends abstractClient_1.AbstractClient {
             .setUrl(this.url)
             .setApiKey(this.apiKey);
     }
+    /**
+     * Creates a new {@link OrdersClient} instance and returns it
+     * @returns {@link OrdersClient}
+     */
+    getOrdersClient() {
+        return new orders_1.OrdersClient(this.client)
+            .setUrl(this.url)
+            .setApiKey(this.apiKey);
+    }
 }
 exports.PublicApiClient = PublicApiClient;
 exports.default = PublicApiClient;

package/build/shared/contact/contact.d.ts

@@ -0,0 +1,10 @@
+export declare enum SharedContactFields {
+    COLUMN_FIRSTNAME = "firstName",
+    COLUMN_LASTNAME = "lastName",
+    COLUMN_EMAIL = "email"
+}
+export interface SharedContactInterface {
+    [SharedContactFields.COLUMN_FIRSTNAME]: string;
+    [SharedContactFields.COLUMN_LASTNAME]: string;
+    [SharedContactFields.COLUMN_EMAIL]: string;
+}

package/build/shared/contact/contact.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedContactFields = void 0;
+var SharedContactFields;
+(function (SharedContactFields) {
+    SharedContactFields["COLUMN_FIRSTNAME"] = "firstName";
+    SharedContactFields["COLUMN_LASTNAME"] = "lastName";
+    SharedContactFields["COLUMN_EMAIL"] = "email";
+})(SharedContactFields = exports.SharedContactFields || (exports.SharedContactFields = {}));
+//# sourceMappingURL=contact.js.map

package/build/shared/index.d.ts

@@ -0,0 +1 @@
+export * from './contact/contact';

package/build/shared/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./contact/contact"), exports);
+//# sourceMappingURL=index.js.map

package/package.json

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