hgs-twilio-class-lib 1.1.72 → 1.1.73

package/lib/models/impl/channelsettings/ChannelSettingModel.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelSettingModel = void 0;
+const BaseModel_1 = require("../../abstract/BaseModel");
+const ChannelSetting_type_1 = require("../../types/ChannelSetting.type");
+class ChannelSettingModel extends BaseModel_1.BaseModel {
+    constructor(id, name, channelType, queueSid, autoAnswer, autoComplete, autoCallTranscript, autoCallRecording, autoCallScreenRecording, alert, waitMusic, createdBy, createdDate, updatedDate, waitMusicFile, alertAudioFile, autoAnswerTime, useAlertExistingAudio, autoCompleteTime, useWaitExistingAudio) {
+        super();
+        this._id = id;
+        this._name = name;
+        this._channelType = channelType;
+        this._queueSid = queueSid;
+        this._autoAnswer = autoAnswer;
+        this._autoAnswerTime = autoAnswerTime;
+        this._autoComplete = autoComplete;
+        this._autoCompleteTime = autoCompleteTime;
+        this._autoCallTranscript = autoCallTranscript;
+        this._autoCallRecording = autoCallRecording;
+        this._autoCallScreenRecording = autoCallScreenRecording;
+        this._alert = alert;
+        this._alertAudioFile = alertAudioFile;
+        this._useAlertExistingAudio = useAlertExistingAudio;
+        this._waitMusic = waitMusic;
+        this._waitMusicFile = waitMusicFile;
+        this._useWaitExistingAudio = useWaitExistingAudio;
+        this._createdDate = createdDate;
+        this._updatedDate = updatedDate;
+        this._createdBy = createdBy;
+        this.validateData();
+    }
+    // Getters and Setters
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get channelType() {
+        return this._channelType;
+    }
+    set channelType(value) {
+        this._channelType = value;
+    }
+    get queueSid() {
+        return this._queueSid;
+    }
+    set queueSid(value) {
+        this._queueSid = value;
+    }
+    get autoAnswer() {
+        return this._autoAnswer;
+    }
+    set autoAnswer(value) {
+        this._autoAnswer = value;
+    }
+    get autoAnswerTime() {
+        return this._autoAnswerTime;
+    }
+    set autoAnswerTime(value) {
+        this._autoAnswerTime = value;
+    }
+    get autoComplete() {
+        return this._autoComplete;
+    }
+    set autoComplete(value) {
+        this._autoComplete = value;
+    }
+    get autoCompleteTime() {
+        return this._autoCompleteTime;
+    }
+    set autoCompleteTime(value) {
+        this._autoCompleteTime = value;
+    }
+    get autoCallTranscript() {
+        return this._autoCallTranscript;
+    }
+    set autoCallTranscript(value) {
+        this._autoCallTranscript = value;
+    }
+    get autoCallRecording() {
+        return this._autoCallRecording;
+    }
+    set autoCallRecording(value) {
+        this._autoCallRecording = value;
+    }
+    get autoCallScreenRecording() {
+        return this._autoCallScreenRecording;
+    }
+    set autoCallScreenRecording(value) {
+        this._autoCallScreenRecording = value;
+    }
+    get alert() {
+        return this._alert;
+    }
+    set alert(value) {
+        this._alert = value;
+    }
+    get alertAudioFile() {
+        return this._alertAudioFile;
+    }
+    set alertAudioFile(value) {
+        this._alertAudioFile = value;
+    }
+    get useAlertExistingAudio() {
+        return this._useAlertExistingAudio;
+    }
+    set useAlertExistingAudio(value) {
+        this._useAlertExistingAudio = value;
+    }
+    get waitMusic() {
+        return this._waitMusic;
+    }
+    set waitMusic(value) {
+        this._waitMusic = value;
+    }
+    get waitMusicFile() {
+        return this._waitMusicFile;
+    }
+    set waitMusicFile(value) {
+        this._waitMusicFile = value;
+    }
+    get useWaitExistingAudio() {
+        return this._useWaitExistingAudio;
+    }
+    set useWaitExistingAudio(value) {
+        this._useWaitExistingAudio = value;
+    }
+    get createdDate() {
+        return this._createdDate;
+    }
+    get createdBy() {
+        return this._createdBy;
+    }
+    get updatedDate() {
+        return this._updatedDate;
+    }
+    set updatedDate(value) {
+        this._updatedDate = value;
+    }
+    get updatedBy() {
+        return this._updatedBy;
+    }
+    set updatedBy(value) {
+        this._updatedBy = value;
+    }
+    // Validation Method
+    validateData() {
+        this.validationMessages = [];
+        // Validate name
+        if (typeof this._name !== "string" || !this._name.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "name",
+                message: "Name must be a non-empty string",
+            });
+        }
+        if (typeof this._createdBy !== "string" || !this._name.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "createdBy",
+                message: "createdBy must be a non-empty string",
+            });
+        }
+        // Validate channelType
+        if (!Object.values(ChannelSetting_type_1.ChannelTypeEnum).includes(this._channelType)) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "channelType",
+                message: "ChannelType must be a valid enum value",
+            });
+        }
+        // Validate queueSid
+        if (typeof this._queueSid !== "string" || !this._queueSid.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "queueSid",
+                message: "QueueSid must be a non-empty string",
+            });
+        }
+        // Validate autoAnswerTime
+        if (this._autoAnswerTime !== undefined && (typeof this._autoAnswerTime !== "number" || this._autoAnswerTime < 0)) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "autoAnswerTime",
+                message: "AutoAnswerTime must be a non-negative number",
+            });
+        }
+        // Validate autoCompleteTime
+        if (this._autoCompleteTime !== undefined && (typeof this._autoCompleteTime !== "number" || this._autoCompleteTime < 0)) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "autoCompleteTime",
+                message: "AutoCompleteTime must be a non-negative number",
+            });
+        }
+        // Validate alertAudioFile when alert is enabled
+        if (this._alert && !this._useAlertExistingAudio && (!this._alertAudioFile || !this._alertAudioFile.trim())) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "alertAudioFile",
+                message: "AlertAudioFile must be provided when alert is enabled and not using existing audio",
+            });
+        }
+        // Validate waitMusicFile when waitMusic is enabled
+        if (this._waitMusic && !this._useWaitExistingAudio && (!this._waitMusicFile || !this._waitMusicFile.trim())) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "waitMusicFile",
+                message: "WaitMusicFile must be provided when waitMusic is enabled and not using existing audio",
+            });
+        }
+        // Validate boolean fields
+        const booleanFields = [
+            { field: "_autoAnswer", fieldDescription: "autoAnswer" },
+            { field: "_autoComplete", fieldDescription: "autoComplete" },
+            { field: "_autoCallTranscript", fieldDescription: "autoCallTranscript" },
+            { field: "_autoCallRecording", fieldDescription: "autoCallRecording" },
+            { field: "_autoCallScreenRecording", fieldDescription: "autoCallScreenRecording" },
+            { field: "_alert", fieldDescription: "alert" },
+            { field: "_waitMusic", fieldDescription: "waitMusic" },
+        ];
+        booleanFields.forEach(({ field, fieldDescription }) => {
+            if (typeof this[field] !== "boolean") {
+                this.validationMessages.push({
+                    type: "Error",
+                    fieldDescription,
+                    message: `${fieldDescription} must be a boolean value`,
+                });
+            }
+        });
+        return this.validationMessages;
+    }
+}
+exports.ChannelSettingModel = ChannelSettingModel;

