@arrowsphere/api-client 3.0.0 → 3.2.1

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 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.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
+
+- Add endpoint get customer invitation
+
 ## [3.0.0] - 2022-03-08
 
 ### 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/customersClient.d.ts

@@ -1,10 +1,12 @@
 import { AbstractClient, Parameters } from '../abstractClient';
 import { GetResult } from '../getResult';
 import { DataCustomers } from './entities/dataCustomers';
+import { DataInvitation } from './entities/dataInvitation';
 export declare class CustomersClient extends AbstractClient {
     /**
      * The base path of the Customers API
      */
     private ROOT_PATH;
     getCustomers(parameters?: Parameters): Promise<GetResult<DataCustomers>>;
+    getCustomerInvitation(codeInvitation: string, parameters?: Parameters): Promise<GetResult<DataInvitation>>;
 }

package/build/customers/customersClient.js

@@ -4,6 +4,7 @@ exports.CustomersClient = void 0;
 const abstractClient_1 = require("../abstractClient");
 const getResult_1 = require("../getResult");
 const dataCustomers_1 = require("./entities/dataCustomers");
+const dataInvitation_1 = require("./entities/dataInvitation");
 class CustomersClient extends abstractClient_1.AbstractClient {
     constructor() {
         super(...arguments);
@@ -16,6 +17,10 @@ class CustomersClient extends abstractClient_1.AbstractClient {
         this.path = this.ROOT_PATH;
         return new getResult_1.GetResult(dataCustomers_1.DataCustomers, await this.get(parameters));
     }
+    async getCustomerInvitation(codeInvitation, parameters = {}) {
+        this.path = `${this.ROOT_PATH}/invitations/${codeInvitation}`;
+        return new getResult_1.GetResult(dataInvitation_1.DataInvitation, await this.get(parameters));
+    }
 }
 exports.CustomersClient = CustomersClient;
 //# sourceMappingURL=customersClient.js.map

package/build/customers/entities/dataInvitation.d.ts

@@ -0,0 +1,27 @@
+import { AbstractEntity } from '../../abstractEntity';
+import { Company, CompanyType } from './invitations/company/company';
+import { InvitationContact, InvitationContactType } from './invitations/contact/invitationContact';
+export declare enum DataInvitationFields {
+    COLUMN_CODE = "code",
+    COLUMN_CREATED_AT = "createdAt",
+    COLUMN_UPDATED_AT = "updatedAt",
+    COLUMN_COMPANY = "company",
+    COLUMN_CONTACT = "contact"
+}
+export declare type DataInvitationType = {
+    [DataInvitationFields.COLUMN_CODE]: string;
+    [DataInvitationFields.COLUMN_CREATED_AT]: string;
+    [DataInvitationFields.COLUMN_UPDATED_AT]: string;
+    [DataInvitationFields.COLUMN_COMPANY]: CompanyType;
+    [DataInvitationFields.COLUMN_CONTACT]: InvitationContactType;
+};
+export declare class DataInvitation extends AbstractEntity<DataInvitationType> {
+    #private;
+    constructor(getCustomerInvitationDataInput: DataInvitationType);
+    get code(): string;
+    get createdAt(): string;
+    get updatedAt(): string;
+    get company(): Company;
+    get contact(): InvitationContact;
+    toJSON(): DataInvitationType;
+}

package/build/customers/entities/dataInvitation.js

@@ -0,0 +1,70 @@
+"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 _code, _createdAt, _updatedAt, _company, _contact;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataInvitation = exports.DataInvitationFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+const company_1 = require("./invitations/company/company");
+const invitationContact_1 = require("./invitations/contact/invitationContact");
+var DataInvitationFields;
+(function (DataInvitationFields) {
+    DataInvitationFields["COLUMN_CODE"] = "code";
+    DataInvitationFields["COLUMN_CREATED_AT"] = "createdAt";
+    DataInvitationFields["COLUMN_UPDATED_AT"] = "updatedAt";
+    DataInvitationFields["COLUMN_COMPANY"] = "company";
+    DataInvitationFields["COLUMN_CONTACT"] = "contact";
+})(DataInvitationFields = exports.DataInvitationFields || (exports.DataInvitationFields = {}));
+class DataInvitation extends abstractEntity_1.AbstractEntity {
+    constructor(getCustomerInvitationDataInput) {
+        super(getCustomerInvitationDataInput);
+        _code.set(this, void 0);
+        _createdAt.set(this, void 0);
+        _updatedAt.set(this, void 0);
+        _company.set(this, void 0);
+        _contact.set(this, void 0);
+        __classPrivateFieldSet(this, _code, getCustomerInvitationDataInput[DataInvitationFields.COLUMN_CODE]);
+        __classPrivateFieldSet(this, _createdAt, getCustomerInvitationDataInput[DataInvitationFields.COLUMN_CREATED_AT]);
+        __classPrivateFieldSet(this, _updatedAt, getCustomerInvitationDataInput[DataInvitationFields.COLUMN_UPDATED_AT]);
+        __classPrivateFieldSet(this, _company, new company_1.Company(getCustomerInvitationDataInput[DataInvitationFields.COLUMN_COMPANY]));
+        __classPrivateFieldSet(this, _contact, new invitationContact_1.InvitationContact(getCustomerInvitationDataInput[DataInvitationFields.COLUMN_CONTACT]));
+    }
+    get code() {
+        return __classPrivateFieldGet(this, _code);
+    }
+    get createdAt() {
+        return __classPrivateFieldGet(this, _createdAt);
+    }
+    get updatedAt() {
+        return __classPrivateFieldGet(this, _updatedAt);
+    }
+    get company() {
+        return __classPrivateFieldGet(this, _company);
+    }
+    get contact() {
+        return __classPrivateFieldGet(this, _contact);
+    }
+    toJSON() {
+        return {
+            [DataInvitationFields.COLUMN_CODE]: this.code,
+            [DataInvitationFields.COLUMN_CREATED_AT]: this.createdAt,
+            [DataInvitationFields.COLUMN_UPDATED_AT]: this.updatedAt,
+            [DataInvitationFields.COLUMN_COMPANY]: this.company.toJSON(),
+            [DataInvitationFields.COLUMN_CONTACT]: this.contact.toJSON(),
+        };
+    }
+}
+exports.DataInvitation = DataInvitation;
+_code = new WeakMap(), _createdAt = new WeakMap(), _updatedAt = new WeakMap(), _company = new WeakMap(), _contact = new WeakMap();
+//# sourceMappingURL=dataInvitation.js.map

package/build/customers/entities/invitations/company/company.d.ts

@@ -0,0 +1,13 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum CompanyFields {
+    COLUMN_REFERENCE = "reference"
+}
+export declare type CompanyType = {
+    [CompanyFields.COLUMN_REFERENCE]: string;
+};
+export declare class Company extends AbstractEntity<CompanyType> {
+    #private;
+    constructor(getCustomersCompanyDataInput: CompanyType);
+    get reference(): string;
+    toJSON(): CompanyType;
+}

package/build/customers/entities/invitations/company/company.js

@@ -0,0 +1,40 @@
+"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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Company = exports.CompanyFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var CompanyFields;
+(function (CompanyFields) {
+    CompanyFields["COLUMN_REFERENCE"] = "reference";
+})(CompanyFields = exports.CompanyFields || (exports.CompanyFields = {}));
+class Company extends abstractEntity_1.AbstractEntity {
+    constructor(getCustomersCompanyDataInput) {
+        super(getCustomersCompanyDataInput);
+        _reference.set(this, void 0);
+        __classPrivateFieldSet(this, _reference, getCustomersCompanyDataInput[CompanyFields.COLUMN_REFERENCE]);
+    }
+    get reference() {
+        return __classPrivateFieldGet(this, _reference);
+    }
+    toJSON() {
+        return {
+            [CompanyFields.COLUMN_REFERENCE]: this.reference,
+        };
+    }
+}
+exports.Company = Company;
+_reference = new WeakMap();
+//# sourceMappingURL=company.js.map

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

@@ -0,0 +1,25 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+import { SharedContactFields, SharedContactInterface } from '../../../../shared/contact/contact';
+declare enum InvitationContactEnum {
+    COLUMN_USERNAME = "username"
+}
+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);
+    get username(): string;
+    get firstName(): string;
+    get lastName(): string;
+    get email(): string;
+    toJSON(): InvitationContactType;
+}
+export {};

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

