hgs-twilio-class-lib 1.1.72 → 1.1.73

package/lib/models/impl/QuestionDetailsModel.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionDetailsModel = void 0;
+const BaseModel_1 = require("../abstract/BaseModel");
+class QuestionDetailsModel extends BaseModel_1.BaseModel {
+    constructor(question, score, yes, no, nA, comment, subInfoTitle, subInfo, subInfo2Title, subInfo2, defaultValue) {
+        super();
+        this._question = question;
+        this._score = score;
+        this._yes = yes;
+        this._no = no;
+        this._nA = nA;
+        this._comment = comment;
+        this._subInfoTitle = subInfoTitle;
+        this._subInfo = subInfo;
+        this._subInfo2Title = subInfo2Title;
+        this._subInfo2 = subInfo2;
+        this._defaultValue = defaultValue;
+    }
+    // Getters and Setters
+    get question() {
+        return this._question;
+    }
+    set question(value) {
+        if (typeof value === "string" && value.trim() !== "") {
+            this._question = value;
+        }
+        else {
+            throw new Error("Invalid question");
+        }
+    }
+    get score() {
+        return this._score;
+    }
+    set score(value) {
+        if (typeof value === "number" && value >= 0) {
+            this._score = value;
+        }
+        else {
+            throw new Error("Invalid score");
+        }
+    }
+    get yes() {
+        return this._yes;
+    }
+    set yes(value) {
+        if (typeof value === "boolean") {
+            this._yes = value;
+        }
+        else {
+            throw new Error("Invalid yes value");
+        }
+    }
+    get no() {
+        return this._no;
+    }
+    set no(value) {
+        if (typeof value === "boolean") {
+            this._no = value;
+        }
+        else {
+            throw new Error("Invalid no value");
+        }
+    }
+    get nA() {
+        return this._nA;
+    }
+    set nA(value) {
+        if (typeof value === "boolean") {
+            this._nA = value;
+        }
+        else {
+            throw new Error("Invalid nA value");
+        }
+    }
+    get comment() {
+        return this._comment;
+    }
+    set comment(value) {
+        if (typeof value === "string" && value.trim() !== "") {
+            this._comment = value;
+        }
+        else {
+            throw new Error("Invalid comment");
+        }
+    }
+    get subInfoTitle() {
+        return this._subInfoTitle;
+    }
+    set subInfoTitle(value) {
+        if (value === undefined || (typeof value === "string" && value.trim() !== "")) {
+            this._subInfoTitle = value;
+        }
+        else {
+            throw new Error("Invalid subInfoTitle");
+        }
+    }
+    get subInfo() {
+        return this._subInfo;
+    }
+    set subInfo(value) {
+        if (value === undefined || (Array.isArray(value) && value.every((item) => typeof item === "string"))) {
+            this._subInfo = value;
+        }
+        else {
+            throw new Error("Invalid subInfo");
+        }
+    }
+    get subInfo2Title() {
+        return this._subInfo2Title;
+    }
+    set subInfo2Title(value) {
+        if (value === undefined || (typeof value === "string" && value.trim() !== "")) {
+            this._subInfo2Title = value;
+        }
+        else {
+            throw new Error("Invalid subInfo2Title");
+        }
+    }
+    get subInfo2() {
+        return this._subInfo2;
+    }
+    set subInfo2(value) {
+        if (value === undefined || (Array.isArray(value) && value.every((item) => typeof item === "string"))) {
+            this._subInfo2 = value;
+        }
+        else {
+            throw new Error("Invalid subInfo2");
+        }
+    }
+    get defaultValue() {
+        return this._defaultValue;
+    }
+    set defaultValue(value) {
+        if (value === undefined || (typeof value === "string" && value.trim() !== "")) {
+            this._defaultValue = value;
+        }
+        else {
+            throw new Error("Invalid defaultValue");
+        }
+    }
+    // Validate data
+    validateData() {
+        this.validationMessages = [];
+        const validationRules = {
+            question: (value) => typeof value === "string" && value.trim() !== "",
+            score: (value) => typeof value === "number" && value >= 0,
+            yes: (value) => typeof value === "boolean",
+            no: (value) => typeof value === "boolean",
+            nA: (value) => typeof value === "boolean",
+            comment: (value) => typeof value === "string" && value.trim() !== "",
+            subInfoTitle: (value) => value === undefined || (typeof value === "string" && value.trim() !== ""),
+            subInfo: (value) => value === undefined || (Array.isArray(value) && value.every((item) => typeof item === "string")),
+            subInfo2Title: (value) => value === undefined || (typeof value === "string" && value.trim() !== ""),
+            subInfo2: (value) => value === undefined || (Array.isArray(value) && value.every((item) => typeof item === "string")),
+            defaultValue: (value) => value === undefined || (typeof value === "string" && value.trim() !== ""),
+        };
+        // Validate each property
+        Object.keys(validationRules).forEach((key) => {
+            const validator = validationRules[key];
+            const fieldValue = this[key];
+            if (!validator(fieldValue)) {
+                this.validationMessages.push({
+                    type: "Error",
+                    fieldDescription: key,
+                    message: `${key} is not valid`,
+                });
+            }
+        });
+        return this.validationMessages;
+    }
+}
+exports.QuestionDetailsModel = QuestionDetailsModel;

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

