hgs-twilio-class-lib 1.1.72 → 1.1.74

package/lib/models/impl/WorkGroupDetailsModel.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkGroupDetailsModel = void 0;
+const BaseModel_1 = require("../abstract/BaseModel");
+class WorkGroupDetailsModel extends BaseModel_1.BaseModel {
+    constructor(id, totalAgents, loggedOn, agentsAvailable, percentAvailable, agentsAvailableToTakeCalls, nonAcdInteractions, availableForAcdInteractions, notAvailableForAcdInteractions, inboundAcdInteractions, outboundAcdInteractions, inboundAcw, outboundAcw, interactionWaiting, interactionOnhold, longestInteractionWaiting, longestAvailable, createdAt, updatedAt) {
+        super();
+        this._id = id;
+        this._totalAgents = totalAgents;
+        this._loggedOn = loggedOn;
+        this._agentsAvailable = agentsAvailable;
+        this._percentAvailable = percentAvailable;
+        this._agentsAvailableToTakeCalls = agentsAvailableToTakeCalls;
+        this._nonAcdInteractions = nonAcdInteractions;
+        this._availableForAcdInteractions = availableForAcdInteractions;
+        this._notAvailableForAcdInteractions = notAvailableForAcdInteractions;
+        this._inboundAcdInteractions = inboundAcdInteractions;
+        this._outboundAcdInteractions = outboundAcdInteractions;
+        this._inboundAcw = inboundAcw;
+        this._outboundAcw = outboundAcw;
+        this._interactionWaiting = interactionWaiting;
+        this._interactionOnhold = interactionOnhold;
+        this._longestInteractionWaiting = longestInteractionWaiting;
+        this._longestAvailable = longestAvailable;
+        this._createdAt = createdAt;
+        this._updatedAt = updatedAt;
+    }
+    validateData() {
+        this.validationMessages = [];
+        if (typeof this._id !== "string" || !this._id.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "id",
+                message: "ID must be a non-empty string",
+            });
+        }
+        if (this._totalAgents < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "totalAgents",
+                message: "Total agents must be a non-negative number",
+            });
+        }
+        if (this._loggedOn < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "loggedOn",
+                message: "Logged on agents must be a non-negative number",
+            });
+        }
+        if (this._agentsAvailable < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "agentsAvailable",
+                message: "Agents available must be a non-negative number",
+            });
+        }
+        if (this._percentAvailable < 0 || this._percentAvailable > 100) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "percentAvailable",
+                message: "Percent available must be between 0 and 100",
+            });
+        }
+        if (this._agentsAvailableToTakeCalls < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "agentsAvailableToTakeCalls",
+                message: "Agents available to take calls must be a non-negative number",
+            });
+        }
+        if (this._nonAcdInteractions < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "nonAcdInteractions",
+                message: "Non-ACD interactions must be a non-negative number",
+            });
+        }
+        if (this._availableForAcdInteractions < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "availableForAcdInteractions",
+                message: "Available for ACD interactions must be a non-negative number",
+            });
+        }
+        if (this._notAvailableForAcdInteractions < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "notAvailableForAcdInteractions",
+                message: "Not available for ACD interactions must be a non-negative number",
+            });
+        }
+        if (this._inboundAcdInteractions < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "inboundAcdInteractions",
+                message: "Inbound ACD interactions must be a non-negative number",
+            });
+        }
+        if (this._outboundAcdInteractions < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "outboundAcdInteractions",
+                message: "Outbound ACD interactions must be a non-negative number",
+            });
+        }
+        if (this._inboundAcw < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "inboundAcw",
+                message: "Inbound ACW must be a non-negative number",
+            });
+        }
+        if (this._outboundAcw < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "outboundAcw",
+                message: "Outbound ACW must be a non-negative number",
+            });
+        }
+        if (this._interactionWaiting < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "interactionWaiting",
+                message: "Interaction waiting count must be a non-negative number",
+            });
+        }
+        if (this._interactionOnhold < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "interactionOnhold",
+                message: "Interaction on-hold count must be a non-negative number",
+            });
+        }
+        if (typeof this._longestInteractionWaiting !== "string" || !this._longestInteractionWaiting.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "longestInteractionWaiting",
+                message: "Longest interaction waiting must be a non-empty string",
+            });
+        }
+        if (this._longestAvailable < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "longestAvailable",
+                message: "Longest available time must be a non-negative number",
+            });
+        }
+        if (this._createdAt && !(this._createdAt instanceof Date)) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "createdAt",
+                message: "CreatedAt must be a valid Date object or undefined",
+            });
+        }
+        if (this._updatedAt && !(this._updatedAt instanceof Date)) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "updatedAt",
+                message: "UpdatedAt must be a valid Date object or undefined",
+            });
+        }
+        return this.validationMessages;
+    }
+    // Getters and setters for all fields
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    get totalAgents() {
+        return this._totalAgents;
+    }
+    set totalAgents(value) {
+        this._totalAgents = value;
+    }
+    get loggedOn() {
+        return this._loggedOn;
+    }
+    set loggedOn(value) {
+        this._loggedOn = value;
+    }
+    get agentsAvailable() {
+        return this._agentsAvailable;
+    }
+    set agentsAvailable(value) {
+        this._agentsAvailable = value;
+    }
+    get percentAvailable() {
+        return this._percentAvailable;
+    }
+    set percentAvailable(value) {
+        this._percentAvailable = value;
+    }
+    get agentsAvailableToTakeCalls() {
+        return this._agentsAvailableToTakeCalls;
+    }
+    set agentsAvailableToTakeCalls(value) {
+        this._agentsAvailableToTakeCalls = value;
+    }
+    get nonAcdInteractions() {
+        return this._nonAcdInteractions;
+    }
+    set nonAcdInteractions(value) {
+        this._nonAcdInteractions = value;
+    }
+    get availableForAcdInteractions() {
+        return this._availableForAcdInteractions;
+    }
+    set availableForAcdInteractions(value) {
+        this._availableForAcdInteractions = value;
+    }
+    get notAvailableForAcdInteractions() {
+        return this._notAvailableForAcdInteractions;
+    }
+    set notAvailableForAcdInteractions(value) {
+        this._notAvailableForAcdInteractions = value;
+    }
+    get inboundAcdInteractions() {
+        return this._inboundAcdInteractions;
+    }
+    set inboundAcdInteractions(value) {
+        this._inboundAcdInteractions = value;
+    }
+    get outboundAcdInteractions() {
+        return this._outboundAcdInteractions;
+    }
+    set outboundAcdInteractions(value) {
+        this._outboundAcdInteractions = value;
+    }
+    get inboundAcw() {
+        return this._inboundAcw;
+    }
+    set inboundAcw(value) {
+        this._inboundAcw = value;
+    }
+    get outboundAcw() {
+        return this._outboundAcw;
+    }
+    set outboundAcw(value) {
+        this._outboundAcw = value;
+    }
+    get interactionWaiting() {
+        return this._interactionWaiting;
+    }
+    set interactionWaiting(value) {
+        this._interactionWaiting = value;
+    }
+    get interactionOnhold() {
+        return this._interactionOnhold;
+    }
+    set interactionOnhold(value) {
+        this._interactionOnhold = value;
+    }
+    get longestInteractionWaiting() {
+        return this._longestInteractionWaiting;
+    }
+    set longestInteractionWaiting(value) {
+        this._longestInteractionWaiting = value;
+    }
+    get longestAvailable() {
+        return this._longestAvailable;
+    }
+    set longestAvailable(value) {
+        this._longestAvailable = value;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    set createdAt(value) {
+        this._createdAt = value;
+    }
+    get updatedAt() {
+        return this._updatedAt;
+    }
+    set updatedAt(value) {
+        this._updatedAt = value;
+    }
+}
+exports.WorkGroupDetailsModel = WorkGroupDetailsModel;