package/lib/models/impl/channelsettings/ChannelSettingTaskInfoModel.d.ts

@@ -0,0 +1,31 @@
+import { validationMessage } from "../../interface/IBaseModel";
+import { BaseModel } from "../../abstract/BaseModel";
+import { ChannelTypeEnum } from "../../types/ChannelSetting.type";
+import { TaskInfoModel } from "./TaskInfoModel";
+export declare class ChannelSettingTaskInfoModel extends BaseModel {
+    private _id;
+    private _channelId;
+    private _name;
+    private _channelType;
+    private _taskInfoGroup;
+    private _createdBy;
+    private _createdDate;
+    private _updatedBy?;
+    private _updatedDate?;
+    constructor(id: string, channelId: string, name: string, channelType: ChannelTypeEnum, taskInfoGroup: TaskInfoModel[], createdBy: string, createdDate: Date);
+    get id(): string;
+    get channelId(): string;
+    get name(): string;
+    set name(value: string);
+    get channelType(): ChannelTypeEnum;
+    set channelType(value: ChannelTypeEnum);
+    get taskInfoGroup(): TaskInfoModel[];
+    set taskInfoGroup(value: TaskInfoModel[]);
+    get createdDate(): Date;
+    get createdBy(): string;
+    get updatedDate(): Date | undefined;
+    set updatedDate(value: Date);
+    get updatedBy(): string | undefined;
+    set updatedBy(value: string);
+    validateData(): validationMessage[];
+}

