@arrowsphere/api-client 2.5.0 → 2.8.0

package/CHANGELOG.md

@@ -3,6 +3,27 @@
 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).
 
+## [2.8.0] - 2022-03-03
+
+### Added
+
+- Add endpoint graphQL
+
+## [2.7.0] - 2022-03-03
+
+### Added
+
+- Update object license for getLicense endpoint
+- Add endpoint update license friendlyName
+
+## [2.6.0] - 2022-02-22
+
+### Added
+
+- Add endpoint get customers
+- Move file GetResult to use it with all endpoint
+- Update GetResult class to add pagination field
+
 ## [2.5.0] - 2022-02-14
 
 ### Added

package/build/abstractClient.js

@@ -121,10 +121,10 @@ class AbstractClient {
     getResponse(response) {
         const statusCode = response.status;
         if (statusCode === 404) {
-            throw new exception_1.NotFoundException(`Resource not found on URL ${this.getUrl()}`);
+            throw new exception_1.NotFoundException(`Resource not found on URL ${this.getUrl()}`, response.data.error, statusCode);
         }
         if (statusCode >= 400 && statusCode <= 599) {
-            throw new exception_1.PublicApiClientException(`Error: status code: ${statusCode}. URL: ${this.getUrl()}`);
+            throw new exception_1.PublicApiClientException(`Error: status code: ${statusCode}. URL: ${this.getUrl()}`, response.data.error, statusCode);
         }
         return response.data;
     }

package/build/abstractGraphQLClient.d.ts

@@ -0,0 +1,27 @@
+import { GraphQLClient } from 'graphql-request';
+import * as Dom from 'graphql-request/dist/types.dom';
+import { Options } from './abstractClient';
+import { GetProductsType } from './catalog';
+export declare type GraphQLResponseTypes = GetProductsType;
+export declare abstract class AbstractGraphQLClient {
+    /**
+     * Base path for HTTP calls
+     */
+    protected basePath: string;
+    /**
+     * Current path for HTTP calls
+     */
+    protected path: string;
+    protected client: GraphQLClient;
+    protected url: string;
+    protected token: string;
+    protected optionsHeader?: Dom.RequestInit['headers'];
+    protected options: Options;
+    private getClient;
+    setToken(apiKey: string): this;
+    setUrl(url: string): this;
+    setOptionsHeader(options: Dom.RequestInit['headers']): this;
+    setOptions(options: Options): this;
+    protected post(query: string): Promise<GraphQLResponseTypes>;
+    protected generateUrl(): string;
+}

package/build/abstractGraphQLClient.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractGraphQLClient = void 0;
+const graphql_request_1 = require("graphql-request");
+const url_1 = require("url");
+const path_1 = __importDefault(require("path"));
+class AbstractGraphQLClient {
+    constructor() {
+        /**
+         * Base path for HTTP calls
+         */
+        this.basePath = '';
+        /**
+         * Current path for HTTP calls
+         */
+        this.path = '';
+        this.url = '';
+        this.token = '';
+        this.options = {};
+    }
+    getClient() {
+        this.client = new graphql_request_1.GraphQLClient(this.generateUrl());
+        return this;
+    }
+    setToken(apiKey) {
+        this.token = apiKey;
+        return this;
+    }
+    setUrl(url) {
+        this.url = url;
+        return this;
+    }
+    setOptionsHeader(options) {
+        this.optionsHeader = options;
+        return this;
+    }
+    setOptions(options) {
+        this.options = options;
+        return this;
+    }
+    async post(query) {
+        this.getClient().client.setHeaders({
+            authorization: this.token,
+            ...this.optionsHeader,
+        });
+        return await this.client.request(query);
+    }
+    generateUrl() {
+        const url = new url_1.URL(`${this.options.isAdmin ? path_1.default.join('admin', this.basePath) : this.basePath}${this.path}`, this.url);
+        return url.toString();
+    }
+}
+exports.AbstractGraphQLClient = AbstractGraphQLClient;
+//# sourceMappingURL=abstractGraphQLClient.js.map

package/build/catalog/catalogGraphQLClient.d.ts

@@ -0,0 +1,17 @@
+import { AbstractGraphQLClient } from '../abstractGraphQLClient';
+import { GetProductsType } from './types/catalogGraphQLTypes';
+export declare class CatalogGraphQLClient extends AbstractGraphQLClient {
+    /**
+     * The base path of the Catalog API
+     */
+    private ROOT_PATH;
+    /**
+     * The base path of the API
+     */
+    protected basePath: string;
+    /**
+     * The Path of graphql catalog API
+     */
+    private GRAPHQL;
+    find(request: string): Promise<GetProductsType>;
+}

package/build/catalog/catalogGraphQLClient.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalogGraphQLClient = void 0;
+const abstractGraphQLClient_1 = require("../abstractGraphQLClient");
+// import { inspect } from 'util';
+class CatalogGraphQLClient extends abstractGraphQLClient_1.AbstractGraphQLClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * The base path of the Catalog API
+         */
+        this.ROOT_PATH = 'catalog/';
+        /**
+         * The base path of the API
+         */
+        this.basePath = this.ROOT_PATH;
+        /**
+         * The Path of graphql catalog API
+         */
+        this.GRAPHQL = 'graphql';
+    }
+    async find(request) {
+        this.path = this.GRAPHQL;
+        return await this.post(request);
+    }
+}
+exports.CatalogGraphQLClient = CatalogGraphQLClient;
+//# sourceMappingURL=catalogGraphQLClient.js.map

