hgs-twilio-class-lib 1.1.72 → 1.1.74

package/lib/models/impl/QueueModel.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueModel = void 0;
+const BaseModel_1 = require("../abstract/BaseModel");
+class QueueModel extends BaseModel_1.BaseModel {
+    constructor(id, name, duration, state, queue, user, station, from, to, interactionId) {
+        super();
+        this._id = id;
+        this._name = name;
+        this._duration = duration;
+        this._state = state;
+        this._queue = queue;
+        this._user = user;
+        this._station = station;
+        this._from = from;
+        this._to = to;
+        this._interactionId = interactionId;
+    }
+    // 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 duration() {
+        return this._duration;
+    }
+    set duration(value) {
+        this._duration = value;
+    }
+    get state() {
+        return this._state;
+    }
+    set state(value) {
+        this._state = value;
+    }
+    get queue() {
+        return this._queue;
+    }
+    set queue(value) {
+        this._queue = value;
+    }
+    get user() {
+        return this._user;
+    }
+    set user(value) {
+        this._user = value;
+    }
+    get station() {
+        return this._station;
+    }
+    set station(value) {
+        this._station = value;
+    }
+    get from() {
+        return this._from;
+    }
+    set from(value) {
+        this._from = value;
+    }
+    get to() {
+        return this._to;
+    }
+    set to(value) {
+        this._to = value;
+    }
+    get interactionId() {
+        return this._interactionId;
+    }
+    set interactionId(value) {
+        this._interactionId = value;
+    }
+    // Validation Method
+    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 (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._duration !== "string" || !this._duration.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "duration",
+                message: "Duration must be a non-empty string",
+            });
+        }
+        if (!["Gather", "Say"].includes(this._state)) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "state",
+                message: "State must be either 'Gather' or 'Say'",
+            });
+        }
+        if (!["Text", "Audio"].includes(this._queue)) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "queue",
+                message: "Queue must be either 'Text' or 'Audio'",
+            });
+        }
+        if (typeof this._user !== "string" || !this._user.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "user",
+                message: "User must be a non-empty string",
+            });
+        }
+        if (this._station && typeof this._station !== "string") {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "station",
+                message: "Station must be a string or null",
+            });
+        }
+        if (this._from && typeof this._from !== "string") {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "from",
+                message: "From must be a string or null",
+            });
+        }
+        if (this._to && typeof this._to !== "string") {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "to",
+                message: "To must be a string or null",
+            });
+        }
+        if (typeof this._interactionId !== "string" || !this._interactionId.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "interactionId",
+                message: "Interaction ID must be a non-empty string",
+            });
+        }
+        return this.validationMessages;
+    }
+}
+exports.QueueModel = QueueModel;

package/lib/models/impl/QuickLinkModel.d.ts

@@ -0,0 +1,24 @@
+import { BaseModel } from "../abstract/BaseModel";
+import { validationMessage } from "../interface/IBaseModel";
+export declare class QuickLinkModel extends BaseModel {
+    private _id;
+    private _iframe;
+    private _label;
+    private _url;
+    private _createdAt;
+    private _updatedAt;
+    constructor(id: string, iframe: boolean, label: string, url: string, createdAt: Date, updatedAt: Date);
+    get id(): string;
+    set id(value: string);
+    get iframe(): boolean;
+    set iframe(value: boolean);
+    get label(): string;
+    set label(value: string);
+    get url(): string;
+    set url(value: string);
+    get createdAt(): Date;
+    set createdAt(value: Date);
+    get updatedAt(): Date;
+    set updatedAt(value: Date);
+    validateData(): validationMessage[];
+}