package/lib/models/impl/channelsettings/ChannelSettingTaskInfoModel.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelSettingTaskInfoModel = void 0;
+const BaseModel_1 = require("../../abstract/BaseModel");
+const ChannelSetting_type_1 = require("../../types/ChannelSetting.type");
+class ChannelSettingTaskInfoModel extends BaseModel_1.BaseModel {
+    constructor(id, channelId, name, channelType, taskInfoGroup, createdBy, createdDate) {
+        super();
+        this._id = id;
+        this._channelId = channelId;
+        this._name = name;
+        this._channelType = channelType;
+        this._taskInfoGroup = taskInfoGroup;
+        this._createdDate = createdDate;
+        this._createdBy = createdBy;
+        this.validateData();
+    }
+    // Getters and Setters
+    get id() {
+        return this._id;
+    }
+    get channelId() {
+        return this._channelId;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get channelType() {
+        return this._channelType;
+    }
+    set channelType(value) {
+        this._channelType = value;
+    }
+    get taskInfoGroup() {
+        return this._taskInfoGroup;
+    }
+    set taskInfoGroup(value) {
+        this._taskInfoGroup = value;
+    }
+    get createdDate() {
+        return this._createdDate;
+    }
+    get createdBy() {
+        return this._createdBy;
+    }
+    get updatedDate() {
+        return this._updatedDate;
+    }
+    set updatedDate(value) {
+        this._updatedDate = value;
+    }
+    get updatedBy() {
+        return this._updatedBy;
+    }
+    set updatedBy(value) {
+        this._updatedBy = value;
+    }
+    // Validation Method
+    validateData() {
+        const validationMessages = [];
+        // Validate name
+        if (typeof this._name !== "string" || !this._name.trim()) {
+            validationMessages.push({
+                type: "Error",
+                fieldDescription: "name",
+                message: "Name must be a non-empty string.",
+            });
+        }
+        if (typeof this._createdBy !== "string" || !this._name.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "createdBy",
+                message: "createdBy must be a non-empty string",
+            });
+        }
+        // Validate channelType
+        if (!Object.values(ChannelSetting_type_1.ChannelTypeEnum).includes(this._channelType)) {
+            validationMessages.push({
+                type: "Error",
+                fieldDescription: "channelType",
+                message: `Channel type must be a valid value from ChannelTypeEnum.`,
+            });
+        }
+        // Validate taskInfoGroup
+        if (!Array.isArray(this._taskInfoGroup) || this._taskInfoGroup.length === 0) {
+            validationMessages.push({
+                type: "Error",
+                fieldDescription: "taskInfoGroup",
+                message: "TaskInfoGroup must be a non-empty array.",
+            });
+        }
+        else {
+            this._taskInfoGroup.forEach((taskInfo, index) => {
+                const taskInfoValidationMessages = taskInfo.validateData();
+                taskInfoValidationMessages.forEach((message) => {
+                    validationMessages.push(Object.assign(Object.assign({}, message), { fieldDescription: `taskInfoGroup[${index}].${message.fieldDescription}` }));
+                });
+            });
+        }
+        return validationMessages;
+    }
+}
+exports.ChannelSettingTaskInfoModel = ChannelSettingTaskInfoModel;

package/lib/models/impl/channelsettings/TaskInfoAttributeModel.d.ts

@@ -0,0 +1,25 @@
+import { BaseModel } from "../../abstract/BaseModel";
+import { validationMessage } from "../../interface/IBaseModel";
+export declare enum TaskAttributeType {
+    readOnly = "Read Only",
+    input = "Input",
+    dropDown = "Drop Down",
+    warningMessage = "Warning Message",
+    verificationStatus = "Verification Status"
+}
+export declare class TaskInfoAttributeModel extends BaseModel {
+    private _attributeName;
+    private _label;
+    private _objectPath;
+    private _type;
+    constructor(attributeName: string, label: string, objectPath: string, type: TaskAttributeType);
+    get attributeName(): string;
+    set attributeName(value: string);
+    get label(): string;
+    set label(value: string);
+    get objectPath(): string;
+    set objectPath(value: string);
+    get type(): TaskAttributeType;
+    set type(value: TaskAttributeType);
+    validateData(): validationMessage[];
+}