package/build/catalog/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types/catalogGraphQLTypes';
+export * from './catalogGraphQLClient';

package/build/catalog/index.js

@@ -0,0 +1,15 @@
+"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("./types/catalogGraphQLTypes"), exports);
+__exportStar(require("./catalogGraphQLClient"), exports);
+//# sourceMappingURL=index.js.map

package/build/catalog/types/catalogGraphQLTypes.d.ts

@@ -0,0 +1,224 @@
+export declare type GetProductsType = {
+    getProducts?: PaginatedProductsType;
+};
+export declare type PaginatedProductsType = {
+    filters?: Array<FiltersType>;
+    pagination?: PaginationType;
+    products?: Array<ProductType>;
+    topOffers?: Array<ProductType>;
+};
+export declare type FiltersType = {
+    name?: string;
+    values?: FiltersValuesType;
+};
+export declare type FiltersValuesType = {
+    value?: string;
+    count?: number;
+};
+export declare type PaginationType = {
+    perPage?: number;
+    currentPage?: number;
+    totalPage?: number;
+    total?: number;
+    next?: string;
+    previous?: string;
+};
+export declare type ProductType = {
+    id?: string;
+    identifiers?: IdentifiersType;
+    name?: string;
+    classification?: string;
+    arrowCategories?: Array<string>;
+    arrowSubCategories?: Array<string>;
+    licenseAgreementType?: string;
+    family?: FamilyType;
+    isAddon?: boolean;
+    hasAddons?: boolean;
+    actionFlags?: ActionFlagsType;
+    addonPrimaries?: Array<IdentifiersType>;
+    conversionOfferPrimaries?: Array<IdentifiersType>;
+    baseOfferPrimaries?: Array<IdentifiersType>;
+    assets?: AssetsType;
+    environmentAvailability?: string;
+    marketplace?: string;
+    isEnabled?: boolean;
+    isTrial?: boolean;
+    isIndirectBusiness?: boolean;
+    lastUpdate?: string;
+    marketingText?: MarketingTextType;
+    vendorOfferUrl?: string;
+    serviceDescription?: string;
+    eula?: string;
+    endCustomerEula?: string;
+    endCustomerRequirements?: string;
+    endCustomerFeatures?: string;
+    xspUrl?: string;
+    saleConstraints?: SaleConstraintsType;
+    vendor?: VendorType;
+    program?: ProgramType;
+    weightTopSales?: number;
+    weightForced?: number;
+    priceBand?: Array<PriceBandType>;
+    defaultPriceBand?: PriceBandType;
+    relatedOffers?: Array<RelatedOfferType>;
+    resellers?: OfferResellersType;
+    scope?: string;
+};
+export declare type IdentifiersType = {
+    arrowsphere?: ArrowsphereIdentifierType;
+    vendor?: VendorIdentifierType;
+};
+export declare type ArrowsphereIdentifierType = {
+    sku?: string;
+    skuXsp?: string;
+    skuXac?: string;
+    orderableSku?: string;
+};
+export declare type VendorIdentifierType = {
+    name?: string;
+    family?: string;
+    offerName?: string;
+    sku?: string;
+    attributes?: AttributesType;
+};
+export declare type AttributesType = {
+    cancelSubscription?: boolean;
+    canSwitchAutoRenew?: boolean;
+    decreaseSeats?: boolean;
+    increaseSeats?: boolean;
+    partIdentifier?: string;
+    periodicity?: number;
+    planId?: string;
+    productId?: string;
+    productSku?: string;
+    reactivateSubscription?: boolean;
+    suspendSubscription?: boolean;
+    term?: number;
+    unitType?: string;
+};
+export declare type FamilyType = {
+    id?: string;
+    name?: string;
+};
+export declare type ActionFlagsType = {
+    isAutoRenew?: boolean;
+    isManualProvisioning?: boolean;
+    renewalSku?: string;
+};
+export declare type AssetsType = {
+    featurePictureUrl?: string;
+    mainLogoUrl?: string;
+    pictureUrl?: string;
+    squareLogoUrl?: string;
+};
+export declare type MarketingTextType = {
+    overviewDescription?: string;
+    featuresShort?: string;
+    featuresFull?: string;
+    features?: string;
+};
+export declare type SaleConstraintsType = {
+    customerQualifications?: Array<string>;
+    resellerQualifications?: Array<string>;
+    minQuantity?: number;
+    maxQuantity?: number;
+    maxSubscriptionConstraint?: string;
+    maxSubscriptionPerCustomer?: number;
+    saleGroup?: string;
+    requiredAttributes?: Array<string>;
+};
+export declare type VendorType = {
+    name?: string;
+};
+export declare type ProgramType = {
+    isEnabled?: boolean;
+    legacyCode?: string;
+    names?: ProgramNameType;
+};
+export declare type ProgramNameType = {
+    full?: string;
+};
+export declare type PriceBandType = {
+    actionFlags?: PriceBandActionFlagsType;
+    attributes?: Array<AttributeType>;
+    billing?: BillingType;
+    currency?: string;
+    dynamicAttributes?: DynamicAttributesType;
+    family?: FamilyType;
+    identifiers?: PriceBandIdentifiersType;
+    isEnabled?: boolean;
+    marketplace?: string;
+    name?: string;
+    orderingType?: string;
+    prices?: PricesType;
+    saleConstraints?: PriceBandSaleConstraintsType;
+    uom?: UomType;
+};
+export declare type PriceBandActionFlagsType = {
+    canBeCancelled?: boolean;
+    canBeReactivated?: boolean;
+    canBeSuspended?: boolean;
+    canDecreaseSeats?: boolean;
+    canIncreaseSeats?: boolean;
+};
+export declare type AttributeType = {
+    name?: string;
+    value?: string;
+};
+export declare type BillingType = {
+    cycle?: number;
+    term?: number;
+    type?: string;
+};
+export declare type DynamicAttributesType = {
+    diskSize?: string;
+    ram?: string;
+    region?: string;
+    vCpu?: string;
+    reservationsAutofitGroup?: string;
+    acu?: string;
+    marketSegment?: string;
+    version?: string;
+    metric?: string;
+};
+export declare type PriceBandIdentifiersType = {
+    arrowsphere?: PriceBandArrowsphereIdentifierType;
+    erp?: ErpIdentifierType;
+    vendor?: PriceBandVendorIdentifierType;
+};
+export declare type PriceBandArrowsphereIdentifierType = {
+    sku?: string;
+};
+export declare type ErpIdentifierType = {
+    sku?: string;
+};
+export declare type PriceBandVendorIdentifierType = {
+    purchasePlan?: string;
+    sku?: string;
+};
+export declare type PricesType = {
+    buy?: string;
+    sell?: string;
+    public?: string;
+};
+export declare type PriceBandSaleConstraintsType = {
+    availableDate?: string;
+    expiryDate?: string;
+    minQuantity?: number;
+    maxQuantity?: number;
+};
+export declare type UomType = {
+    quantity?: number;
+    type?: string;
+};
+export declare type RelatedOfferType = {
+    vendor?: string;
+    sku?: string;
+};
+export declare type OfferResellersType = {
+    owner?: ResellerType;
+    viewers?: Array<ResellerType>;
+};
+export declare type ResellerType = {
+    xspRef?: string;
+};