package/lib/models/impl/QuickLinkModel.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickLinkModel = void 0;
+const BaseModel_1 = require("../abstract/BaseModel");
+const uuid_1 = require("uuid");
+class QuickLinkModel extends BaseModel_1.BaseModel {
+    constructor(id, iframe, label, url, createdAt, updatedAt) {
+        super(); // Call the constructor of the BaseModelOld class with provided data
+        // Initialize the private attributes
+        this._id = id;
+        this._iframe = iframe;
+        this._label = label;
+        this._url = url;
+        this._createdAt = createdAt;
+        this._updatedAt = updatedAt;
+    }
+    // Getters and Setters for each private attribute
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        if (typeof value === "string" && value.trim() !== "" && (0, uuid_1.validate)(value)) {
+            this._id = value;
+        }
+        else {
+            console.error("Invalid id");
+        }
+    }
+    get iframe() {
+        return this._iframe;
+    }
+    set iframe(value) {
+        if (typeof value === "boolean") {
+            this._iframe = value;
+        }
+        else {
+            console.error("Invalid iframe value");
+        }
+    }
+    get label() {
+        return this._label;
+    }
+    set label(value) {
+        if (typeof value === "string" && value.trim() !== "") {
+            this._label = value;
+        }
+        else {
+            console.error("Invalid label value");
+        }
+    }
+    get url() {
+        return this._url;
+    }
+    set url(value) {
+        if (typeof value === "string" && value.trim() !== "") {
+            this._url = value;
+        }
+        else {
+            console.error("Invalid url value");
+        }
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    set createdAt(value) {
+        if (value instanceof Date || value === undefined) {
+            this._createdAt = value;
+        }
+        else {
+            console.error("Invalid createdAt value");
+        }
+    }
+    get updatedAt() {
+        return this._updatedAt;
+    }
+    set updatedAt(value) {
+        if (value instanceof Date || value === undefined) {
+            this._updatedAt = value;
+        }
+        else {
+            console.error("Invalid updatedAt value");
+        }
+    }
+    // Method to validate data based on predefined rules
+    validateData() {
+        this.validationMessages = []; // Clear any existing validation messages
+        // Define validation rules for each property of the quick links data
+        const validationRules = {
+            id: (value) => typeof value === "string" && value.trim() !== "" && (0, uuid_1.validate)(value),
+            iframe: (value) => typeof value === "boolean",
+            label: (value) => typeof value === "string" && value.trim() !== "",
+            url: (value) => typeof value === "string" && value.trim() !== "",
+            createdAt: (value) => {
+                const parsedDate = new Date(value);
+                return parsedDate instanceof Date && !isNaN(parsedDate.getTime());
+            },
+            updatedAt: (value) => {
+                const parsedDate = new Date(value);
+                return parsedDate instanceof Date && !isNaN(parsedDate.getTime());
+            },
+        };
+        // Iterate through each property and validate against its respective rule
+        for (const key in validationRules) {
+            if (!validationRules.hasOwnProperty(key))
+                continue;
+            const validator = validationRules[key];
+            const value = this[key]; // Access private attributes directly
+            // Check if the property exists and passes the validation rule
+            if (!validator(value)) {
+                // If validation fails, add a validation message to the list
+                console.error(`Validation failed for property "${key}".`);
+                this.validationMessages.push({
+                    type: "Error",
+                    fieldDescription: key,
+                    message: `${key} is not valid`,
+                });
+            }
+        }
+        return this.validationMessages;
+    }
+}
+exports.QuickLinkModel = QuickLinkModel;

package/lib/models/impl/StatisticsNumberDetailsModel.d.ts

@@ -0,0 +1,18 @@
+import { BaseModel } from "../abstract/BaseModel";
+import { validationMessage } from "../interface/IBaseModel";
+export declare class StatisticsNumberDetailsModel extends BaseModel {
+    private _currentPeriod;
+    private _currentShift;
+    private _previousPeriod;
+    private _previousShift;
+    constructor(currentPeriod: number, currentShift: number, previousPeriod: number, previousShift: number);
+    get currentPeriod(): number;
+    set currentPeriod(value: number);
+    get currentShift(): number;
+    set currentShift(value: number);
+    get previousPeriod(): number;
+    set previousPeriod(value: number);
+    get previousShift(): number;
+    set previousShift(value: number);
+    validateData(): validationMessage[];
+}