package/lib/models/impl/channelsettings/TaskInfoAttributeModel.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskInfoAttributeModel = exports.TaskAttributeType = void 0;
+const BaseModel_1 = require("../../abstract/BaseModel");
+var TaskAttributeType;
+(function (TaskAttributeType) {
+    TaskAttributeType["readOnly"] = "Read Only";
+    TaskAttributeType["input"] = "Input";
+    TaskAttributeType["dropDown"] = "Drop Down";
+    TaskAttributeType["warningMessage"] = "Warning Message";
+    TaskAttributeType["verificationStatus"] = "Verification Status";
+})(TaskAttributeType || (exports.TaskAttributeType = TaskAttributeType = {}));
+class TaskInfoAttributeModel extends BaseModel_1.BaseModel {
+    constructor(attributeName, label, objectPath, type) {
+        super();
+        this._attributeName = attributeName;
+        this._label = label;
+        this._objectPath = objectPath;
+        this._type = type;
+    }
+    // Getters and Setters
+    get attributeName() {
+        return this._attributeName;
+    }
+    set attributeName(value) {
+        this._attributeName = value;
+    }
+    get label() {
+        return this._label;
+    }
+    set label(value) {
+        this._label = value;
+    }
+    get objectPath() {
+        return this._objectPath;
+    }
+    set objectPath(value) {
+        this._objectPath = value;
+    }
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        this._type = value;
+    }
+    // Validation Method
+    validateData() {
+        const validationMessages = [];
+        if (typeof this._attributeName !== "string" || !this._attributeName.trim()) {
+            validationMessages.push({
+                type: "Error",
+                fieldDescription: "attributeName",
+                message: "Attribute name must be a non-empty string.",
+            });
+        }
+        if (typeof this._label !== "string" || !this._label.trim()) {
+            validationMessages.push({
+                type: "Error",
+                fieldDescription: "label",
+                message: "Label must be a non-empty string.",
+            });
+        }
+        if (typeof this._objectPath !== "string" || !this._objectPath.trim()) {
+            validationMessages.push({
+                type: "Error",
+                fieldDescription: "objectPath",
+                message: "Object path must be a non-empty string.",
+            });
+        }
+        if (!Object.values(TaskAttributeType).includes(this._type)) {
+            validationMessages.push({
+                type: "Error",
+                fieldDescription: "type",
+                message: "Type must be a valid TaskAttributeType.",
+            });
+        }
+        return validationMessages;
+    }
+}
+exports.TaskInfoAttributeModel = TaskInfoAttributeModel;

package/lib/models/impl/channelsettings/TaskInfoModel.d.ts

@@ -0,0 +1,13 @@
+import { BaseModel } from "../../abstract/BaseModel";
+import { validationMessage } from "../../interface/IBaseModel";
+import { TaskInfoAttributeModel } from "./TaskInfoAttributeModel";
+export declare class TaskInfoModel extends BaseModel {
+    private _name;
+    private _attributes;
+    constructor(name: string, attributes: TaskInfoAttributeModel[]);
+    get name(): string;
+    set name(value: string);
+    get attributes(): TaskInfoAttributeModel[];
+    set attributes(value: TaskInfoAttributeModel[]);
+    validateData(): validationMessage[];
+}

package/lib/models/impl/channelsettings/TaskInfoModel.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskInfoModel = void 0;
+const BaseModel_1 = require("../../abstract/BaseModel");
+class TaskInfoModel extends BaseModel_1.BaseModel {
+    constructor(name, attributes) {
+        super();
+        this._name = name;
+        this._attributes = attributes;
+    }
+    // Getters and Setters
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get attributes() {
+        return this._attributes;
+    }
+    set attributes(value) {
+        this._attributes = value;
+    }
+    // Validation Method
+    validateData() {
+        const validationMessages = [];
+        if (typeof this._name !== "string" || !this._name.trim()) {
+            validationMessages.push({
+                type: "Error",
+                fieldDescription: "name",
+                message: "Name must be a non-empty string.",
+            });
+        }
+        if (!Array.isArray(this._attributes) || this._attributes.length === 0) {
+            validationMessages.push({
+                type: "Error",
+                fieldDescription: "attributes",
+                message: "Attributes must be a non-empty array.",
+            });
+        }
+        else {
+            this._attributes.forEach((attribute, index) => {
+                const attrValidationMessages = attribute.validateData();
+                attrValidationMessages.forEach((message) => {
+                    validationMessages.push(Object.assign(Object.assign({}, message), { fieldDescription: `attributes[${index}].${message.fieldDescription}` }));
+                });
+            });
+        }
+        return validationMessages;
+    }
+}
+exports.TaskInfoModel = TaskInfoModel;