package/build/catalog/types/catalogGraphQLTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=catalogGraphQLTypes.js.map

package/build/customers/customersClient.d.ts

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

package/build/customers/customersClient.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomersClient = void 0;
+const abstractClient_1 = require("../abstractClient");
+const getResult_1 = require("../getResult");
+const dataCustomers_1 = require("./entities/dataCustomers");
+class CustomersClient extends abstractClient_1.AbstractClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * The base path of the Customers API
+         */
+        this.ROOT_PATH = '/customers';
+    }
+    async getCustomers(parameters = {}) {
+        this.path = this.ROOT_PATH;
+        return new getResult_1.GetResult(dataCustomers_1.DataCustomers, await this.get(parameters));
+    }
+}
+exports.CustomersClient = CustomersClient;
+//# sourceMappingURL=customersClient.js.map

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

@@ -0,0 +1,28 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum ContactFields {
+    COLUMN_FIRSTNAME = "FirstName",
+    COLUMN_LASTNAME = "LastName",
+    COLUMN_EMAIL = "Email",
+    COLUMN_PHONE = "Phone",
+    COLUMN_SYNC_PARTNER_CONTACT_REF_ID = "SyncPartnerContactRefId",
+    COLUMN_CONTACT_PERSON_ID = "ContactPersonID"
+}
+export declare type ContactType = {
+    [ContactFields.COLUMN_FIRSTNAME]: string;
+    [ContactFields.COLUMN_LASTNAME]: string;
+    [ContactFields.COLUMN_EMAIL]: string;
+    [ContactFields.COLUMN_PHONE]: string;
+    [ContactFields.COLUMN_SYNC_PARTNER_CONTACT_REF_ID]?: number;
+    [ContactFields.COLUMN_CONTACT_PERSON_ID]: string;
+};
+export declare class Contact extends AbstractEntity<ContactType> {
+    #private;
+    constructor(getCustomersContactDataInput: ContactType);
+    get FirstName(): string;
+    get LastName(): string;
+    get Email(): string;
+    get Phone(): string;
+    get SyncPartnerContactRefId(): number | undefined;
+    get ContactPersonID(): string;
+    toJSON(): ContactType;
+}

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