package/lib/models/impl/StatisticsNumberDetailsModel.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatisticsNumberDetailsModel = void 0;
+const BaseModel_1 = require("../abstract/BaseModel");
+class StatisticsNumberDetailsModel extends BaseModel_1.BaseModel {
+    constructor(currentPeriod, currentShift, previousPeriod, previousShift) {
+        super();
+        this._currentPeriod = currentPeriod;
+        this._currentShift = currentShift;
+        this._previousPeriod = previousPeriod;
+        this._previousShift = previousShift;
+    }
+    // Getters and Setters
+    get currentPeriod() {
+        return this._currentPeriod;
+    }
+    set currentPeriod(value) {
+        this._currentPeriod = value;
+    }
+    get currentShift() {
+        return this._currentShift;
+    }
+    set currentShift(value) {
+        this._currentShift = value;
+    }
+    get previousPeriod() {
+        return this._previousPeriod;
+    }
+    set previousPeriod(value) {
+        this._previousPeriod = value;
+    }
+    get previousShift() {
+        return this._previousShift;
+    }
+    set previousShift(value) {
+        this._previousShift = value;
+    }
+    // Validation Method
+    validateData() {
+        this.validationMessages = [];
+        if (typeof this._currentPeriod !== "number" || this._currentPeriod < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "currentPeriod",
+                message: "Current period must be a non-negative number",
+            });
+        }
+        if (typeof this._currentShift !== "number" || this._currentShift < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "currentShift",
+                message: "Current shift must be a non-negative number",
+            });
+        }
+        if (typeof this._previousPeriod !== "number" || this._previousPeriod < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "previousPeriod",
+                message: "Previous period must be a non-negative number",
+            });
+        }
+        if (typeof this._previousShift !== "number" || this._previousShift < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "previousShift",
+                message: "Previous shift must be a non-negative number",
+            });
+        }
+        return this.validationMessages;
+    }
+}
+exports.StatisticsNumberDetailsModel = StatisticsNumberDetailsModel;

package/lib/models/impl/StatisticsTimeDetailsModel.d.ts

@@ -0,0 +1,18 @@
+import { BaseModel } from "../abstract/BaseModel";
+import { validationMessage } from "../interface/IBaseModel";
+export declare class StatisticsTimeDetailsModel extends BaseModel {
+    private _currentPeriod;
+    private _currentShift;
+    private _previousPeriod;
+    private _previousShift;
+    constructor(currentPeriod: string, currentShift: string, previousPeriod: string, previousShift: string);
+    get currentPeriod(): string;
+    set currentPeriod(value: string);
+    get currentShift(): string;
+    set currentShift(value: string);
+    get previousPeriod(): string;
+    set previousPeriod(value: string);
+    get previousShift(): string;
+    set previousShift(value: string);
+    validateData(): validationMessage[];
+}

package/lib/models/impl/StatisticsTimeDetailsModel.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatisticsTimeDetailsModel = void 0;
+const BaseModel_1 = require("../abstract/BaseModel");
+class StatisticsTimeDetailsModel extends BaseModel_1.BaseModel {
+    constructor(currentPeriod, currentShift, previousPeriod, previousShift) {
+        super();
+        this._currentPeriod = currentPeriod;
+        this._currentShift = currentShift;
+        this._previousPeriod = previousPeriod;
+        this._previousShift = previousShift;
+    }
+    // Getters and Setters
+    get currentPeriod() {
+        return this._currentPeriod;
+    }
+    set currentPeriod(value) {
+        this._currentPeriod = value;
+    }
+    get currentShift() {
+        return this._currentShift;
+    }
+    set currentShift(value) {
+        this._currentShift = value;
+    }
+    get previousPeriod() {
+        return this._previousPeriod;
+    }
+    set previousPeriod(value) {
+        this._previousPeriod = value;
+    }
+    get previousShift() {
+        return this._previousShift;
+    }
+    set previousShift(value) {
+        this._previousShift = value;
+    }
+    // Validation Method
+    validateData() {
+        this.validationMessages = [];
+        if (typeof this._currentPeriod !== "string" || !this._currentPeriod.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "currentPeriod",
+                message: "Current period must be a non-empty string",
+            });
+        }
+        if (typeof this._currentShift !== "string" || !this._currentShift.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "currentShift",
+                message: "Current shift must be a non-empty string",
+            });
+        }
+        if (typeof this._previousPeriod !== "string" || !this._previousPeriod.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "previousPeriod",
+                message: "Previous period must be a non-empty string",
+            });
+        }
+        if (typeof this._previousShift !== "string" || !this._previousShift.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "previousShift",
+                message: "Previous shift must be a non-empty string",
+            });
+        }
+        return this.validationMessages;
+    }
+}
+exports.StatisticsTimeDetailsModel = StatisticsTimeDetailsModel;

package/lib/models/impl/TaskAttributesModel.d.ts