package/lib/models/impl/cxconfig/CxConfigNamespace.d.ts

@@ -0,0 +1,16 @@
+import { CxConfiguratorConfigModel } from "./CxConfiguratorConfigModel";
+import { CxConfiguratorExternalNumbersModel } from "./CxConfiguratorExternalNumbersModel";
+import { CxConfiguratorGPMAssetModel } from "./CxConfiguratorGPMAssetModel";
+import { CxConfiguratorGPMPromptModel } from "./CxConfiguratorGPMPromptModel";
+import { CxConfiguratorOtherModel } from "./CxConfiguratorOtherModel";
+import { CxConfiguratorQueueMenuModel } from "./CxConfiguratorQueueMenuModel";
+import { CxGpmUIConfigModel } from "./CxConfigUIConfigModel";
+export declare namespace CxConfigurator {
+    const GpmUIConfig: typeof CxGpmUIConfigModel;
+    const QueueModel: typeof CxConfiguratorQueueMenuModel;
+    const OtherModel: typeof CxConfiguratorOtherModel;
+    const ConfigModel: typeof CxConfiguratorConfigModel;
+    const ExternalNumberModel: typeof CxConfiguratorExternalNumbersModel;
+    const GpmAsset: typeof CxConfiguratorGPMAssetModel;
+    const GpmPrompt: typeof CxConfiguratorGPMPromptModel;
+}

package/lib/models/impl/cxconfig/CxConfigNamespace.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CxConfigurator = void 0;
+const CxConfiguratorConfigModel_1 = require("./CxConfiguratorConfigModel");
+const CxConfiguratorExternalNumbersModel_1 = require("./CxConfiguratorExternalNumbersModel");
+const CxConfiguratorGPMAssetModel_1 = require("./CxConfiguratorGPMAssetModel");
+const CxConfiguratorGPMPromptModel_1 = require("./CxConfiguratorGPMPromptModel");
+const CxConfiguratorOtherModel_1 = require("./CxConfiguratorOtherModel");
+const CxConfiguratorQueueMenuModel_1 = require("./CxConfiguratorQueueMenuModel");
+const CxConfigUIConfigModel_1 = require("./CxConfigUIConfigModel");
+var CxConfigurator;
+(function (CxConfigurator) {
+    CxConfigurator.GpmUIConfig = CxConfigUIConfigModel_1.CxGpmUIConfigModel;
+    CxConfigurator.QueueModel = CxConfiguratorQueueMenuModel_1.CxConfiguratorQueueMenuModel;
+    CxConfigurator.OtherModel = CxConfiguratorOtherModel_1.CxConfiguratorOtherModel;
+    CxConfigurator.ConfigModel = CxConfiguratorConfigModel_1.CxConfiguratorConfigModel;
+    CxConfigurator.ExternalNumberModel = CxConfiguratorExternalNumbersModel_1.CxConfiguratorExternalNumbersModel;
+    CxConfigurator.GpmAsset = CxConfiguratorGPMAssetModel_1.CxConfiguratorGPMAssetModel;
+    CxConfigurator.GpmPrompt = CxConfiguratorGPMPromptModel_1.CxConfiguratorGPMPromptModel;
+})(CxConfigurator || (exports.CxConfigurator = CxConfigurator = {}));

package/lib/models/impl/cxconfig/CxConfigUIConfigModel.d.ts

@@ -0,0 +1,27 @@
+import { BaseModel } from "../../abstract/BaseModel";
+import { validationMessage } from "../../interface/IBaseModel";
+/**
+ * Quick Link Model
+ */
+export declare class CxGpmUIConfigModel extends BaseModel {
+    private _id;
+    private _name;
+    private _value;
+    private _description;
+    private _createdAt;
+    private _updatedAt;
+    constructor(id: string, name: string, value: string, description: string, createdAt: Date | undefined, updatedAt: Date | undefined);
+    get id(): string;
+    set id(value: string);
+    get name(): string;
+    set name(value: string);
+    get value(): string;
+    set value(value: string);
+    get description(): string;
+    set description(value: string);
+    get createdAt(): Date | undefined;
+    set createdAt(value: Date | undefined);
+    get updatedAt(): Date | undefined;
+    set updatedAt(value: Date | undefined);
+    validateData(): validationMessage[];
+}