@arrowsphere/api-client 3.0.0 → 3.1.0

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 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.1.0] - 2022-03-21
+
+### Changed
+
+- Add endpoint get customer invitation
+
 ## [3.0.0] - 2022-03-08
 
 ### Changed

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,22 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum InvitationContactFields {
+    COLUMN_FIRSTNAME = "firstName",
+    COLUMN_LASTNAME = "lastName",
+    COLUMN_EMAIL = "email",
+    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 class InvitationContact extends AbstractEntity<InvitationContactType> {
+    #private;
+    constructor(getCustomersContactDataInput: InvitationContactType);
+    get username(): string;
+    get firstName(): string;
+    get lastName(): string;
+    get email(): string;
+    toJSON(): InvitationContactType;
+}

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

@@ -0,0 +1,61 @@
+"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");
+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 = {}));
+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[InvitationContactFields.COLUMN_FIRSTNAME]);
+        __classPrivateFieldSet(this, _username, getCustomersContactDataInput[InvitationContactFields.COLUMN_USERNAME]);
+        __classPrivateFieldSet(this, _lastname, getCustomersContactDataInput[InvitationContactFields.COLUMN_LASTNAME]);
+        __classPrivateFieldSet(this, _email, getCustomersContactDataInput[InvitationContactFields.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 {
+            [InvitationContactFields.COLUMN_USERNAME]: this.username,
+            [InvitationContactFields.COLUMN_FIRSTNAME]: this.firstName,
+            [InvitationContactFields.COLUMN_LASTNAME]: this.lastName,
+            [InvitationContactFields.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/package.json

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