@arrowsphere/api-client 3.1.0 → 3.2.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 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.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/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;
+    get customer(): ReferenceLink;
+    get ponumber(): string;
+    get products(): Array<OrderProduct>;
+    toJSON(): OrderType;
+}

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

@@ -0,0 +1,99 @@
+"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, new partner_1.OrderPartner(getOrderDataInput[OrderFields.COLUMN_PARTNER]));
+        __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() {
+        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]: this.partner.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/products.d.ts

@@ -0,0 +1,47 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+import { ReferenceLink, ReferenceLinkType } from '../../referenceLink';
+export declare enum ProductPricesFields {
+    COLUMN_BUY = "buy",
+    COLUMN_SELL = "sell",
+    COLUMN_CURRENCY = "currency",
+    COLUMN_PERIODICITY = "periodicity"
+}
+export declare type ProductPricesType = {
+    [ProductPricesFields.COLUMN_BUY]: number;
+    [ProductPricesFields.COLUMN_SELL]: number;
+    [ProductPricesFields.COLUMN_CURRENCY]: string;
+    [ProductPricesFields.COLUMN_PERIODICITY]: string;
+};
+export declare enum OrderProductsFields {
+    COLUMN_SKU = "sku",
+    COLUMN_QUANTITY = "quantity",
+    COLUMN_STATUS = "status",
+    COLUMN_DATESTATUS = "dateStatus",
+    COLUMN_DETAILEDSTATUS = "detailedStatus",
+    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_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 prices(): ProductPricesType;
+    get subscription(): ReferenceLink;
+    get license(): ReferenceLink;
+    toJSON(): OrderProductsType;
+}

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

@@ -0,0 +1,97 @@
+"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, _prices, _subscription, _license;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderProduct = exports.OrderProductsFields = exports.ProductPricesFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+const referenceLink_1 = require("../../referenceLink");
+var ProductPricesFields;
+(function (ProductPricesFields) {
+    ProductPricesFields["COLUMN_BUY"] = "buy";
+    ProductPricesFields["COLUMN_SELL"] = "sell";
+    ProductPricesFields["COLUMN_CURRENCY"] = "currency";
+    ProductPricesFields["COLUMN_PERIODICITY"] = "periodicity";
+})(ProductPricesFields = exports.ProductPricesFields || (exports.ProductPricesFields = {}));
+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_PRICES"] = "prices";
+    OrderProductsFields["COLUMN_SUBSCRIPTION"] = "subscription";
+    OrderProductsFields["COLUMN_LICENSE"] = "license";
+})(OrderProductsFields = exports.OrderProductsFields || (exports.OrderProductsFields = {}));
+class OrderProduct extends abstractEntity_1.AbstractEntity {
+    constructor(getOrderProducts) {
+        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);
+        _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, _prices, 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 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_PRICES]: this.prices,
+            [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(), _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,6 @@
+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,19 @@
+"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/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,49 @@
+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"
+}
+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;
+    }>;
+};
+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(parameters?: Parameters): Promise<GetResult<DataListOrders>>;
+    getOrder(orderReference: string): Promise<GetResult<DataListOrders>>;
+}

package/build/orders/ordersClient.js

@@ -0,0 +1,48 @@
+"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 = 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(parameters = {}) {
+        return new getResult_1.GetResult(dataListOrders_1.DataListOrders, await this.get(parameters));
+    }
+    async getOrder(orderReference) {
+        this.path = `${this.ROOT_PATH}/${orderReference}`;
+        return new getResult_1.GetResult(dataListOrders_1.DataListOrders, await this.get());
+    }
+}
+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/package.json

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