@@ -0,0 +1,77 @@
+"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 _firstname, _lastname, _email, _phone, _syncPartnerContactRefId, _contactPersonId;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contact = exports.ContactFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var ContactFields;
+(function (ContactFields) {
+    ContactFields["COLUMN_FIRSTNAME"] = "FirstName";
+    ContactFields["COLUMN_LASTNAME"] = "LastName";
+    ContactFields["COLUMN_EMAIL"] = "Email";
+    ContactFields["COLUMN_PHONE"] = "Phone";
+    ContactFields["COLUMN_SYNC_PARTNER_CONTACT_REF_ID"] = "SyncPartnerContactRefId";
+    ContactFields["COLUMN_CONTACT_PERSON_ID"] = "ContactPersonID";
+})(ContactFields = exports.ContactFields || (exports.ContactFields = {}));
+class Contact extends abstractEntity_1.AbstractEntity {
+    constructor(getCustomersContactDataInput) {
+        var _a;
+        super(getCustomersContactDataInput);
+        _firstname.set(this, void 0);
+        _lastname.set(this, void 0);
+        _email.set(this, void 0);
+        _phone.set(this, void 0);
+        _syncPartnerContactRefId.set(this, void 0);
+        _contactPersonId.set(this, void 0);
+        __classPrivateFieldSet(this, _firstname, getCustomersContactDataInput[ContactFields.COLUMN_FIRSTNAME]);
+        __classPrivateFieldSet(this, _lastname, getCustomersContactDataInput[ContactFields.COLUMN_LASTNAME]);
+        __classPrivateFieldSet(this, _email, getCustomersContactDataInput[ContactFields.COLUMN_EMAIL]);
+        __classPrivateFieldSet(this, _phone, getCustomersContactDataInput[ContactFields.COLUMN_PHONE]);
+        __classPrivateFieldSet(this, _syncPartnerContactRefId, (_a = getCustomersContactDataInput[ContactFields.COLUMN_SYNC_PARTNER_CONTACT_REF_ID]) !== null && _a !== void 0 ? _a : undefined);
+        __classPrivateFieldSet(this, _contactPersonId, getCustomersContactDataInput[ContactFields.COLUMN_CONTACT_PERSON_ID]);
+    }
+    get FirstName() {
+        return __classPrivateFieldGet(this, _firstname);
+    }
+    get LastName() {
+        return __classPrivateFieldGet(this, _lastname);
+    }
+    get Email() {
+        return __classPrivateFieldGet(this, _email);
+    }
+    get Phone() {
+        return __classPrivateFieldGet(this, _phone);
+    }
+    get SyncPartnerContactRefId() {
+        return __classPrivateFieldGet(this, _syncPartnerContactRefId);
+    }
+    get ContactPersonID() {
+        return __classPrivateFieldGet(this, _contactPersonId);
+    }
+    toJSON() {
+        return {
+            [ContactFields.COLUMN_FIRSTNAME]: this.FirstName,
+            [ContactFields.COLUMN_LASTNAME]: this.LastName,
+            [ContactFields.COLUMN_EMAIL]: this.Email,
+            [ContactFields.COLUMN_PHONE]: this.Phone,
+            [ContactFields.COLUMN_SYNC_PARTNER_CONTACT_REF_ID]: this
+                .SyncPartnerContactRefId,
+            [ContactFields.COLUMN_CONTACT_PERSON_ID]: this.ContactPersonID,
+        };
+    }
+}
+exports.Contact = Contact;
+_firstname = new WeakMap(), _lastname = new WeakMap(), _email = new WeakMap(), _phone = new WeakMap(), _syncPartnerContactRefId = new WeakMap(), _contactPersonId = new WeakMap();
+//# sourceMappingURL=contact.js.map

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