package/lib/models/impl/callbackandvoicemail/CallbackAndVoicemailModel.d.ts

@@ -0,0 +1,33 @@
+import { BaseModel } from "../../abstract/BaseModel";
+import { validationMessage } from "../../interface/IBaseModel";
+import { VoicemailModel } from './VoicemailModel';
+import { CallbackModel } from './CallbackModel';
+export declare class CallbackAndVoicemailModel extends BaseModel {
+    private _id;
+    private _isEnabled;
+    private _callback;
+    private _voicemail;
+    private _createdAt;
+    private _updatedAt;
+    constructor(id: string, isEnabled: boolean, callback: CallbackModel, voicemail: VoicemailModel, createdAt: Date, updatedAt: Date);
+    /**Getters and Setters */
+    get id(): string;
+    set id(value: string);
+    get isEnabled(): boolean;
+    set isEnabled(value: boolean);
+    get callback(): CallbackModel;
+    set callback(value: CallbackModel);
+    get voicemail(): VoicemailModel;
+    set voicemail(value: VoicemailModel);
+    get createdAt(): Date;
+    set createdAt(value: Date);
+    get updatedAt(): Date;
+    set updatedAt(value: Date);
+    /** **Validation Method** */
+    validateData(): validationMessage[];
+    setValidationMessages(data: validationMessage): void;
+    /****Serialization Support** */
+    get serialize(): Record<string, any>;
+    /****Deserialization Support** */
+    deserialize(data: Record<string, any>): void;
+}

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

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallbackAndVoicemailModel = void 0;
+const BaseModel_1 = require("../../abstract/BaseModel");
+const uuid_1 = require("uuid");
+const VoicemailModel_1 = require("./VoicemailModel");
+const CallbackModel_1 = require("./CallbackModel");
+class CallbackAndVoicemailModel extends BaseModel_1.BaseModel {
+    constructor(id, isEnabled, callback, voicemail, createdAt, updatedAt) {
+        super();
+        this._id = id;
+        this._isEnabled = isEnabled;
+        this._callback = new CallbackModel_1.CallbackModel(callback.isEnabled, callback.enableDuringBusinessHrs, callback.enableDuringNonBusinessHrs, callback.assignTask);
+        this._voicemail = new VoicemailModel_1.VoicemailModel(voicemail.isEnabled, voicemail.enableDuringBusinessHrs, voicemail.enableDuringNonBusinessHrs, voicemail.createReport, voicemail.assignTask, voicemail.sendEmail);
+        this._createdAt = new Date(createdAt);
+        this._updatedAt = new Date(updatedAt);
+        this.validateData();
+    }
+    /**Getters and Setters */
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        if (!(0, uuid_1.validate)(value)) {
+            throw new Error("Invalid ID format.");
+        }
+        this._id = value;
+    }
+    get isEnabled() {
+        return this._isEnabled;
+    }
+    set isEnabled(value) {
+        if (typeof value !== 'boolean') {
+            throw new Error("isEnabled must be a boolean.");
+        }
+        this._isEnabled = value;
+    }
+    get callback() {
+        return this._callback;
+    }
+    set callback(value) {
+        if (!(value instanceof CallbackModel_1.CallbackModel)) {
+            throw new Error("Invalid callback instance.");
+        }
+        this._callback = value;
+    }
+    get voicemail() {
+        return this._voicemail;
+    }
+    set voicemail(value) {
+        if (!(value instanceof VoicemailModel_1.VoicemailModel)) {
+            throw new Error("Invalid voicemail instance.");
+        }
+        this._voicemail = value;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    set createdAt(value) {
+        if (!(value instanceof Date) || isNaN(value.getTime())) {
+            throw new Error("Invalid createdAt format.");
+        }
+        this._createdAt = value;
+    }
+    get updatedAt() {
+        return this._updatedAt;
+    }
+    set updatedAt(value) {
+        if (!(value instanceof Date) || isNaN(value.getTime())) {
+            throw new Error("Invalid updatedAt format.");
+        }
+        this._updatedAt = value;
+    }
+    /** **Validation Method** */
+    validateData() {
+        this.validationMessages = [];
+        const validationRules = {
+            id: (value) => typeof value === "string" && (0, uuid_1.validate)(value),
+            isEnabled: (value) => typeof value === "boolean",
+            callback: (value) => value.validateData().length === 0,
+            voicemail: (value) => value.validateData().length === 0,
+            createdAt: (value) => value instanceof Date && !isNaN(value.getTime()),
+            updatedAt: (value) => value instanceof Date && !isNaN(value.getTime()),
+        };
+        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(data) {
+        this.validationMessages.push(data);
+    }
+    /****Serialization Support** */
+    get serialize() {
+        return {
+            id: this._id,
+            isEnabled: this._isEnabled,
+            callback: this._callback.serialize, // Serialize nested model
+            voicemail: this._voicemail.serialize, // Serialize nested model
+            createdAt: this._createdAt.toISOString(),
+            updatedAt: this._updatedAt.toISOString(),
+        };
+    }
+    /****Deserialization Support** */
+    deserialize(data) {
+        if (data.hasOwnProperty("id") && (0, uuid_1.validate)(data.id)) {
+            this._id = data.id;
+        }
+        if (data.hasOwnProperty("isEnabled") && typeof data.isEnabled === "boolean") {
+            this._isEnabled = data.isEnabled;
+        }
+        if (data.hasOwnProperty("callback")) {
+            let callback = data.callback;
+            const callbackInstance = new CallbackModel_1.CallbackModel(callback.isEnabled, callback.enableDuringBusinessHrs, callback.enableDuringNonBusinessHrs, callback.assignTask);
+            callbackInstance.deserialize(data.callback);
+            this._callback = callbackInstance;
+        }
+        if (data.hasOwnProperty("voicemail")) {
+            let voicemail = data.voicemail;
+            const voicemailInstance = new VoicemailModel_1.VoicemailModel(voicemail.isEnabled, voicemail.enableDuringBusinessHrs, voicemail.enableDuringNonBusinessHrs, voicemail.createReport, voicemail.assignTask, voicemail.sendEmail);
+            voicemailInstance.deserialize(data.voicemail);
+            this._voicemail = voicemailInstance;
+        }
+        if (data.hasOwnProperty("createdAt")) {
+            this._createdAt = new Date(data.createdAt);
+        }
+        if (data.hasOwnProperty("updatedAt")) {
+            this._updatedAt = new Date(data.updatedAt);
+        }
+    }
+}
+exports.CallbackAndVoicemailModel = CallbackAndVoicemailModel;

package/lib/models/impl/callbackandvoicemail/CallbackAndVoicemailNamespace.d.ts

@@ -0,0 +1,8 @@
+import { CallbackModel } from './CallbackModel';
+import { VoicemailModel } from './VoicemailModel';
+import { CallbackAndVoicemailModel } from './CallbackAndVoicemailModel';
+export declare namespace CallbackVoicemail {
+    const Callback: typeof CallbackModel;
+    const Voicemail: typeof VoicemailModel;
+    const CallbackAndVoicemail: typeof CallbackAndVoicemailModel;
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallbackVoicemail = void 0;
+const CallbackModel_1 = require("./CallbackModel");
+const VoicemailModel_1 = require("./VoicemailModel");
+const CallbackAndVoicemailModel_1 = require("./CallbackAndVoicemailModel");
+var CallbackVoicemail;
+(function (CallbackVoicemail) {
+    CallbackVoicemail.Callback = CallbackModel_1.CallbackModel;
+    CallbackVoicemail.Voicemail = VoicemailModel_1.VoicemailModel;
+    CallbackVoicemail.CallbackAndVoicemail = CallbackAndVoicemailModel_1.CallbackAndVoicemailModel;
+})(CallbackVoicemail || (exports.CallbackVoicemail = CallbackVoicemail = {}));

package/lib/models/impl/callbackandvoicemail/CallbackModel.d.ts

@@ -0,0 +1,19 @@
+import { BaseModel } from "../../abstract/BaseModel";
+import { validationMessage } from "../../interface/IBaseModel";
+export declare class CallbackModel extends BaseModel {
+    private _isEnabled;
+    private _enableDuringBusinessHrs;
+    private _enableDuringNonBusinessHrs;
+    private _assignTask;
+    constructor(isEnabled: boolean, enableDuringBusinessHrs: boolean, enableDuringNonBusinessHrs: boolean, assignTask: boolean);
+    get isEnabled(): boolean;
+    set isEnabled(value: boolean);
+    get enableDuringBusinessHrs(): boolean;
+    set enableDuringBusinessHrs(value: boolean);
+    get enableDuringNonBusinessHrs(): boolean;
+    set enableDuringNonBusinessHrs(value: boolean);
+    get assignTask(): boolean;
+    set assignTask(value: boolean);
+    validateData(): validationMessage[];
+    setValidationMessages(message: validationMessage): void;
+}

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallbackModel = void 0;
+const BaseModel_1 = require("../../abstract/BaseModel");
+class CallbackModel extends BaseModel_1.BaseModel {
+    constructor(isEnabled, enableDuringBusinessHrs, enableDuringNonBusinessHrs, assignTask) {
+        super();
+        this._isEnabled = isEnabled;
+        this._enableDuringBusinessHrs = enableDuringBusinessHrs;
+        this._enableDuringNonBusinessHrs = enableDuringNonBusinessHrs;
+        this._assignTask = assignTask;
+    }
+    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 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',
+            assignTask: (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.CallbackModel = CallbackModel;

package/lib/models/impl/callbackandvoicemail/VoicemailModel.d.ts

@@ -0,0 +1,25 @@
+import { BaseModel } from "../../abstract/BaseModel";
+import { validationMessage } from "../../interface/IBaseModel";
+export declare class VoicemailModel extends BaseModel {
+    private _isEnabled;
+    private _enableDuringBusinessHrs;
+    private _enableDuringNonBusinessHrs;
+    private _createReport;
+    private _assignTask;
+    private _sendEmail;
+    constructor(isEnabled: boolean, enableDuringBusinessHrs: boolean, enableDuringNonBusinessHrs: boolean, createReport: boolean, assignTask: boolean, sendEmail: boolean);
+    get isEnabled(): boolean;
+    set isEnabled(value: boolean);
+    get enableDuringBusinessHrs(): boolean;
+    set enableDuringBusinessHrs(value: boolean);
+    get enableDuringNonBusinessHrs(): boolean;
+    set enableDuringNonBusinessHrs(value: boolean);
+    get createReport(): boolean;
+    set createReport(value: boolean);
+    get sendEmail(): boolean;
+    set sendEmail(value: boolean);
+    get assignTask(): boolean;
+    set assignTask(value: boolean);
+    validateData(): validationMessage[];
+    setValidationMessages(message: validationMessage): void;
+}