@arrowsphere/api-client 3.25.0-rc.wev.1 → 3.26.0-rc.1

package/CHANGELOG.md

@@ -3,13 +3,25 @@
 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.26.0] - 2023-04-20
+
+### Changed
+
+- Add support center endpoints
+
 ## [3.25.0] - 2023-04-13
 
 ### Changed
 
 - Add `isManualProvisioning` field in license event offer
 
-## [3.24.0] - 2023-04-07
+## [3.24.1] - 2023-04-13
+
+### Changed
+
+- Fix Extra information type
+
+## [3.24.0] - 2023-04-13
 
 ### Changed
 

package/build/abstractClient.d.ts

@@ -15,9 +15,16 @@ export declare enum ParameterKeys {
 export declare enum ExtraInformationFields {
     COLUMN_EXTRA_INFORMATION = "extraInformation"
 }
+export declare type ParametersWithPaginationType = (Parameters & {
+    [ParameterKeys.PAGE]?: number;
+    [ParameterKeys.PER_PAGE]?: number;
+}) | (Parameters & {
+    [ParameterKeys.PAGE]?: number;
+    [ParameterKeys.PER_PAGE_CAMEL]?: number;
+});
 export declare type Parameters = Record<string, string | string[] | number | number[] | boolean | null | undefined>;
 export declare type Headers = Record<string, string>;
-export declare type Payload = Record<string, unknown>;
+export declare type Payload = Record<string, unknown> | Array<Payload>;
 export declare type Options = {
     isAdmin?: boolean;
 };
@@ -26,7 +33,9 @@ export declare type ConfigurationsClient = {
     [ParameterKeys.URL]?: string;
     [ParameterKeys.HEADERS]?: Headers;
 };
-export declare type ExtraInformationType = Record<string, unknown>;
+export declare type ExtraInformationType = {
+    [ExtraInformationFields.COLUMN_EXTRA_INFORMATION]?: Record<string, unknown>;
+};
 export declare abstract class AbstractClient {
     /**
      * Base path for HTTP calls

package/build/index.d.ts

@@ -18,5 +18,6 @@ export * from './publicGraphQLClient';
 export * from './shared/';
 export * from './security/';
 export * from './subscriptions/';
+export * from './supportCenter/';
 export { ContactInformation };
 import * as ContactInformation from './contact';

package/build/index.js

@@ -43,6 +43,7 @@ __exportStar(require("./publicGraphQLClient"), exports);
 __exportStar(require("./shared/"), exports);
 __exportStar(require("./security/"), exports);
 __exportStar(require("./subscriptions/"), exports);
+__exportStar(require("./supportCenter/"), exports);
 const ContactInformation = __importStar(require("./contact"));
 exports.ContactInformation = ContactInformation;
 //# sourceMappingURL=index.js.map

package/build/licenses/entities/event/licenseEvent.d.ts

@@ -35,7 +35,7 @@ export interface LicenseEventPriceband {
 export interface LicenseEventOffer {
     arrowsphereSku: string;
     name: string;
-    isManualProvisioning: boolean;
+    isManualProvisioning: boolean | null;
 }
 export interface LicenseEventQuantity {
     current: number;

package/build/licenses/licensesClient.d.ts

@@ -1,7 +1,7 @@
 /**
  * Class LicensesClient
  */
-import { AbstractClient, ExtraInformationFields, ExtraInformationType, Parameters } from '../abstractClient';
+import { AbstractClient, ExtraInformationType, Parameters } from '../abstractClient';
 import { FindConfig, FindData, FindResult } from './entities/findResult';
 import { ConfigFindResult, ConfigFindResultData, ConfigFindResultDataKeywords, ConfigFindResultDataSortParameters } from './entities/license/configFindResult';
 import { LicenceFindDataFiltersParameters, LicenceFindDataKeywords, LicenceFindDataSortParameters } from './entities/license/licenseFindResult';
@@ -190,27 +190,15 @@ export declare type LicenseFindRawPayload = {
 };
 export declare type UpdateSeatsData = {
     [LicenseGetFields.COLUMN_SEATS]: number;
-    [ExtraInformationFields.COLUMN_EXTRA_INFORMATION]?: ExtraInformationType;
-};
+} & ExtraInformationType;
 export declare type PutFriendlyName = {
     [LicenseGetFields.COLUMN_FRIENDLY_NAME]: string;
-    [ExtraInformationFields.COLUMN_EXTRA_INFORMATION]?: ExtraInformationType;
-};
-export declare type PutReactivate = {
-    [ExtraInformationFields.COLUMN_EXTRA_INFORMATION]?: ExtraInformationType;
-};
-export declare type PutSuspend = {
-    [ExtraInformationFields.COLUMN_EXTRA_INFORMATION]?: ExtraInformationType;
-};
-export declare type PutCancel = {
-    [ExtraInformationFields.COLUMN_EXTRA_INFORMATION]?: ExtraInformationType;
-};
-export declare type PutCancelAutoRenew = {
-    [ExtraInformationFields.COLUMN_EXTRA_INFORMATION]?: ExtraInformationType;
-};
-export declare type PutReactivateAutoRenew = {
-    [ExtraInformationFields.COLUMN_EXTRA_INFORMATION]?: ExtraInformationType;
-};
+} & ExtraInformationType;
+export declare type PutReactivate = ExtraInformationType;
+export declare type PutSuspend = ExtraInformationType;
+export declare type PutCancel = ExtraInformationType;
+export declare type PutCancelAutoRenew = ExtraInformationType;
+export declare type PutReactivateAutoRenew = ExtraInformationType;
 export declare class LicensesClient extends AbstractClient {
     /**
      * The base path of the API

package/build/publicApiClient.d.ts

@@ -10,6 +10,7 @@ import { ConsumptionClient } from './consumption';
 import { StandardsClient } from './security/standards/standardsClient';
 import { RegisterClient } from './security';
 import { CartClient } from './cart/cartClient';
+import { SupportCenterClient } from './supportCenter';
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -59,5 +60,6 @@ export declare class PublicApiClient extends AbstractClient {
     getSecurityStandardsClient(): StandardsClient;
     getSecurityRegisterClient(): RegisterClient;
     getCartClient(): CartClient;
+    getSupportCenterClient(): SupportCenterClient;
 }
 export default PublicApiClient;

package/build/publicApiClient.js

@@ -13,6 +13,7 @@ const consumption_1 = require("./consumption");
 const standardsClient_1 = require("./security/standards/standardsClient");
 const security_1 = require("./security");
 const cartClient_1 = require("./cart/cartClient");
+const supportCenter_1 = require("./supportCenter");
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -124,6 +125,12 @@ class PublicApiClient extends abstractClient_1.AbstractClient {
             .setApiKey(this.apiKey)
             .setHeaders(this.headers);
     }
+    getSupportCenterClient() {
+        return new supportCenter_1.SupportCenterClient()
+            .setUrl(this.url)
+            .setApiKey(this.apiKey)
+            .setHeaders(this.headers);
+    }
 }
 exports.PublicApiClient = PublicApiClient;
 exports.default = PublicApiClient;

package/build/supportCenter/entities/issue/attachment.d.ts

@@ -0,0 +1,29 @@
+import { AbstractEntity } from '../../../abstractEntity';
+export declare enum IssueAttachmentFields {
+    COLUMN_ID = "id",
+    COLUMN_FILE_NAME = "fileName",
+    COLUMN_MIME_TYPE = "mimeType",
+    COLUMN_CONTENT = "content"
+}
+export declare type IssueAttachmentType = {
+    [IssueAttachmentFields.COLUMN_ID]: string;
+    [IssueAttachmentFields.COLUMN_FILE_NAME]: string;
+    [IssueAttachmentFields.COLUMN_MIME_TYPE]: string;
+    [IssueAttachmentFields.COLUMN_CONTENT]: string;
+};
+export declare class IssueAttachment extends AbstractEntity<IssueAttachmentType> {
+    #private;
+    constructor(input: IssueAttachmentType);
+    get id(): string;
+    get fileName(): string;
+    get mimeType(): string;
+    get content(): string;
+    toJSON(): IssueAttachmentType;
+}
+export declare type IssueAttachmentsType = Array<IssueAttachmentType>;
+export declare class IssueAttachments extends AbstractEntity<IssueAttachmentsType> {
+    #private;
+    constructor(input: IssueAttachmentsType);
+    get list(): IssueAttachment[];
+    toJSON(): IssueAttachmentsType;
+}

package/build/supportCenter/entities/issue/attachment.js

@@ -0,0 +1,76 @@
+"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 _id, _fileName, _mimeType, _content, _list;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueAttachments = exports.IssueAttachment = exports.IssueAttachmentFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+var IssueAttachmentFields;
+(function (IssueAttachmentFields) {
+    IssueAttachmentFields["COLUMN_ID"] = "id";
+    IssueAttachmentFields["COLUMN_FILE_NAME"] = "fileName";
+    IssueAttachmentFields["COLUMN_MIME_TYPE"] = "mimeType";
+    IssueAttachmentFields["COLUMN_CONTENT"] = "content";
+})(IssueAttachmentFields = exports.IssueAttachmentFields || (exports.IssueAttachmentFields = {}));
+class IssueAttachment extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _id.set(this, void 0);
+        _fileName.set(this, void 0);
+        _mimeType.set(this, void 0);
+        _content.set(this, void 0);
+        __classPrivateFieldSet(this, _id, input[IssueAttachmentFields.COLUMN_ID]);
+        __classPrivateFieldSet(this, _fileName, input[IssueAttachmentFields.COLUMN_FILE_NAME]);
+        __classPrivateFieldSet(this, _mimeType, input[IssueAttachmentFields.COLUMN_MIME_TYPE]);
+        __classPrivateFieldSet(this, _content, input[IssueAttachmentFields.COLUMN_CONTENT]);
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _id);
+    }
+    get fileName() {
+        return __classPrivateFieldGet(this, _fileName);
+    }
+    get mimeType() {
+        return __classPrivateFieldGet(this, _mimeType);
+    }
+    get content() {
+        return __classPrivateFieldGet(this, _content);
+    }
+    toJSON() {
+        return {
+            [IssueAttachmentFields.COLUMN_ID]: this.id,
+            [IssueAttachmentFields.COLUMN_FILE_NAME]: this.fileName,
+            [IssueAttachmentFields.COLUMN_MIME_TYPE]: this.mimeType,
+            [IssueAttachmentFields.COLUMN_CONTENT]: this.content,
+        };
+    }
+}
+exports.IssueAttachment = IssueAttachment;
+_id = new WeakMap(), _fileName = new WeakMap(), _mimeType = new WeakMap(), _content = new WeakMap();
+class IssueAttachments extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _list.set(this, void 0);
+        __classPrivateFieldSet(this, _list, input.map((item) => new IssueAttachment(item)));
+    }
+    get list() {
+        return __classPrivateFieldGet(this, _list);
+    }
+    toJSON() {
+        return this.list.map((item) => item.toJSON());
+    }
+}
+exports.IssueAttachments = IssueAttachments;
+_list = new WeakMap();
+//# sourceMappingURL=attachment.js.map

package/build/supportCenter/entities/issue/comment.d.ts

@@ -0,0 +1,30 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { IssueCreatedBy, IssueCreatedByType } from './issue';
+export declare enum IssueCommentFields {
+    COLUMN_ID = "id",
+    COLUMN_BODY = "body",
+    COLUMN_DATE = "date",
+    COLUMN_CREATED_BY = "createdBy"
+}
+export declare type IssueCommentType = {
+    [IssueCommentFields.COLUMN_ID]: string;
+    [IssueCommentFields.COLUMN_BODY]: string;
+    [IssueCommentFields.COLUMN_DATE]: string;
+    [IssueCommentFields.COLUMN_CREATED_BY]: IssueCreatedByType;
+};
+export declare class IssueComment extends AbstractEntity<IssueCommentType> {
+    #private;
+    constructor(input: IssueCommentType);
+    get id(): string;
+    get body(): string;
+    get date(): Date;
+    get createdBy(): IssueCreatedBy;
+    toJSON(): IssueCommentType;
+}
+export declare type IssueCommentsType = Array<IssueCommentType>;
+export declare class IssueComments extends AbstractEntity<IssueCommentsType> {
+    #private;
+    constructor(input: IssueCommentsType);
+    get list(): IssueComment[];
+    toJSON(): IssueCommentsType;
+}

package/build/supportCenter/entities/issue/comment.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 _id, _body, _date, _createdBy, _list;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueComments = exports.IssueComment = exports.IssueCommentFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const issue_1 = require("./issue");
+var IssueCommentFields;
+(function (IssueCommentFields) {
+    IssueCommentFields["COLUMN_ID"] = "id";
+    IssueCommentFields["COLUMN_BODY"] = "body";
+    IssueCommentFields["COLUMN_DATE"] = "date";
+    IssueCommentFields["COLUMN_CREATED_BY"] = "createdBy";
+})(IssueCommentFields = exports.IssueCommentFields || (exports.IssueCommentFields = {}));
+class IssueComment extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _id.set(this, void 0);
+        _body.set(this, void 0);
+        _date.set(this, void 0);
+        _createdBy.set(this, void 0);
+        __classPrivateFieldSet(this, _id, input[IssueCommentFields.COLUMN_ID]);
+        __classPrivateFieldSet(this, _body, input[IssueCommentFields.COLUMN_BODY]);
+        __classPrivateFieldSet(this, _date, new Date(input[IssueCommentFields.COLUMN_DATE]));
+        __classPrivateFieldSet(this, _createdBy, new issue_1.IssueCreatedBy(input[IssueCommentFields.COLUMN_CREATED_BY]));
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _id);
+    }
+    get body() {
+        return __classPrivateFieldGet(this, _body);
+    }
+    get date() {
+        return __classPrivateFieldGet(this, _date);
+    }
+    get createdBy() {
+        return __classPrivateFieldGet(this, _createdBy);
+    }
+    toJSON() {
+        return {
+            [IssueCommentFields.COLUMN_ID]: this.id,
+            [IssueCommentFields.COLUMN_BODY]: this.body,
+            [IssueCommentFields.COLUMN_DATE]: this.date.toISOString(),
+            [IssueCommentFields.COLUMN_CREATED_BY]: this.createdBy.toJSON(),
+        };
+    }
+}
+exports.IssueComment = IssueComment;
+_id = new WeakMap(), _body = new WeakMap(), _date = new WeakMap(), _createdBy = new WeakMap();
+class IssueComments extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _list.set(this, void 0);
+        __classPrivateFieldSet(this, _list, input.map((item) => new IssueComment(item)));
+    }
+    get list() {
+        return __classPrivateFieldGet(this, _list);
+    }
+    toJSON() {
+        return this.list.map((item) => item.toJSON());
+    }
+}
+exports.IssueComments = IssueComments;
+_list = new WeakMap();
+//# sourceMappingURL=comment.js.map

package/build/supportCenter/entities/issue/issue.d.ts

@@ -0,0 +1,142 @@
+import { AbstractEntity } from '../../../abstractEntity';
+export declare enum IssueFields {
+    COLUMN_ID = "id",
+    COLUMN_TITLE = "title",
+    COLUMN_DESCRIPTION = "description",
+    COLUMN_TOPIC_ID = "topicId",
+    COLUMN_END_CUSTOMER_REF = "endCustomerRef",
+    COLUMN_LANGUAGE = "language",
+    COLUMN_OFFER = "offer",
+    COLUMN_PRIORITY = "priority",
+    COLUMN_STATUS = "status",
+    COLUMN_CREATED_BY = "createdBy",
+    COLUMN_SUPPORT_PLAN = "supportPlan",
+    COLUMN_PROGRAM = "program",
+    COLUMN_ADDITIONAL_DATA = "additionalData",
+    COLUMN_CREATED = "created",
+    COLUMN_UPDATED = "updated"
+}
+export declare enum IssueOfferFields {
+    COLUMN_SKU = "sku",
+    COLUMN_NAME = "name",
+    COLUMN_VENDOR = "vendor"
+}
+export declare enum IssueCreatedByFields {
+    COLUMN_EMAIL = "email",
+    COLUMN_FIRST_NAME = "firstName",
+    COLUMN_LAST_NAME = "lastName",
+    COLUMN_PHONE = "phone"
+}
+export declare enum IssueSupportPlanFields {
+    COLUMN_LABEL = "label",
+    COLUMN_SKU = "sku",
+    COLUMN_SOURCE_PORTAL = "sourcePortal"
+}
+export declare enum IssueAdditionalDataFields {
+    COLUMN_NAME = "name",
+    COLUMN_VALUE = "value"
+}
+export declare type IssueOfferType = {
+    [IssueOfferFields.COLUMN_SKU]: string;
+    [IssueOfferFields.COLUMN_NAME]: string;
+    [IssueOfferFields.COLUMN_VENDOR]: string;
+};
+export declare enum IssueStatusesType {
+    PENDING_CUSTOMER = "PENDING_CUSTOMER",
+    PENDING_VENDOR = "PENDING_VENDOR",
+    PENDING_ARROW = "PENDING_ARROW",
+    ON_HOLD = "ON_HOLD",
+    CLOSED = "CLOSED",
+    PENDING_CLOSE = "PENDING_CLOSE"
+}
+export declare type IssueCreatedByType = {
+    [IssueCreatedByFields.COLUMN_EMAIL]: string;
+    [IssueCreatedByFields.COLUMN_FIRST_NAME]: string;
+    [IssueCreatedByFields.COLUMN_LAST_NAME]: string;
+    [IssueCreatedByFields.COLUMN_PHONE]: string;
+};
+export declare type IssueSupportPlanType = {
+    [IssueSupportPlanFields.COLUMN_SKU]: string;
+    [IssueSupportPlanFields.COLUMN_LABEL]: string;
+    [IssueSupportPlanFields.COLUMN_SOURCE_PORTAL]: string;
+};
+export declare type IssueAdditionalDataType = {
+    [IssueAdditionalDataFields.COLUMN_NAME]: string;
+    [IssueAdditionalDataFields.COLUMN_VALUE]: string;
+};
+export declare type IssueType = {
+    [IssueFields.COLUMN_ID]: string;
+    [IssueFields.COLUMN_TITLE]: string;
+    [IssueFields.COLUMN_DESCRIPTION]: string;
+    [IssueFields.COLUMN_TOPIC_ID]: string;
+    [IssueFields.COLUMN_END_CUSTOMER_REF]: string;
+    [IssueFields.COLUMN_LANGUAGE]: string;
+    [IssueFields.COLUMN_OFFER]: IssueOfferType;
+    [IssueFields.COLUMN_PRIORITY]: number;
+    [IssueFields.COLUMN_STATUS]: string;
+    [IssueFields.COLUMN_CREATED_BY]: IssueCreatedByType;
+    [IssueFields.COLUMN_SUPPORT_PLAN]: IssueSupportPlanType;
+    [IssueFields.COLUMN_PROGRAM]: string;
+    [IssueFields.COLUMN_ADDITIONAL_DATA]: Array<IssueAdditionalDataType>;
+    [IssueFields.COLUMN_CREATED]: string;
+    [IssueFields.COLUMN_UPDATED]: string;
+};
+export declare class IssueOffer extends AbstractEntity<IssueOfferType> {
+    #private;
+    constructor(input: IssueOfferType);
+    get sku(): string;
+    get name(): string;
+    get vendor(): string;
+    toJSON(): IssueOfferType;
+}
+export declare class IssueCreatedBy extends AbstractEntity<IssueCreatedByType> {
+    #private;
+    constructor(input: IssueCreatedByType);
+    get email(): string;
+    get firstName(): string;
+    get lastName(): string;
+    get phone(): string;
+    toJSON(): IssueCreatedByType;
+}
+export declare class IssueSupportPlan extends AbstractEntity<IssueSupportPlanType> {
+    #private;
+    constructor(input: IssueSupportPlanType);
+    get sku(): string;
+    get label(): string;
+    get sourcePortal(): string;
+    toJSON(): IssueSupportPlanType;
+}
+export declare class IssueAdditionalData extends AbstractEntity<IssueAdditionalDataType> {
+    #private;
+    constructor(input: IssueAdditionalDataType);
+    get name(): string;
+    get value(): string;
+    toJSON(): IssueAdditionalDataType;
+}
+export declare class Issue extends AbstractEntity<IssueType> {
+    #private;
+    constructor(input: IssueType);
+    get id(): string;
+    get title(): string;
+    get description(): string;
+    get topicId(): string;
+    get endCustomerRef(): string;
+    get language(): string;
+    get offer(): IssueOffer;
+    get priority(): number;
+    get status(): string;
+    get createdBy(): IssueCreatedBy;
+    get supportPlan(): IssueSupportPlan;
+    get program(): string;
+    get additionalData(): Array<IssueAdditionalData>;
+    get created(): Date;
+    get updated(): Date;
+    toJSON(): IssueType;
+}
+export declare type IssuesType = Array<IssueType>;
+export declare class Issues extends AbstractEntity<IssuesType> {
+    #private;
+    constructor(input: IssuesType);
+    get list(): Issue[];
+    toJSON(): IssuesType;
+}

package/build/supportCenter/entities/issue/issue.js

@@ -0,0 +1,302 @@
+"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, _name, _vendor, _email, _firstName, _lastName, _phone, _sku_1, _label, _sourcePortal, _name_1, _value, _id, _title, _description, _topicId, _endCustomerRef, _language, _offer, _priority, _status, _createdBy, _supportPlan, _program, _additionalData, _created, _updated, _list;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Issues = exports.Issue = exports.IssueAdditionalData = exports.IssueSupportPlan = exports.IssueCreatedBy = exports.IssueOffer = exports.IssueStatusesType = exports.IssueAdditionalDataFields = exports.IssueSupportPlanFields = exports.IssueCreatedByFields = exports.IssueOfferFields = exports.IssueFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+var IssueFields;
+(function (IssueFields) {
+    IssueFields["COLUMN_ID"] = "id";
+    IssueFields["COLUMN_TITLE"] = "title";
+    IssueFields["COLUMN_DESCRIPTION"] = "description";
+    IssueFields["COLUMN_TOPIC_ID"] = "topicId";
+    IssueFields["COLUMN_END_CUSTOMER_REF"] = "endCustomerRef";
+    IssueFields["COLUMN_LANGUAGE"] = "language";
+    IssueFields["COLUMN_OFFER"] = "offer";
+    IssueFields["COLUMN_PRIORITY"] = "priority";
+    IssueFields["COLUMN_STATUS"] = "status";
+    IssueFields["COLUMN_CREATED_BY"] = "createdBy";
+    IssueFields["COLUMN_SUPPORT_PLAN"] = "supportPlan";
+    IssueFields["COLUMN_PROGRAM"] = "program";
+    IssueFields["COLUMN_ADDITIONAL_DATA"] = "additionalData";
+    IssueFields["COLUMN_CREATED"] = "created";
+    IssueFields["COLUMN_UPDATED"] = "updated";
+})(IssueFields = exports.IssueFields || (exports.IssueFields = {}));
+var IssueOfferFields;
+(function (IssueOfferFields) {
+    IssueOfferFields["COLUMN_SKU"] = "sku";
+    IssueOfferFields["COLUMN_NAME"] = "name";
+    IssueOfferFields["COLUMN_VENDOR"] = "vendor";
+})(IssueOfferFields = exports.IssueOfferFields || (exports.IssueOfferFields = {}));
+var IssueCreatedByFields;
+(function (IssueCreatedByFields) {
+    IssueCreatedByFields["COLUMN_EMAIL"] = "email";
+    IssueCreatedByFields["COLUMN_FIRST_NAME"] = "firstName";
+    IssueCreatedByFields["COLUMN_LAST_NAME"] = "lastName";
+    IssueCreatedByFields["COLUMN_PHONE"] = "phone";
+})(IssueCreatedByFields = exports.IssueCreatedByFields || (exports.IssueCreatedByFields = {}));
+var IssueSupportPlanFields;
+(function (IssueSupportPlanFields) {
+    IssueSupportPlanFields["COLUMN_LABEL"] = "label";
+    IssueSupportPlanFields["COLUMN_SKU"] = "sku";
+    IssueSupportPlanFields["COLUMN_SOURCE_PORTAL"] = "sourcePortal";
+})(IssueSupportPlanFields = exports.IssueSupportPlanFields || (exports.IssueSupportPlanFields = {}));
+var IssueAdditionalDataFields;
+(function (IssueAdditionalDataFields) {
+    IssueAdditionalDataFields["COLUMN_NAME"] = "name";
+    IssueAdditionalDataFields["COLUMN_VALUE"] = "value";
+})(IssueAdditionalDataFields = exports.IssueAdditionalDataFields || (exports.IssueAdditionalDataFields = {}));
+var IssueStatusesType;
+(function (IssueStatusesType) {
+    IssueStatusesType["PENDING_CUSTOMER"] = "PENDING_CUSTOMER";
+    IssueStatusesType["PENDING_VENDOR"] = "PENDING_VENDOR";
+    IssueStatusesType["PENDING_ARROW"] = "PENDING_ARROW";
+    IssueStatusesType["ON_HOLD"] = "ON_HOLD";
+    IssueStatusesType["CLOSED"] = "CLOSED";
+    IssueStatusesType["PENDING_CLOSE"] = "PENDING_CLOSE";
+})(IssueStatusesType = exports.IssueStatusesType || (exports.IssueStatusesType = {}));
+class IssueOffer extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _sku.set(this, void 0);
+        _name.set(this, void 0);
+        _vendor.set(this, void 0);
+        __classPrivateFieldSet(this, _sku, input[IssueOfferFields.COLUMN_SKU]);
+        __classPrivateFieldSet(this, _name, input[IssueOfferFields.COLUMN_NAME]);
+        __classPrivateFieldSet(this, _vendor, input[IssueOfferFields.COLUMN_VENDOR]);
+    }
+    get sku() {
+        return __classPrivateFieldGet(this, _sku);
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _name);
+    }
+    get vendor() {
+        return __classPrivateFieldGet(this, _vendor);
+    }
+    toJSON() {
+        return {
+            [IssueOfferFields.COLUMN_SKU]: this.sku,
+            [IssueOfferFields.COLUMN_NAME]: this.name,
+            [IssueOfferFields.COLUMN_VENDOR]: this.vendor,
+        };
+    }
+}
+exports.IssueOffer = IssueOffer;
+_sku = new WeakMap(), _name = new WeakMap(), _vendor = new WeakMap();
+class IssueCreatedBy extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _email.set(this, void 0);
+        _firstName.set(this, void 0);
+        _lastName.set(this, void 0);
+        _phone.set(this, void 0);
+        __classPrivateFieldSet(this, _email, input[IssueCreatedByFields.COLUMN_EMAIL]);
+        __classPrivateFieldSet(this, _firstName, input[IssueCreatedByFields.COLUMN_FIRST_NAME]);
+        __classPrivateFieldSet(this, _lastName, input[IssueCreatedByFields.COLUMN_LAST_NAME]);
+        __classPrivateFieldSet(this, _phone, input[IssueCreatedByFields.COLUMN_PHONE]);
+    }
+    get email() {
+        return __classPrivateFieldGet(this, _email);
+    }
+    get firstName() {
+        return __classPrivateFieldGet(this, _firstName);
+    }
+    get lastName() {
+        return __classPrivateFieldGet(this, _lastName);
+    }
+    get phone() {
+        return __classPrivateFieldGet(this, _phone);
+    }
+    toJSON() {
+        return {
+            [IssueCreatedByFields.COLUMN_EMAIL]: this.email,
+            [IssueCreatedByFields.COLUMN_FIRST_NAME]: this.firstName,
+            [IssueCreatedByFields.COLUMN_LAST_NAME]: this.lastName,
+            [IssueCreatedByFields.COLUMN_PHONE]: this.phone,
+        };
+    }
+}
+exports.IssueCreatedBy = IssueCreatedBy;
+_email = new WeakMap(), _firstName = new WeakMap(), _lastName = new WeakMap(), _phone = new WeakMap();
+class IssueSupportPlan extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _sku_1.set(this, void 0);
+        _label.set(this, void 0);
+        _sourcePortal.set(this, void 0);
+        __classPrivateFieldSet(this, _sku_1, input[IssueSupportPlanFields.COLUMN_SKU]);
+        __classPrivateFieldSet(this, _label, input[IssueSupportPlanFields.COLUMN_LABEL]);
+        __classPrivateFieldSet(this, _sourcePortal, input[IssueSupportPlanFields.COLUMN_SOURCE_PORTAL]);
+    }
+    get sku() {
+        return __classPrivateFieldGet(this, _sku_1);
+    }
+    get label() {
+        return __classPrivateFieldGet(this, _label);
+    }
+    get sourcePortal() {
+        return __classPrivateFieldGet(this, _sourcePortal);
+    }
+    toJSON() {
+        return {
+            [IssueSupportPlanFields.COLUMN_SKU]: this.sku,
+            [IssueSupportPlanFields.COLUMN_LABEL]: this.label,
+            [IssueSupportPlanFields.COLUMN_SOURCE_PORTAL]: this.sourcePortal,
+        };
+    }
+}
+exports.IssueSupportPlan = IssueSupportPlan;
+_sku_1 = new WeakMap(), _label = new WeakMap(), _sourcePortal = new WeakMap();
+class IssueAdditionalData extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _name_1.set(this, void 0);
+        _value.set(this, void 0);
+        __classPrivateFieldSet(this, _name_1, input[IssueAdditionalDataFields.COLUMN_NAME]);
+        __classPrivateFieldSet(this, _value, input[IssueAdditionalDataFields.COLUMN_VALUE]);
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _name_1);
+    }
+    get value() {
+        return __classPrivateFieldGet(this, _value);
+    }
+    toJSON() {
+        return {
+            [IssueAdditionalDataFields.COLUMN_NAME]: this.name,
+            [IssueAdditionalDataFields.COLUMN_VALUE]: this.value,
+        };
+    }
+}
+exports.IssueAdditionalData = IssueAdditionalData;
+_name_1 = new WeakMap(), _value = new WeakMap();
+class Issue extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _id.set(this, void 0);
+        _title.set(this, void 0);
+        _description.set(this, void 0);
+        _topicId.set(this, void 0);
+        _endCustomerRef.set(this, void 0);
+        _language.set(this, void 0);
+        _offer.set(this, void 0);
+        _priority.set(this, void 0);
+        _status.set(this, void 0);
+        _createdBy.set(this, void 0);
+        _supportPlan.set(this, void 0);
+        _program.set(this, void 0);
+        _additionalData.set(this, void 0);
+        _created.set(this, void 0);
+        _updated.set(this, void 0);
+        __classPrivateFieldSet(this, _id, input[IssueFields.COLUMN_ID]);
+        __classPrivateFieldSet(this, _title, input[IssueFields.COLUMN_TITLE]);
+        __classPrivateFieldSet(this, _description, input[IssueFields.COLUMN_DESCRIPTION]);
+        __classPrivateFieldSet(this, _topicId, input[IssueFields.COLUMN_TOPIC_ID]);
+        __classPrivateFieldSet(this, _endCustomerRef, input[IssueFields.COLUMN_END_CUSTOMER_REF]);
+        __classPrivateFieldSet(this, _language, input[IssueFields.COLUMN_LANGUAGE]);
+        __classPrivateFieldSet(this, _offer, new IssueOffer(input[IssueFields.COLUMN_OFFER]));
+        __classPrivateFieldSet(this, _priority, input[IssueFields.COLUMN_PRIORITY]);
+        __classPrivateFieldSet(this, _status, input[IssueFields.COLUMN_STATUS]);
+        __classPrivateFieldSet(this, _createdBy, new IssueCreatedBy(input[IssueFields.COLUMN_CREATED_BY]));
+        __classPrivateFieldSet(this, _supportPlan, new IssueSupportPlan(input[IssueFields.COLUMN_SUPPORT_PLAN]));
+        __classPrivateFieldSet(this, _program, input[IssueFields.COLUMN_PROGRAM]);
+        __classPrivateFieldSet(this, _additionalData, input[IssueFields.COLUMN_ADDITIONAL_DATA].map((item) => new IssueAdditionalData(item)));
+        __classPrivateFieldSet(this, _created, new Date(input[IssueFields.COLUMN_CREATED]));
+        __classPrivateFieldSet(this, _updated, new Date(input[IssueFields.COLUMN_UPDATED]));
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _id);
+    }
+    get title() {
+        return __classPrivateFieldGet(this, _title);
+    }
+    get description() {
+        return __classPrivateFieldGet(this, _description);
+    }
+    get topicId() {
+        return __classPrivateFieldGet(this, _topicId);
+    }
+    get endCustomerRef() {
+        return __classPrivateFieldGet(this, _endCustomerRef);
+    }
+    get language() {
+        return __classPrivateFieldGet(this, _language);
+    }
+    get offer() {
+        return __classPrivateFieldGet(this, _offer);
+    }
+    get priority() {
+        return __classPrivateFieldGet(this, _priority);
+    }
+    get status() {
+        return __classPrivateFieldGet(this, _status);
+    }
+    get createdBy() {
+        return __classPrivateFieldGet(this, _createdBy);
+    }
+    get supportPlan() {
+        return __classPrivateFieldGet(this, _supportPlan);
+    }
+    get program() {
+        return __classPrivateFieldGet(this, _program);
+    }
+    get additionalData() {
+        return __classPrivateFieldGet(this, _additionalData);
+    }
+    get created() {
+        return __classPrivateFieldGet(this, _created);
+    }
+    get updated() {
+        return __classPrivateFieldGet(this, _updated);
+    }
+    toJSON() {
+        return {
+            [IssueFields.COLUMN_ID]: this.id,
+            [IssueFields.COLUMN_TITLE]: this.title,
+            [IssueFields.COLUMN_DESCRIPTION]: this.description,
+            [IssueFields.COLUMN_TOPIC_ID]: this.topicId,
+            [IssueFields.COLUMN_END_CUSTOMER_REF]: this.endCustomerRef,
+            [IssueFields.COLUMN_LANGUAGE]: this.language,
+            [IssueFields.COLUMN_OFFER]: this.offer.toJSON(),
+            [IssueFields.COLUMN_PRIORITY]: this.priority,
+            [IssueFields.COLUMN_STATUS]: this.status,
+            [IssueFields.COLUMN_CREATED_BY]: this.createdBy.toJSON(),
+            [IssueFields.COLUMN_SUPPORT_PLAN]: this.supportPlan.toJSON(),
+            [IssueFields.COLUMN_PROGRAM]: this.program,
+            [IssueFields.COLUMN_ADDITIONAL_DATA]: this.additionalData.map((item) => item.toJSON()),
+            [IssueFields.COLUMN_CREATED]: this.created.toISOString(),
+            [IssueFields.COLUMN_UPDATED]: this.updated.toISOString(),
+        };
+    }
+}
+exports.Issue = Issue;
+_id = new WeakMap(), _title = new WeakMap(), _description = new WeakMap(), _topicId = new WeakMap(), _endCustomerRef = new WeakMap(), _language = new WeakMap(), _offer = new WeakMap(), _priority = new WeakMap(), _status = new WeakMap(), _createdBy = new WeakMap(), _supportPlan = new WeakMap(), _program = new WeakMap(), _additionalData = new WeakMap(), _created = new WeakMap(), _updated = new WeakMap();
+class Issues extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _list.set(this, void 0);
+        __classPrivateFieldSet(this, _list, input.map((item) => new Issue(item)));
+    }
+    get list() {
+        return __classPrivateFieldGet(this, _list);
+    }
+    toJSON() {
+        return this.list.map((item) => item.toJSON());
+    }
+}
+exports.Issues = Issues;
+_list = new WeakMap();
+//# sourceMappingURL=issue.js.map

package/build/supportCenter/entities/topic.d.ts

@@ -0,0 +1,32 @@
+import { AbstractEntity } from '../../abstractEntity';
+export declare enum TopicFields {
+    COLUMN_ID = "id",
+    COLUMN_NAME = "name",
+    COLUMN_LABEL = "label",
+    COLUMN_PREMIUM = "premium",
+    COLUMN_DESCRIPTION = "content"
+}
+export declare type TopicType = {
+    [TopicFields.COLUMN_ID]: number;
+    [TopicFields.COLUMN_NAME]: string;
+    [TopicFields.COLUMN_LABEL]: string;
+    [TopicFields.COLUMN_PREMIUM]: boolean;
+    [TopicFields.COLUMN_DESCRIPTION]: string;
+};
+export declare class Topic extends AbstractEntity<TopicType> {
+    #private;
+    constructor(input: TopicType);
+    get id(): number;
+    get name(): string;
+    get label(): string;
+    get premium(): boolean;
+    get description(): string;
+    toJSON(): TopicType;
+}
+export declare type TopicsType = Array<TopicType>;
+export declare class Topics extends AbstractEntity<TopicsType> {
+    #private;
+    constructor(input: TopicsType);
+    get list(): Topic[];
+    toJSON(): TopicsType;
+}

package/build/supportCenter/entities/topic.js

@@ -0,0 +1,83 @@
+"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 _id, _name, _label, _premium, _description, _list;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Topics = exports.Topic = exports.TopicFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+var TopicFields;
+(function (TopicFields) {
+    TopicFields["COLUMN_ID"] = "id";
+    TopicFields["COLUMN_NAME"] = "name";
+    TopicFields["COLUMN_LABEL"] = "label";
+    TopicFields["COLUMN_PREMIUM"] = "premium";
+    TopicFields["COLUMN_DESCRIPTION"] = "content";
+})(TopicFields = exports.TopicFields || (exports.TopicFields = {}));
+class Topic extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _id.set(this, void 0);
+        _name.set(this, void 0);
+        _label.set(this, void 0);
+        _premium.set(this, void 0);
+        _description.set(this, void 0);
+        __classPrivateFieldSet(this, _id, input[TopicFields.COLUMN_ID]);
+        __classPrivateFieldSet(this, _name, input[TopicFields.COLUMN_NAME]);
+        __classPrivateFieldSet(this, _label, input[TopicFields.COLUMN_LABEL]);
+        __classPrivateFieldSet(this, _premium, input[TopicFields.COLUMN_PREMIUM]);
+        __classPrivateFieldSet(this, _description, input[TopicFields.COLUMN_DESCRIPTION]);
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _id);
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _name);
+    }
+    get label() {
+        return __classPrivateFieldGet(this, _label);
+    }
+    get premium() {
+        return __classPrivateFieldGet(this, _premium);
+    }
+    get description() {
+        return __classPrivateFieldGet(this, _description);
+    }
+    toJSON() {
+        return {
+            [TopicFields.COLUMN_ID]: this.id,
+            [TopicFields.COLUMN_NAME]: this.name,
+            [TopicFields.COLUMN_LABEL]: this.label,
+            [TopicFields.COLUMN_PREMIUM]: this.premium,
+            [TopicFields.COLUMN_DESCRIPTION]: this.description,
+        };
+    }
+}
+exports.Topic = Topic;
+_id = new WeakMap(), _name = new WeakMap(), _label = new WeakMap(), _premium = new WeakMap(), _description = new WeakMap();
+class Topics extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _list.set(this, void 0);
+        __classPrivateFieldSet(this, _list, input.map((item) => new Topic(item)));
+    }
+    get list() {
+        return __classPrivateFieldGet(this, _list);
+    }
+    toJSON() {
+        return this.list.map((item) => item.toJSON());
+    }
+}
+exports.Topics = Topics;
+_list = new WeakMap();
+//# sourceMappingURL=topic.js.map

package/build/supportCenter/index.d.ts

@@ -0,0 +1,8 @@
+export * from './entities/topic';
+export * from './entities/issue/issue';
+export * from './entities/issue/comment';
+export * from './entities/issue/attachment';
+export * from './payloads/issue';
+export * from './payloads/comment';
+export * from './payloads/attachment';
+export * from './supportCenterClient';

package/build/supportCenter/index.js

@@ -0,0 +1,21 @@
+"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/topic"), exports);
+__exportStar(require("./entities/issue/issue"), exports);
+__exportStar(require("./entities/issue/comment"), exports);
+__exportStar(require("./entities/issue/attachment"), exports);
+__exportStar(require("./payloads/issue"), exports);
+__exportStar(require("./payloads/comment"), exports);
+__exportStar(require("./payloads/attachment"), exports);
+__exportStar(require("./supportCenterClient"), exports);
+//# sourceMappingURL=index.js.map

package/build/supportCenter/payloads/attachment.d.ts

@@ -0,0 +1,6 @@
+import { IssueAttachmentFields } from '../entities/issue/attachment';
+export declare type AddIssueAttachmentPayload = {
+    [IssueAttachmentFields.COLUMN_FILE_NAME]: string;
+    [IssueAttachmentFields.COLUMN_MIME_TYPE]: string;
+    [IssueAttachmentFields.COLUMN_CONTENT]: string;
+};

package/build/supportCenter/payloads/attachment.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const attachment_1 = require("../entities/issue/attachment");
+//# sourceMappingURL=attachment.js.map

package/build/supportCenter/payloads/comment.d.ts

@@ -0,0 +1,6 @@
+import { IssueCreatedByType } from '../entities/issue/issue';
+import { IssueCommentFields } from '../entities/issue/comment';
+export declare type AddIssueCommentPayload = {
+    [IssueCommentFields.COLUMN_BODY]: string;
+    [IssueCommentFields.COLUMN_CREATED_BY]?: IssueCreatedByType;
+};

package/build/supportCenter/payloads/comment.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const comment_1 = require("../entities/issue/comment");
+//# sourceMappingURL=comment.js.map

package/build/supportCenter/payloads/issue.d.ts

@@ -0,0 +1,32 @@
+import { IssueAdditionalDataType, IssueCreatedByType, IssueFields, IssueOfferType, IssueStatusesType } from '../entities/issue/issue';
+import { Payload } from '../../abstractClient';
+export declare enum IssueProgramsType {
+    MSCSP = "MSCSP",
+    ARWS_AMS = "ARWS-AMS"
+}
+export declare type CreateIssuePayload = {
+    [IssueFields.COLUMN_TITLE]: string;
+    [IssueFields.COLUMN_DESCRIPTION]: string;
+    [IssueFields.COLUMN_TOPIC_ID]: string;
+    [IssueFields.COLUMN_PROGRAM]: IssueProgramsType;
+    [IssueFields.COLUMN_OFFER]?: IssueOfferType;
+    [IssueFields.COLUMN_CREATED_BY]?: IssueCreatedByType;
+    [IssueFields.COLUMN_END_CUSTOMER_REF]?: string;
+    [IssueFields.COLUMN_ADDITIONAL_DATA]?: Array<IssueAdditionalDataType>;
+};
+export declare type UpdateIssueStatusOperation = {
+    op: 'replace';
+    path: 'status';
+    value: IssueStatusesType.CLOSED;
+};
+export declare enum StatusDetailsValueEnum {
+    RESOLVED = "RESOLVED",
+    CANCELLED = "CANCELLED",
+    SELF_RESOLVED = "SELF_RESOLVED"
+}
+export declare type UpdateIssueStatusDetailsOperation = {
+    op: 'replace';
+    path: 'statusDetails';
+    value: StatusDetailsValueEnum;
+};
+export declare type UpdateIssuePayload = [UpdateIssueStatusOperation, UpdateIssueStatusDetailsOperation] | Payload;

package/build/supportCenter/payloads/issue.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusDetailsValueEnum = exports.IssueProgramsType = void 0;
+const issue_1 = require("../entities/issue/issue");
+var IssueProgramsType;
+(function (IssueProgramsType) {
+    IssueProgramsType["MSCSP"] = "MSCSP";
+    IssueProgramsType["ARWS_AMS"] = "ARWS-AMS";
+})(IssueProgramsType = exports.IssueProgramsType || (exports.IssueProgramsType = {}));
+var StatusDetailsValueEnum;
+(function (StatusDetailsValueEnum) {
+    StatusDetailsValueEnum["RESOLVED"] = "RESOLVED";
+    StatusDetailsValueEnum["CANCELLED"] = "CANCELLED";
+    StatusDetailsValueEnum["SELF_RESOLVED"] = "SELF_RESOLVED";
+})(StatusDetailsValueEnum = exports.StatusDetailsValueEnum || (exports.StatusDetailsValueEnum = {}));
+//# sourceMappingURL=issue.js.map

package/build/supportCenter/supportCenterClient.d.ts

@@ -0,0 +1,42 @@
+import { AbstractClient, Parameters, ParametersWithPaginationType } from '../abstractClient';
+import { Issue, Issues, IssueStatusesType } from './entities/issue/issue';
+import { GetResult } from '../getResult';
+import { IssueAttachment, IssueAttachments } from './entities/issue/attachment';
+import { CreateIssuePayload, UpdateIssuePayload } from './payloads/issue';
+import { IssueComment, IssueComments } from './entities/issue/comment';
+import { AddIssueCommentPayload } from './payloads/comment';
+import { AddIssueAttachmentPayload } from './payloads/attachment';
+import { Topics } from './entities/topic';
+export declare enum ListIssueParametersFields {
+    DIR = "dir",
+    END_CUSTOMER_REF = "endCustomerRef",
+    PROGRAM = "program",
+    RESELLER_REF = "resellerRef",
+    SKU = "sku",
+    SORT = "sort",
+    STATUSES = "statuses",
+    TITLE = "title"
+}
+export declare type ListIssueParametersType = ParametersWithPaginationType & {
+    [ListIssueParametersFields.DIR]?: string;
+    [ListIssueParametersFields.END_CUSTOMER_REF]?: string;
+    [ListIssueParametersFields.PROGRAM]?: string;
+    [ListIssueParametersFields.RESELLER_REF]?: string;
+    [ListIssueParametersFields.SKU]?: string;
+    [ListIssueParametersFields.SORT]?: 'title' | 'updated' | 'status';
+    [ListIssueParametersFields.STATUSES]?: IssueStatusesType;
+    [ListIssueParametersFields.TITLE]?: string;
+};
+export declare class SupportCenterClient extends AbstractClient {
+    protected basePath: string;
+    listTopics(parameters?: Parameters): Promise<GetResult<Topics>>;
+    listIssues(parameters?: ListIssueParametersType): Promise<GetResult<Issues>>;
+    createIssue(issuePayload: CreateIssuePayload, parameters?: Parameters): Promise<GetResult<Issue>>;
+    getIssue(issueId: string, parameters?: Parameters): Promise<GetResult<Issue>>;
+    updateIssue(issueId: string, payload: UpdateIssuePayload, parameters?: Parameters): Promise<GetResult<Issue>>;
+    listIssueComments(issueId: string, parameters?: Parameters): Promise<GetResult<IssueComments>>;
+    addIssueComment(issueId: string, payload: AddIssueCommentPayload, parameters?: Parameters): Promise<GetResult<IssueComment>>;
+    listIssueAttachments(issueId: string, parameters?: Parameters): Promise<GetResult<IssueAttachments>>;
+    addIssueAttachment(issueId: string, payload: AddIssueAttachmentPayload, parameters?: Parameters): Promise<GetResult<IssueAttachment>>;
+    downloadIssueAttachment(issueId: string, attachmentId: string, parameters?: Parameters): Promise<GetResult<IssueAttachment>>;
+}

package/build/supportCenter/supportCenterClient.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupportCenterClient = exports.ListIssueParametersFields = void 0;
+const abstractClient_1 = require("../abstractClient");
+const issue_1 = require("./entities/issue/issue");
+const getResult_1 = require("../getResult");
+const attachment_1 = require("./entities/issue/attachment");
+const comment_1 = require("./entities/issue/comment");
+const topic_1 = require("./entities/topic");
+var ListIssueParametersFields;
+(function (ListIssueParametersFields) {
+    ListIssueParametersFields["DIR"] = "dir";
+    ListIssueParametersFields["END_CUSTOMER_REF"] = "endCustomerRef";
+    ListIssueParametersFields["PROGRAM"] = "program";
+    ListIssueParametersFields["RESELLER_REF"] = "resellerRef";
+    ListIssueParametersFields["SKU"] = "sku";
+    ListIssueParametersFields["SORT"] = "sort";
+    ListIssueParametersFields["STATUSES"] = "statuses";
+    ListIssueParametersFields["TITLE"] = "title";
+})(ListIssueParametersFields = exports.ListIssueParametersFields || (exports.ListIssueParametersFields = {}));
+class SupportCenterClient extends abstractClient_1.AbstractClient {
+    constructor() {
+        super(...arguments);
+        this.basePath = '/support';
+    }
+    async listTopics(parameters = {}) {
+        this.path = `/topics`;
+        return new getResult_1.GetResult(topic_1.Topics, await this.get(parameters));
+    }
+    async listIssues(parameters = {}) {
+        this.path = `/issues`;
+        return new getResult_1.GetResult(issue_1.Issues, await this.get(parameters));
+    }
+    async createIssue(issuePayload, parameters = {}) {
+        this.path = `/issues`;
+        return new getResult_1.GetResult(issue_1.Issue, await this.post(issuePayload, parameters));
+    }
+    async getIssue(issueId, parameters = {}) {
+        this.path = `/issues/${issueId}`;
+        return new getResult_1.GetResult(issue_1.Issue, await this.get(parameters));
+    }
+    async updateIssue(issueId, payload, parameters = {}) {
+        this.path = `/issues/${issueId}`;
+        return new getResult_1.GetResult(issue_1.Issue, await this.patch(payload, parameters));
+    }
+    async listIssueComments(issueId, parameters = {}) {
+        this.path = `/issues/${issueId}/comments`;
+        return new getResult_1.GetResult(comment_1.IssueComments, await this.get(parameters));
+    }
+    async addIssueComment(issueId, payload, parameters = {}) {
+        this.path = `/issues/${issueId}/comments`;
+        return new getResult_1.GetResult(comment_1.IssueComment, await this.post(payload, parameters));
+    }
+    async listIssueAttachments(issueId, parameters = {}) {
+        this.path = `/issues/${issueId}/attachments`;
+        return new getResult_1.GetResult(attachment_1.IssueAttachments, await this.get(parameters));
+    }
+    async addIssueAttachment(issueId, payload, parameters = {}) {
+        this.path = `/issues/${issueId}/attachments`;
+        return new getResult_1.GetResult(attachment_1.IssueAttachment, await this.post(payload, parameters));
+    }
+    async downloadIssueAttachment(issueId, attachmentId, parameters = {}) {
+        this.path = `/issues/${issueId}/attachments/${attachmentId}`;
+        return new getResult_1.GetResult(attachment_1.IssueAttachment, await this.get(parameters));
+    }
+}
+exports.SupportCenterClient = SupportCenterClient;
+//# sourceMappingURL=supportCenterClient.js.map

package/package.json

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