hgs-twilio-class-lib 1.1.72 → 1.1.74

package/lib/models/impl/callbackandvoicemail/VoicemailModel.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoicemailModel = void 0;
+const BaseModel_1 = require("../../abstract/BaseModel");
+class VoicemailModel extends BaseModel_1.BaseModel {
+    constructor(isEnabled, enableDuringBusinessHrs, enableDuringNonBusinessHrs, createReport, assignTask, sendEmail) {
+        super();
+        this._isEnabled = isEnabled;
+        this._enableDuringBusinessHrs = enableDuringBusinessHrs;
+        this._enableDuringNonBusinessHrs = enableDuringNonBusinessHrs;
+        this._createReport = createReport;
+        this._assignTask = assignTask;
+        this._sendEmail = sendEmail;
+    }
+    get isEnabled() {
+        return this._isEnabled;
+    }
+    set isEnabled(value) {
+        if (typeof value === "boolean") {
+            this._isEnabled = value;
+        }
+        else {
+            throw new Error("Invalid isEnabled value");
+        }
+    }
+    get enableDuringBusinessHrs() {
+        return this._enableDuringBusinessHrs;
+    }
+    set enableDuringBusinessHrs(value) {
+        if (typeof value === "boolean") {
+            this._enableDuringBusinessHrs = value;
+        }
+        else {
+            throw new Error("Invalid enableDuringBusinessHrs value");
+        }
+    }
+    get enableDuringNonBusinessHrs() {
+        return this._enableDuringNonBusinessHrs;
+    }
+    set enableDuringNonBusinessHrs(value) {
+        if (typeof value === "boolean") {
+            this._enableDuringNonBusinessHrs = value;
+        }
+        else {
+            throw new Error("Invalid enableDuringNonBusinessHrs value");
+        }
+    }
+    get createReport() {
+        return this._createReport;
+    }
+    set createReport(value) {
+        if (typeof value === "boolean") {
+            this._createReport = value;
+        }
+        else {
+            throw new Error("Invalid createReport value");
+        }
+    }
+    get sendEmail() {
+        return this._sendEmail;
+    }
+    set sendEmail(value) {
+        if (typeof value === "boolean") {
+            this._sendEmail = value;
+        }
+        else {
+            throw new Error("Invalid sendEmail value");
+        }
+    }
+    get assignTask() {
+        return this._assignTask;
+    }
+    set assignTask(value) {
+        if (typeof value === "boolean") {
+            this._assignTask = value;
+        }
+        else {
+            throw new Error("Invalid assignTask value");
+        }
+    }
+    validateData() {
+        this.validationMessages = [];
+        const validationRules = {
+            isEnabled: (value) => typeof value === 'boolean',
+            enableDuringBusinessHrs: (value) => typeof value === 'boolean',
+            enableDuringNonBusinessHrs: (value) => typeof value === 'boolean',
+            createReport: (value) => typeof value === 'boolean',
+            assignTask: (value) => typeof value === 'boolean',
+            sendEmail: (value) => typeof value === 'boolean',
+        };
+        for (const key in validationRules) {
+            const validator = validationRules[key];
+            const value = this[key];
+            if (!validator(value)) {
+                this.setValidationMessages({
+                    type: "Error",
+                    fieldDescription: key,
+                    message: `${key} is invalid.`,
+                });
+            }
+        }
+        return this.validationMessages;
+    }
+    setValidationMessages(message) {
+        this.validationMessages.push(message);
+    }
+}
+exports.VoicemailModel = VoicemailModel;

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

@@ -0,0 +1,68 @@
+import { BaseModel } from "../../abstract/BaseModel";
+import { validationMessage } from "../../interface/IBaseModel";
+import { ChannelTypeEnum } from "../../types/ChannelSetting.type";
+export declare class ChannelSettingModel extends BaseModel {
+    private _id;
+    private _name;
+    private _channelType;
+    private _queueSid;
+    private _autoAnswer;
+    private _autoComplete;
+    private _autoCallTranscript;
+    private _autoCallRecording;
+    private _autoCallScreenRecording;
+    private _alert;
+    private _alertAudioFile;
+    private _waitMusic;
+    private _waitMusicFile;
+    private _autoAnswerTime?;
+    private _autoCompleteTime?;
+    private _useAlertExistingAudio?;
+    private _useWaitExistingAudio?;
+    private _createdBy;
+    private _createdDate;
+    private _updatedBy?;
+    private _updatedDate;
+    constructor(id: string, name: string, channelType: ChannelTypeEnum, queueSid: string, autoAnswer: boolean, autoComplete: boolean, autoCallTranscript: boolean, autoCallRecording: boolean, autoCallScreenRecording: boolean, alert: boolean, waitMusic: boolean, createdBy: string, createdDate: Date, updatedDate: Date, waitMusicFile: string, alertAudioFile: string, autoAnswerTime?: number, useAlertExistingAudio?: boolean, autoCompleteTime?: number, useWaitExistingAudio?: boolean);
+    get id(): string;
+    set id(value: string);
+    get name(): string;
+    set name(value: string);
+    get channelType(): ChannelTypeEnum;
+    set channelType(value: ChannelTypeEnum);
+    get queueSid(): string;
+    set queueSid(value: string);
+    get autoAnswer(): boolean;
+    set autoAnswer(value: boolean);
+    get autoAnswerTime(): number | undefined;
+    set autoAnswerTime(value: number | undefined);
+    get autoComplete(): boolean;
+    set autoComplete(value: boolean);
+    get autoCompleteTime(): number | undefined;
+    set autoCompleteTime(value: number | undefined);
+    get autoCallTranscript(): boolean;
+    set autoCallTranscript(value: boolean);
+    get autoCallRecording(): boolean;
+    set autoCallRecording(value: boolean);
+    get autoCallScreenRecording(): boolean;
+    set autoCallScreenRecording(value: boolean);
+    get alert(): boolean;
+    set alert(value: boolean);
+    get alertAudioFile(): string;
+    set alertAudioFile(value: string);
+    get useAlertExistingAudio(): boolean | undefined;
+    set useAlertExistingAudio(value: boolean | undefined);
+    get waitMusic(): boolean;
+    set waitMusic(value: boolean);
+    get waitMusicFile(): string;
+    set waitMusicFile(value: string);
+    get useWaitExistingAudio(): boolean | undefined;
+    set useWaitExistingAudio(value: boolean | undefined);
+    get createdDate(): Date;
+    get createdBy(): string;
+    get updatedDate(): Date;
+    set updatedDate(value: Date);
+    get updatedBy(): string | undefined;
+    set updatedBy(value: string);
+    validateData(): validationMessage[];
+}

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[];
+}