@@ -0,0 +1,63 @@
+import { BaseModel } from "../abstract/BaseModel";
+import { validationMessage } from "../interface/IBaseModel";
+export declare class QueueDetailsModel extends BaseModel {
+    private _id;
+    private _uniqueName;
+    private _periodNumber;
+    private _intOffr;
+    private _intAns;
+    private _intAbn;
+    private _slaTarget;
+    private _totalServiceLevel;
+    private _sumTalkTime;
+    private _sumHoldTime;
+    private _sumWaitTime;
+    private _longestWaitTime;
+    private _longestHoldTime;
+    private _longestTalkTime;
+    private _longestInboundACDIntereaction;
+    private _longestOutboundACDIntereaction;
+    private _createdAt;
+    private _updatedAt;
+    private _eventId;
+    constructor(id: string, uniqueName: string, periodNumber: string, intOffr: number, intAns: number, intAbn: number, slaTarget: number, totalServiceLevel: number, sumTalkTime: number, sumHoldTime: number, sumWaitTime: number, longestWaitTime: number, longestHoldTime: number, longestTalkTime: number, longestInboundACDIntereaction: number, longestOutboundACDIntereaction: number, createdAt: Date | undefined | string, updatedAt: Date | undefined | string, eventId: string);
+    get id(): string;
+    set id(value: string);
+    get uniqueName(): string;
+    set uniqueName(value: string);
+    get periodNumber(): string;
+    set periodNumber(value: string);
+    get intOffr(): number;
+    set intOffr(value: number);
+    get intAns(): number;
+    set intAns(value: number);
+    get intAbn(): number;
+    set intAbn(value: number);
+    get slaTarget(): number;
+    set slaTarget(value: number);
+    get totalServiceLevel(): number;
+    set totalServiceLevel(value: number);
+    get sumTalkTime(): number;
+    set sumTalkTime(value: number);
+    get sumHoldTime(): number;
+    set sumHoldTime(value: number);
+    get sumWaitTime(): number;
+    set sumWaitTime(value: number);
+    get longestWaitTime(): number;
+    set longestWaitTime(value: number);
+    get longestHoldTime(): number;
+    set longestHoldTime(value: number);
+    get longestTalkTime(): number;
+    set longestTalkTime(value: number);
+    get longestInboundACDIntereaction(): number;
+    set longestInboundACDIntereaction(value: number);
+    get longestOutboundACDIntereaction(): number;
+    set longestOutboundACDIntereaction(value: number);
+    get createdAt(): Date | undefined | string;
+    set createdAt(value: Date | undefined | string);
+    get updatedAt(): Date | undefined | string;
+    set updatedAt(value: Date | undefined | string);
+    get eventId(): string;
+    set eventId(value: string);
+    validateData(): validationMessage[];
+}