@@ -0,0 +1,72 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { Contact, ContactType } from './contact/contact';
+import { Details, DetailsType } from './details/details';
+export declare enum CustomerFields {
+    COLUMN_REFERENCE = "Reference",
+    COLUMN_COMPANY_NAME = "CompanyName",
+    COLUMN_PARTNER_COMPANY_ID = "PartnerCompanyId",
+    COLUMN_ADDRESS_LINE_1 = "AddressLine1",
+    COLUMN_ADDRESS_LINE_2 = "AddressLine2",
+    COLUMN_ZIP = "Zip",
+    COLUMN_CITY = "City",
+    COLUMN_COUNTRY_CODE = "CountryCode",
+    COLUMN_STATE = "State",
+    COLUMN_RECEPTION_PHONE = "ReceptionPhone",
+    COLUMN_WEBSITE_URL = "WebsiteUrl",
+    COLUMN_EMAIL_CONTACT = "EmailContact",
+    COLUMN_HEADCOUNT = "Headcount",
+    COLUMN_TAX_NUMBER = "TaxNumber",
+    COLUMN_REF = "Ref",
+    COLUMN_BILLING_ID = "BillingId",
+    COLUMN_INTERNAL_REFERENCE = "InternalReference",
+    COLUMN_CONTACT = "Contact",
+    COLUMN_DETAILS = "Details",
+    COLUMN_DELETED_AT = "DeletedAt"
+}
+export declare type CustomerType = {
+    [CustomerFields.COLUMN_REFERENCE]: string;
+    [CustomerFields.COLUMN_COMPANY_NAME]: string;
+    [CustomerFields.COLUMN_PARTNER_COMPANY_ID]: string;
+    [CustomerFields.COLUMN_ADDRESS_LINE_1]?: string;
+    [CustomerFields.COLUMN_ADDRESS_LINE_2]?: string;
+    [CustomerFields.COLUMN_ZIP]: string;
+    [CustomerFields.COLUMN_CITY]: string;
+    [CustomerFields.COLUMN_COUNTRY_CODE]: string;
+    [CustomerFields.COLUMN_STATE]: string;
+    [CustomerFields.COLUMN_RECEPTION_PHONE]: string;
+    [CustomerFields.COLUMN_WEBSITE_URL]: string;
+    [CustomerFields.COLUMN_EMAIL_CONTACT]: string;
+    [CustomerFields.COLUMN_HEADCOUNT]: number;
+    [CustomerFields.COLUMN_TAX_NUMBER]: string;
+    [CustomerFields.COLUMN_REF]: string;
+    [CustomerFields.COLUMN_BILLING_ID]: string;
+    [CustomerFields.COLUMN_INTERNAL_REFERENCE]: string;
+    [CustomerFields.COLUMN_CONTACT]: ContactType;
+    [CustomerFields.COLUMN_DETAILS]: DetailsType;
+    [CustomerFields.COLUMN_DELETED_AT]?: string | null;
+};
+export declare class Customer extends AbstractEntity<CustomerType> {
+    #private;
+    constructor(getCustomersDataInput: CustomerType);
+    get Reference(): string;
+    get CompanyName(): string;
+    get PartnerCompanyId(): string;
+    get AddressLine1(): string | undefined;
+    get AddressLine2(): string | undefined;
+    get Zip(): string;
+    get City(): string;
+    get CountryCode(): string;
+    get State(): string;
+    get ReceptionPhone(): string;
+    get WebsiteUrl(): string;
+    get EmailContact(): string;
+    get Headcount(): number;
+    get TaxNumber(): string;
+    get Ref(): string;
+    get BillingId(): string;
+    get InternalReference(): string;
+    get Contact(): Contact;
+    get Details(): Details;
+    get DeletedAt(): string | null | undefined;
+    toJSON(): CustomerType;
+}