@@ -0,0 +1,63 @@
+"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 _username, _firstname, _lastname, _email;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvitationContact = exports.InvitationContactFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+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);
+        _username.set(this, void 0);
+        _firstname.set(this, void 0);
+        _lastname.set(this, void 0);
+        _email.set(this, void 0);
+        __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);
+    }
+    get firstName() {
+        return __classPrivateFieldGet(this, _firstname);
+    }
+    get lastName() {
+        return __classPrivateFieldGet(this, _lastname);
+    }
+    get email() {
+        return __classPrivateFieldGet(this, _email);
+    }
+    toJSON() {
+        return {
+            [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,
+        };
+    }
+}
+exports.InvitationContact = InvitationContact;
+_username = new WeakMap(), _firstname = new WeakMap(), _lastname = new WeakMap(), _email = new WeakMap();
+//# sourceMappingURL=invitationContact.js.map

package/build/customers/index.d.ts

@@ -1,5 +1,8 @@
 export * from './entities/customers/contact/contact';
+export * from './entities/invitations/contact/invitationContact';
 export * from './entities/customers/details/details';
+export * from './entities/invitations/company/company';
 export * from './entities/customers/customer';
 export * from './entities/dataCustomers';
+export * from './entities/dataInvitation';
 export * from './customersClient';

package/build/customers/index.js

@@ -11,8 +11,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./entities/customers/contact/contact"), exports);
+__exportStar(require("./entities/invitations/contact/invitationContact"), exports);
 __exportStar(require("./entities/customers/details/details"), exports);
+__exportStar(require("./entities/invitations/company/company"), exports);
 __exportStar(require("./entities/customers/customer"), exports);
 __exportStar(require("./entities/dataCustomers"), exports);
+__exportStar(require("./entities/dataInvitation"), exports);
 __exportStar(require("./customersClient"), exports);
 //# sourceMappingURL=index.js.map

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/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,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/package.json

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