package/lib/models/impl/QueueDetailsModel.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueDetailsModel = void 0;
+const BaseModel_1 = require("../abstract/BaseModel");
+class QueueDetailsModel extends BaseModel_1.BaseModel {
+    constructor(id, uniqueName, periodNumber, intOffr, intAns, intAbn, slaTarget, totalServiceLevel, sumTalkTime, sumHoldTime, sumWaitTime, longestWaitTime, longestHoldTime, longestTalkTime, longestInboundACDIntereaction, longestOutboundACDIntereaction, createdAt, updatedAt, eventId) {
+        super();
+        this._id = id;
+        this._uniqueName = uniqueName;
+        this._periodNumber = periodNumber;
+        this._intOffr = intOffr;
+        this._intAns = intAns;
+        this._intAbn = intAbn;
+        this._slaTarget = slaTarget;
+        this._totalServiceLevel = totalServiceLevel;
+        this._sumTalkTime = sumTalkTime;
+        this._sumHoldTime = sumHoldTime;
+        this._sumWaitTime = sumWaitTime;
+        this._longestWaitTime = longestWaitTime;
+        this._longestHoldTime = longestHoldTime;
+        this._longestTalkTime = longestTalkTime;
+        this._longestInboundACDIntereaction = longestInboundACDIntereaction;
+        this._longestOutboundACDIntereaction = longestOutboundACDIntereaction;
+        this._createdAt = createdAt;
+        this._updatedAt = updatedAt;
+        this._eventId = eventId;
+    }
+    // Getters and Setters
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    get uniqueName() {
+        return this._uniqueName;
+    }
+    set uniqueName(value) {
+        this._uniqueName = value;
+    }
+    get periodNumber() {
+        return this._periodNumber;
+    }
+    set periodNumber(value) {
+        this._periodNumber = value;
+    }
+    get intOffr() {
+        return this.intOffr;
+    }
+    set intOffr(value) {
+        this.intOffr = value;
+    }
+    get intAns() {
+        return this._intAns;
+    }
+    set intAns(value) {
+        this._intAns = value;
+    }
+    get intAbn() {
+        return this._intAbn;
+    }
+    set intAbn(value) {
+        this._intAbn = value;
+    }
+    get slaTarget() {
+        return this._slaTarget;
+    }
+    set slaTarget(value) {
+        this._slaTarget = value;
+    }
+    get totalServiceLevel() {
+        return this._totalServiceLevel;
+    }
+    set totalServiceLevel(value) {
+        this._totalServiceLevel = value;
+    }
+    get sumTalkTime() {
+        return this._sumTalkTime;
+    }
+    set sumTalkTime(value) {
+        this._sumTalkTime = value;
+    }
+    get sumHoldTime() {
+        return this._sumHoldTime;
+    }
+    set sumHoldTime(value) {
+        this._sumHoldTime = value;
+    }
+    get sumWaitTime() {
+        return this._sumWaitTime;
+    }
+    set sumWaitTime(value) {
+        this._sumWaitTime = value;
+    }
+    get longestWaitTime() {
+        return this._longestWaitTime;
+    }
+    set longestWaitTime(value) {
+        this._longestWaitTime = value;
+    }
+    get longestHoldTime() {
+        return this._longestHoldTime;
+    }
+    set longestHoldTime(value) {
+        this._longestHoldTime = value;
+    }
+    get longestTalkTime() {
+        return this._longestTalkTime;
+    }
+    set longestTalkTime(value) {
+        this._longestTalkTime = value;
+    }
+    get longestInboundACDIntereaction() {
+        return this._longestInboundACDIntereaction;
+    }
+    set longestInboundACDIntereaction(value) {
+        this._longestInboundACDIntereaction = value;
+    }
+    get longestOutboundACDIntereaction() {
+        return this._longestOutboundACDIntereaction;
+    }
+    set longestOutboundACDIntereaction(value) {
+        this._longestOutboundACDIntereaction = value;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    set createdAt(value) {
+        this._createdAt = value;
+    }
+    get updatedAt() {
+        return this._updatedAt;
+    }
+    set updatedAt(value) {
+        this._updatedAt = value;
+    }
+    get eventId() {
+        return this._eventId;
+    }
+    set eventId(value) {
+        this._eventId = 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._uniqueName !== "string" || !this._uniqueName.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "uniqueName",
+                message: "Unique name must be a non-empty string",
+            });
+        }
+        if (typeof this._periodNumber !== "string" || !this._periodNumber.trim()) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "periodNumber",
+                message: "Period number must be a non-empty string",
+            });
+        }
+        if (typeof this._intOffr !== "number" || this.intOffr < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "intOffr",
+                message: "intOffr must be a non-negative number",
+            });
+        }
+        if (typeof this._intAns !== "number" || this._intAns < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "intAns",
+                message: "intAns must be a non-negative number",
+            });
+        }
+        if (typeof this._intAbn !== "number" || this._intAbn < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "intAbn",
+                message: "intAbn must be a non-negative number",
+            });
+        }
+        if (typeof this._slaTarget !== "number" || this._slaTarget < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "slaTarget",
+                message: "slaTarget must be a non-negative number",
+            });
+        }
+        if (typeof this._totalServiceLevel !== "number" || this._totalServiceLevel < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "totalServiceLevel",
+                message: "totalServiceLevel must be a non-negative number",
+            });
+        }
+        if (typeof this._sumTalkTime !== "number" || this._sumTalkTime < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "sumTalkTime",
+                message: "sumTalkTime must be a non-negative number",
+            });
+        }
+        if (typeof this._sumHoldTime !== "number" || this._sumHoldTime < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "sumHoldTime",
+                message: "sumHoldTime must be a non-negative number",
+            });
+        }
+        if (typeof this._sumWaitTime !== "number" || this._sumWaitTime < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "sumWaitTime",
+                message: "sumWaitTime must be a non-negative number",
+            });
+        }
+        if (typeof this._longestWaitTime !== "number" || this._longestWaitTime < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "longestWaitTime",
+                message: "longestWaitTime must be a non-negative number",
+            });
+        }
+        if (typeof this._longestHoldTime !== "number" || this._longestHoldTime < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "longestHoldTime",
+                message: "longestHoldTime must be a non-negative number",
+            });
+        }
+        if (typeof this._longestTalkTime !== "number" || this._longestTalkTime < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "longestTalkTime",
+                message: "longestTalkTime must be a non-negative number",
+            });
+        }
+        if (typeof this._longestInboundACDIntereaction !== "number" || this._longestInboundACDIntereaction < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "longestInboundACDIntereaction",
+                message: "longestInboundACDIntereaction must be a non-negative number",
+            });
+        }
+        if (typeof this._longestOutboundACDIntereaction !== "number" || this._longestOutboundACDIntereaction < 0) {
+            this.validationMessages.push({
+                type: "Error",
+                fieldDescription: "longestOutboundACDIntereaction",
+                message: "longestOutboundACDIntereaction must be a non-negative number",
+            });
+        }
+        return this.validationMessages;
+    }
+}
+exports.QueueDetailsModel = QueueDetailsModel;

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

@@ -0,0 +1,39 @@
+import { BaseModel } from "../abstract/BaseModel";
+import { validationMessage } from "../interface/IBaseModel";
+type Department = "gather" | "say";
+type Skills = "text" | "audio";
+export declare class QueueModel extends BaseModel {
+    private _id;
+    private _name;
+    private _duration;
+    private _state;
+    private _queue;
+    private _user;
+    private _station;
+    private _from;
+    private _to;
+    private _interactionId;
+    constructor(id: string, name: string, duration: string, state: Department, queue: Skills, user: string, station: string | null, from: string | null, to: string | null, interactionId: string);
+    get id(): string;
+    set id(value: string);
+    get name(): string;
+    set name(value: string);
+    get duration(): string;
+    set duration(value: string);
+    get state(): Department;
+    set state(value: Department);
+    get queue(): Skills;
+    set queue(value: Skills);
+    get user(): string;
+    set user(value: string);
+    get station(): string | null;
+    set station(value: string | null);
+    get from(): string | null;
+    set from(value: string | null);
+    get to(): string | null;
+    set to(value: string | null);
+    get interactionId(): string;
+    set interactionId(value: string);
+    validateData(): validationMessage[];
+}
+export {};

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;