@@ -0,0 +1,31 @@
+import { validationMessage } from "../interface/IBaseModel";
+import { BaseModel } from "../abstract/BaseModel";
+export declare enum ChannelTypeEnum {
+    voice = "voice",
+    chat = "chat",
+    sms = "sms",
+    video = "video",
+    email = "email"
+}
+export declare class TaskAttributesModel extends BaseModel {
+    private _channelType;
+    private _from;
+    private _email;
+    private _customerDevice;
+    private _onHoldTime;
+    private _conversationSid;
+    constructor(channelType: ChannelTypeEnum, from: string, email: string, customerDevice: string, onHoldTime: number, conversationSid: string);
+    get channelType(): ChannelTypeEnum;
+    set channelType(value: ChannelTypeEnum);
+    get from(): string;
+    set from(value: string);
+    get email(): string;
+    set email(value: string);
+    get customerDevice(): string;
+    set customerDevice(value: string);
+    get onHoldTime(): number;
+    set onHoldTime(value: number);
+    get conversationSid(): string;
+    set conversationSid(value: string);
+    validateData(): validationMessage[];
+}

package/lib/models/impl/TaskAttributesModel.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskAttributesModel = exports.ChannelTypeEnum = void 0;
+const BaseModel_1 = require("../abstract/BaseModel");
+var ChannelTypeEnum;
+(function (ChannelTypeEnum) {
+    ChannelTypeEnum["voice"] = "voice";
+    ChannelTypeEnum["chat"] = "chat";
+    ChannelTypeEnum["sms"] = "sms";
+    ChannelTypeEnum["video"] = "video";
+    ChannelTypeEnum["email"] = "email";
+})(ChannelTypeEnum || (exports.ChannelTypeEnum = ChannelTypeEnum = {}));
+class TaskAttributesModel extends BaseModel_1.BaseModel {
+    constructor(channelType, from, email, customerDevice, onHoldTime, conversationSid) {
+        super();
+        this._channelType = channelType;
+        this._from = from;
+        this._email = email;
+        this._customerDevice = customerDevice;
+        this._onHoldTime = onHoldTime;
+        this._conversationSid = conversationSid;
+    }
+    // Getters and Setters
+    get channelType() {
+        return this._channelType;
+    }
+    set channelType(value) {
+        this._channelType = value;
+    }
+    get from() {
+        return this._from;
+    }
+    set from(value) {
+        this._from = value;
+    }
+    get email() {
+        return this._email;
+    }
+    set email(value) {
+        this._email = value;
+    }
+    get customerDevice() {
+        return this._customerDevice;
+    }
+    set customerDevice(value) {
+        this._customerDevice = value;
+    }
+    get onHoldTime() {
+        return this._onHoldTime;
+    }
+    set onHoldTime(value) {
+        this._onHoldTime = value;
+    }
+    get conversationSid() {
+        return this._conversationSid;
+    }
+    set conversationSid(value) {
+        this._conversationSid = value;
+    }
+    // Validation Method
+    validateData() {
+        this.validationMessages = [];
+        if (!Object.values(ChannelTypeEnum).includes(this._channelType)) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "channelType",
+                message: "ChannelType must be a valid enum value",
+            });
+        }
+        if (typeof this._from !== "string" || !this._from.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "from",
+                message: "From must be a non-empty string",
+            });
+        }
+        if (typeof this._email !== "string" || !this._email.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "email",
+                message: "Email must be a non-empty string",
+            });
+        }
+        if (typeof this._customerDevice !== "string" || !this._customerDevice.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "customerDevice",
+                message: "CustomerDevice must be a non-empty string",
+            });
+        }
+        if (typeof this._onHoldTime !== "number" || this._onHoldTime < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "onHoldTime",
+                message: "OnHoldTime must be a non-negative number",
+            });
+        }
+        if (typeof this._conversationSid !== "string" || !this._conversationSid.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "conversationSid",
+                message: "ConversationSid must be a non-empty string",
+            });
+        }
+        return this.validationMessages;
+    }
+}
+exports.TaskAttributesModel = TaskAttributesModel;

package/lib/models/impl/TaskChannelModel.d.ts

@@ -0,0 +1,15 @@
+import { BaseModel } from "../abstract/BaseModel";
+import { validationMessage } from "../interface/IBaseModel";
+export declare class TaskChannelModel extends BaseModel {
+    private _channel;
+    private _capacity;
+    private _isAvailable;
+    constructor(channel: string, capacity: number, isAvailable: boolean);
+    get channel(): string;
+    set channel(value: string);
+    get capacity(): number;
+    set capacity(value: number);
+    get isAvailable(): boolean;
+    set isAvailable(value: boolean);
+    validateData(): validationMessage[];
+}