tnzapi-ts 3.0.0

package/dist/Api/Addressbook/interfaces/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IContactArgs"), exports);
+__exportStar(require("./IGroupArgs"), exports);
+__exportStar(require("./IContactGroupArgs"), exports);
+__exportStar(require("./IGroupContactArgs"), exports);

package/dist/Api/Messaging/BaseMessagingApi.d.ts

@@ -0,0 +1,28 @@
+import { IMessagingModel } from './models';
+import { MessagingApiSuccessResponseDTO, MessagingBaseRequestDTO } from './dtos';
+import { ErrorResponseDTO } from "../../Common/dtos";
+import { IHttpClient } from "../../Common/IHttpClient";
+import { ValidationResult } from "../../Common/ValidationResult";
+import { IAddRecipientArg } from "./helpers/AddRecipient";
+export declare abstract class BaseMessagingApi<T extends IMessagingModel> {
+    protected readonly baseUrl: string;
+    protected readonly authToken: string;
+    protected readonly httpClient: IHttpClient;
+    protected abstract entity: T;
+    protected abstract readonly apiEndpoint: string;
+    constructor(baseUrl: string, authToken: string, httpClient?: IHttpClient);
+    protected abstract createEntity(): T;
+    protected abstract validate(entity: T): ValidationResult;
+    protected abstract createRequestDTO(entity: T): MessagingBaseRequestDTO;
+    /**
+     * Single-destination shorthand fields this channel accepts, as [inputFieldName, destinationKey]
+     * pairs. Override in subclasses; default is none. See resolveSingleDestinations().
+     */
+    protected singleDestinationFields(): Array<[string, string]>;
+    private resolveSingleDestinations;
+    SendMessage(args?: any): Promise<MessagingApiSuccessResponseDTO | ErrorResponseDTO>;
+    protected processAttachments(entity: T): Promise<void>;
+    protected baseValidate(entity: T): ValidationResult;
+    AddRecipient(recipient: IAddRecipientArg<T['Destinations'][number]>): this;
+    AddAttachment(attachment: string): this;
+}

package/dist/Api/Messaging/BaseMessagingApi.js

@@ -0,0 +1,152 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseMessagingApi = void 0;
+const Functions_1 = require("../../Functions");
+const helpers = __importStar(require("./helpers"));
+const NodeHttpClient_1 = require("../../Common/NodeHttpClient");
+class BaseMessagingApi {
+    constructor(baseUrl, authToken, httpClient = new NodeHttpClient_1.NodeHttpClient(authToken)) {
+        this.baseUrl = baseUrl;
+        this.authToken = authToken;
+        this.httpClient = httpClient;
+    }
+    /**
+     * Single-destination shorthand fields this channel accepts, as [inputFieldName, destinationKey]
+     * pairs. Override in subclasses; default is none. See resolveSingleDestinations().
+     */
+    singleDestinationFields() {
+        return [];
+    }
+    resolveSingleDestinations(entity) {
+        for (const [field, destinationKey] of this.singleDestinationFields()) {
+            const raw = entity[field];
+            if (typeof raw === 'string' && !Functions_1.UsefulStuff.isEmpty(raw)) {
+                for (const value of raw.split(',').map(v => v.trim()).filter(v => v.length > 0)) {
+                    entity.Destinations.push({ [destinationKey]: value });
+                }
+            }
+            // Clear unconditionally so this transient field can never leak into the
+            // outbound request DTO — Map() copies any own property of `entity`, not just
+            // ones the target DTO class declares (see Functions/Mapper.ts).
+            entity[field] = undefined;
+        }
+    }
+    async SendMessage(args) {
+        if (args) {
+            (0, Functions_1.Map)(this.entity, args);
+        }
+        const currentEntity = this.entity;
+        this.entity = this.createEntity(); // Reset state for next call
+        this.resolveSingleDestinations(currentEntity);
+        const validation = this.validate(currentEntity);
+        if (!validation.valid) {
+            return helpers.MapApiResponse({
+                "Result": "Error",
+                "ErrorMessage": [validation.error || "An error occurred while processing."]
+            });
+        }
+        try {
+            await this.processAttachments(currentEntity);
+        }
+        catch (err) {
+            return helpers.MapApiResponse({
+                "Result": "Error",
+                "ErrorMessage": [`Failed to process attachments: ${err?.message ?? err}`]
+            });
+        }
+        const responseData = await this.httpClient.post(`${this.baseUrl}${this.apiEndpoint}`, this.createRequestDTO(currentEntity));
+        return helpers.MapApiResponse(responseData);
+    }
+    async processAttachments(entity) {
+        if (!Functions_1.UsefulStuff.isEmpty(entity.Attachments)) {
+            const files = await Promise.all(entity.Attachments.map(async (attachment) => {
+                const baseName = Functions_1.FileHandler.getBaseName(attachment);
+                const fileData = await Functions_1.FileHandler.getFileData(attachment);
+                return {
+                    Name: baseName,
+                    Data: fileData
+                };
+            }));
+            entity.Files.push(...files);
+        }
+    }
+    baseValidate(entity) {
+        if (Functions_1.UsefulStuff.isEmpty(this.authToken)) {
+            return { valid: false, error: "Missing AuthToken" };
+        }
+        if (!Functions_1.UsefulStuff.isEmpty(entity.WebhookCallbackURL)) {
+            const validFormats = ["JSON", "XML", "POST", "GET"];
+            if (Functions_1.UsefulStuff.isEmpty(entity.WebhookCallbackFormat) ||
+                !validFormats.includes(entity.WebhookCallbackFormat?.toUpperCase() ?? "")) {
+                return { valid: false, error: "Missing or invalid WebhookCallbackFormat - JSON, XML, POST or GET" };
+            }
+        }
+        if (!Functions_1.UsefulStuff.isEmpty(entity.SendTime) && !Functions_1.UsefulStuff.isDateTime(entity.SendTime)) {
+            return { valid: false, error: "Unable to parse SendTime. Use YYYY-MM-DD hh:mm format." };
+        }
+        if (Functions_1.UsefulStuff.isEmpty(entity.Destinations)) {
+            return { valid: false, error: "Empty Destination(s)" };
+        }
+        if (!Functions_1.UsefulStuff.isEmpty(entity.Files)) {
+            for (let i = 0; i < entity.Files.length; i++) {
+                if (Functions_1.UsefulStuff.isEmpty(entity.Files[i].Name)) {
+                    return { valid: false, error: "Could not find attachment file name." };
+                }
+                if (Functions_1.UsefulStuff.isEmpty(entity.Files[i].Data)) {
+                    return { valid: false, error: `Could not parse attachment file data ${entity.Files[i].Name}` };
+                }
+            }
+        }
+        if (!Functions_1.UsefulStuff.isEmpty(entity.Mode) && entity.Mode?.toUpperCase() !== "TEST") {
+            return { valid: false, error: "Only Mode=Test is allowed" };
+        }
+        return { valid: true };
+    }
+    AddRecipient(recipient) {
+        const targets = helpers.AddRecipient(recipient);
+        if (!Functions_1.UsefulStuff.isEmpty(targets)) {
+            this.entity.Destinations.push(...targets);
+        }
+        return this;
+    }
+    AddAttachment(attachment) {
+        if (Functions_1.FileHandler.fileExists(attachment)) {
+            this.entity.Attachments.push(attachment);
+        }
+        return this;
+    }
+}
+exports.BaseMessagingApi = BaseMessagingApi;

package/dist/Api/Messaging/EmailApi.d.ts

@@ -0,0 +1,21 @@
+import { EmailModel } from './models';
+import { MessagingApiSuccessResponseDTO, MessagingBaseRequestDTO } from './dtos';
+import { BaseMessagingApi } from './BaseMessagingApi';
+import { IHttpClient } from '../../Common/IHttpClient';
+import { ErrorResponseDTO } from '../../Common/dtos';
+import { ValidationResult } from '../../Common/ValidationResult';
+import { IEmailArgs } from './interfaces';
+export declare class EmailApi extends BaseMessagingApi<EmailModel> {
+    protected entity: EmailModel;
+    protected readonly apiEndpoint = "/email";
+    constructor(args: {
+        URL: string;
+        AuthToken?: string;
+        httpClient?: IHttpClient;
+    });
+    protected createEntity(): EmailModel;
+    protected singleDestinationFields(): Array<[string, string]>;
+    SendMessage(args?: IEmailArgs): Promise<MessagingApiSuccessResponseDTO | ErrorResponseDTO>;
+    protected validate(entity: EmailModel): ValidationResult;
+    protected createRequestDTO(entity: EmailModel): MessagingBaseRequestDTO;
+}

package/dist/Api/Messaging/EmailApi.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailApi = void 0;
+const Functions_1 = require("../../Functions");
+const models_1 = require("./models");
+const dtos_1 = require("./dtos");
+const BaseMessagingApi_1 = require("./BaseMessagingApi");
+class EmailApi extends BaseMessagingApi_1.BaseMessagingApi {
+    constructor(args) {
+        super(args.URL, args.AuthToken || "", args.httpClient);
+        this.apiEndpoint = "/email";
+        this.entity = new models_1.EmailModel(args);
+    }
+    createEntity() {
+        return new models_1.EmailModel();
+    }
+    singleDestinationFields() {
+        return [['EmailAddress', 'EmailAddress'], ['GroupID', 'GroupID'], ['ContactID', 'ContactID']];
+    }
+    async SendMessage(args) {
+        return super.SendMessage(args);
+    }
+    validate(entity) {
+        const baseValidation = this.baseValidate(entity);
+        if (!baseValidation.valid) {
+            return baseValidation;
+        }
+        if (Functions_1.UsefulStuff.isEmpty(entity.EmailSubject)) {
+            return { valid: false, error: "Missing EmailSubject" };
+        }
+        if (Functions_1.UsefulStuff.isEmpty(entity.MessagePlain) && Functions_1.UsefulStuff.isEmpty(entity.MessageHTML) && Functions_1.UsefulStuff.isEmpty(entity.TemplateID)) {
+            return { valid: false, error: "Missing MessagePlain, MessageHTML or TemplateID" };
+        }
+        for (let i = 0; i < entity.Destinations.length; i++) {
+            const destination = entity.Destinations[i];
+            const address = destination.EmailAddress ?? destination.Recipient;
+            if (!Functions_1.UsefulStuff.isEmpty(address) && !Functions_1.UsefulStuff.isEmail(address)) {
+                return { valid: false, error: `Invalid EmailAddress - must be email address - ${address}` };
+            }
+        }
+        return { valid: true };
+    }
+    createRequestDTO(entity) {
+        return new dtos_1.EmailApiRequestDTO(entity);
+    }
+}
+exports.EmailApi = EmailApi;

package/dist/Api/Messaging/FaxApi.d.ts

@@ -0,0 +1,18 @@
+import { FaxModel } from './models';
+import { MessagingBaseRequestDTO } from './dtos';
+import { BaseMessagingApi } from './BaseMessagingApi';
+import { IHttpClient } from '../../Common/IHttpClient';
+import { ValidationResult } from '../../Common/ValidationResult';
+export declare class FaxApi extends BaseMessagingApi<FaxModel> {
+    protected entity: FaxModel;
+    protected readonly apiEndpoint = "/fax";
+    constructor(args: {
+        URL: string;
+        AuthToken?: string;
+        httpClient?: IHttpClient;
+    });
+    protected createEntity(): FaxModel;
+    protected singleDestinationFields(): Array<[string, string]>;
+    protected validate(entity: FaxModel): ValidationResult;
+    protected createRequestDTO(entity: FaxModel): MessagingBaseRequestDTO;
+}

package/dist/Api/Messaging/FaxApi.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FaxApi = void 0;
+const Functions_1 = require("../../Functions");
+const models_1 = require("./models");
+const dtos_1 = require("./dtos");
+const BaseMessagingApi_1 = require("./BaseMessagingApi");
+class FaxApi extends BaseMessagingApi_1.BaseMessagingApi {
+    constructor(args) {
+        super(args.URL, args.AuthToken || "", args.httpClient);
+        this.apiEndpoint = "/fax";
+        this.entity = new models_1.FaxModel(args);
+    }
+    createEntity() {
+        return new models_1.FaxModel();
+    }
+    singleDestinationFields() {
+        return [['ToNumber', 'ToNumber'], ['GroupID', 'GroupID'], ['ContactID', 'ContactID']];
+    }
+    validate(entity) {
+        const baseValidation = this.baseValidate(entity);
+        if (!baseValidation.valid) {
+            return baseValidation;
+        }
+        if (Functions_1.UsefulStuff.isEmpty(entity.TemplateID) && Functions_1.UsefulStuff.isEmpty(entity.Files) && Functions_1.UsefulStuff.isEmpty(entity.Attachments)) {
+            return { valid: false, error: "Missing fax contents - TemplateID or File Attachments required" };
+        }
+        if (!Functions_1.UsefulStuff.isEmpty(entity.RetryAttempts) && !Functions_1.UsefulStuff.isNumber(entity.RetryAttempts)) {
+            return { valid: false, error: "RetryAttempts must be a number" };
+        }
+        if (!Functions_1.UsefulStuff.isEmpty(entity.RetryPeriod) && !Functions_1.UsefulStuff.isNumber(entity.RetryPeriod)) {
+            return { valid: false, error: "RetryPeriod must be a number" };
+        }
+        for (let i = 0; i < entity.Destinations.length; i++) {
+            const destination = entity.Destinations[i];
+            const number = destination.ToNumber ?? destination.Recipient;
+            if (!Functions_1.UsefulStuff.isEmpty(number) && !Functions_1.UsefulStuff.isPhoneNumber(number)) {
+                return { valid: false, error: `Invalid Recipient - must be phone number - ${number}` };
+            }
+        }
+        return { valid: true };
+    }
+    createRequestDTO(entity) {
+        return new dtos_1.FaxApiRequestDTO(entity);
+    }
+}
+exports.FaxApi = FaxApi;

package/dist/Api/Messaging/RCSApi.d.ts

@@ -0,0 +1,21 @@
+import { RCSModel } from './models';
+import { MessagingApiSuccessResponseDTO, MessagingBaseRequestDTO } from './dtos';
+import { ErrorResponseDTO } from "../../Common/dtos";
+import { IHttpClient } from "../../Common/IHttpClient";
+import { ValidationResult } from "../../Common/ValidationResult";
+import { BaseMessagingApi } from './BaseMessagingApi';
+import { IRCSArgs } from './interfaces';
+export declare class RCSApi extends BaseMessagingApi<RCSModel> {
+    protected entity: RCSModel;
+    protected readonly apiEndpoint = "/rcs";
+    constructor(args: {
+        URL: string;
+        AuthToken?: string;
+        httpClient?: IHttpClient;
+    });
+    SendMessage(args?: IRCSArgs): Promise<MessagingApiSuccessResponseDTO | ErrorResponseDTO>;
+    protected createEntity(): RCSModel;
+    protected singleDestinationFields(): Array<[string, string]>;
+    protected validate(entity: RCSModel): ValidationResult;
+    protected createRequestDTO(entity: RCSModel): MessagingBaseRequestDTO;
+}

package/dist/Api/Messaging/RCSApi.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RCSApi = void 0;
+const Functions_1 = require("../../Functions");
+const models_1 = require("./models");
+const dtos_1 = require("./dtos");
+const BaseMessagingApi_1 = require("./BaseMessagingApi");
+class RCSApi extends BaseMessagingApi_1.BaseMessagingApi {
+    constructor(args) {
+        super(args.URL, args.AuthToken || "", args.httpClient);
+        this.apiEndpoint = "/rcs";
+        this.entity = new models_1.RCSModel();
+    }
+    async SendMessage(args) {
+        return super.SendMessage(args);
+    }
+    createEntity() {
+        return new models_1.RCSModel();
+    }
+    singleDestinationFields() {
+        return [['ToNumber', 'ToNumber'], ['GroupID', 'GroupID'], ['ContactID', 'ContactID']];
+    }
+    validate(entity) {
+        const base = this.baseValidate(entity);
+        if (!base.valid)
+            return base;
+        if (Functions_1.UsefulStuff.isEmpty(entity.Message) && Functions_1.UsefulStuff.isEmpty(entity.TemplateID)) {
+            return { valid: false, error: "Missing Message or TemplateID" };
+        }
+        for (const destination of entity.Destinations) {
+            if (!destination)
+                continue;
+            const number = destination.ToNumber || destination.Recipient;
+            if (!Functions_1.UsefulStuff.isEmpty(number) && !Functions_1.UsefulStuff.isPhoneNumber(number)) {
+                return { valid: false, error: `Invalid ToNumber - must be phone number - ${number}` };
+            }
+        }
+        return { valid: true };
+    }
+    createRequestDTO(entity) {
+        return new dtos_1.RCSApiRequestDTO(entity);
+    }
+}
+exports.RCSApi = RCSApi;

package/dist/Api/Messaging/SMSApi.d.ts

@@ -0,0 +1,21 @@
+import { SMSModel } from './models';
+import { MessagingApiSuccessResponseDTO, MessagingBaseRequestDTO } from './dtos';
+import { BaseMessagingApi } from './BaseMessagingApi';
+import { IHttpClient } from '../../Common/IHttpClient';
+import { ErrorResponseDTO } from '../../Common/dtos';
+import { ValidationResult } from '../../Common/ValidationResult';
+import { ISMSArgs } from './interfaces';
+export declare class SMSApi extends BaseMessagingApi<SMSModel> {
+    protected entity: SMSModel;
+    protected readonly apiEndpoint = "/sms";
+    constructor(args: {
+        URL: string;
+        AuthToken?: string;
+        httpClient?: IHttpClient;
+    });
+    protected createEntity(): SMSModel;
+    protected singleDestinationFields(): Array<[string, string]>;
+    SendMessage(args?: ISMSArgs): Promise<MessagingApiSuccessResponseDTO | ErrorResponseDTO>;
+    protected validate(entity: SMSModel): ValidationResult;
+    protected createRequestDTO(entity: SMSModel): MessagingBaseRequestDTO;
+}

package/dist/Api/Messaging/SMSApi.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SMSApi = void 0;
+const Functions_1 = require("../../Functions");
+const models_1 = require("./models");
+const dtos_1 = require("./dtos");
+const BaseMessagingApi_1 = require("./BaseMessagingApi");
+class SMSApi extends BaseMessagingApi_1.BaseMessagingApi {
+    constructor(args) {
+        super(args.URL, args.AuthToken || "", args.httpClient);
+        this.apiEndpoint = "/sms";
+        this.entity = new models_1.SMSModel(args);
+    }
+    createEntity() {
+        return new models_1.SMSModel();
+    }
+    singleDestinationFields() {
+        return [['ToNumber', 'ToNumber'], ['GroupID', 'GroupID'], ['ContactID', 'ContactID']];
+    }
+    async SendMessage(args) {
+        return super.SendMessage(args);
+    }
+    validate(entity) {
+        const baseValidation = this.baseValidate(entity);
+        if (!baseValidation.valid) {
+            return baseValidation;
+        }
+        if (Functions_1.UsefulStuff.isEmpty(entity.Message) && Functions_1.UsefulStuff.isEmpty(entity.TemplateID)) {
+            return { valid: false, error: "Missing Message or TemplateID" };
+        }
+        for (let i = 0; i < entity.Destinations.length; i++) {
+            const destination = entity.Destinations[i];
+            const number = destination.ToNumber ?? destination.Recipient;
+            if (!Functions_1.UsefulStuff.isEmpty(number) && !Functions_1.UsefulStuff.isMobileNumber(number)) {
+                return { valid: false, error: `Invalid ToNumber - must be mobile number - ${number}` };
+            }
+        }
+        return { valid: true };
+    }
+    createRequestDTO(entity) {
+        return new dtos_1.SMSApiRequestDTO(entity);
+    }
+}
+exports.SMSApi = SMSApi;

package/dist/Api/Messaging/TTSApi.d.ts

@@ -0,0 +1,22 @@
+import { TTSModel } from './models';
+import { MessagingApiSuccessResponseDTO, MessagingBaseRequestDTO } from './dtos';
+import { ErrorResponseDTO } from "../../Common/dtos";
+import { IHttpClient } from "../../Common/IHttpClient";
+import { ValidationResult } from "../../Common/ValidationResult";
+import { BaseMessagingApi } from './BaseMessagingApi';
+import { ITTSArgs } from './interfaces';
+export declare class TTSApi extends BaseMessagingApi<TTSModel> {
+    protected entity: TTSModel;
+    protected readonly apiEndpoint = "/tts";
+    constructor(args: {
+        URL: string;
+        AuthToken?: string;
+        httpClient?: IHttpClient;
+    });
+    SendMessage(args?: ITTSArgs): Promise<MessagingApiSuccessResponseDTO | ErrorResponseDTO>;
+    protected createEntity(): TTSModel;
+    protected singleDestinationFields(): Array<[string, string]>;
+    protected validate(entity: TTSModel): ValidationResult;
+    protected createRequestDTO(entity: TTSModel): MessagingBaseRequestDTO;
+    AddKeypad(tone: number, routeNumber: string, play?: string, playSection?: string): this;
+}

package/dist/Api/Messaging/TTSApi.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TTSApi = void 0;
+const Functions_1 = require("../../Functions");
+const models_1 = require("./models");
+const dtos_1 = require("./dtos");
+const BaseMessagingApi_1 = require("./BaseMessagingApi");
+class TTSApi extends BaseMessagingApi_1.BaseMessagingApi {
+    constructor(args) {
+        super(args.URL, args.AuthToken || "", args.httpClient);
+        this.apiEndpoint = "/tts";
+        this.entity = new models_1.TTSModel(args);
+    }
+    async SendMessage(args) {
+        return super.SendMessage(args);
+    }
+    createEntity() {
+        return new models_1.TTSModel();
+    }
+    singleDestinationFields() {
+        return [['ToNumber', 'MainPhone'], ['GroupID', 'GroupID'], ['ContactID', 'ContactID']];
+    }
+    validate(entity) {
+        const base = this.baseValidate(entity);
+        if (!base.valid)
+            return base;
+        if (Functions_1.UsefulStuff.isEmpty(entity.MessageToPeople) && Functions_1.UsefulStuff.isEmpty(entity.TemplateID)) {
+            return { valid: false, error: "Missing MessageToPeople or TemplateID" };
+        }
+        if (!Functions_1.UsefulStuff.isEmpty(entity.RetryAttempts) && !Functions_1.UsefulStuff.isNumber(entity.RetryAttempts)) {
+            return { valid: false, error: "RetryAttempts must be a number" };
+        }
+        if (!Functions_1.UsefulStuff.isEmpty(entity.RetryPeriod) && !Functions_1.UsefulStuff.isNumber(entity.RetryPeriod)) {
+            return { valid: false, error: "RetryPeriod must be a number" };
+        }
+        if (!Functions_1.UsefulStuff.isEmpty(entity.NumberOfOperators) && !Functions_1.UsefulStuff.isNumber(entity.NumberOfOperators)) {
+            return { valid: false, error: "NumberOfOperators must be a number" };
+        }
+        for (const destination of entity.Destinations) {
+            const phone = destination.MainPhone ?? destination.Recipient;
+            if (!Functions_1.UsefulStuff.isEmpty(phone) && !Functions_1.UsefulStuff.isPhoneNumber(phone)) {
+                return { valid: false, error: `Invalid Recipient - must be phone number - ${phone}` };
+            }
+        }
+        if (!Functions_1.UsefulStuff.isEmpty(entity.Keypads)) {
+            for (const keypad of entity.Keypads) {
+                if (Functions_1.UsefulStuff.isEmpty(keypad.RouteNumber) && Functions_1.UsefulStuff.isEmpty(keypad.Play) && Functions_1.UsefulStuff.isEmpty(keypad.PlaySection)) {
+                    return { valid: false, error: `Empty Keypad ${keypad.Tone} Data: Please specify RouteNumber OR Play OR PlaySection` };
+                }
+            }
+        }
+        return { valid: true };
+    }
+    createRequestDTO(entity) {
+        return new dtos_1.TTSApiRequestDTO(entity);
+    }
+    AddKeypad(tone, routeNumber, play = "", playSection = "") {
+        this.entity.Keypads.push({
+            "Tone": tone,
+            "RouteNumber": routeNumber,
+            "Play": play,
+            "PlaySection": playSection
+        });
+        return this;
+    }
+}
+exports.TTSApi = TTSApi;

package/dist/Api/Messaging/VoiceApi.d.ts

@@ -0,0 +1,24 @@
+import { VoiceModel } from './models';
+import { MessagingApiSuccessResponseDTO, MessagingBaseRequestDTO } from './dtos';
+import { ErrorResponseDTO } from "../../Common/dtos";
+import { IHttpClient } from "../../Common/IHttpClient";
+import { ValidationResult } from "../../Common/ValidationResult";
+import { BaseMessagingApi } from './BaseMessagingApi';
+import { IVoiceArgs } from './interfaces';
+export declare class VoiceApi extends BaseMessagingApi<VoiceModel> {
+    protected entity: VoiceModel;
+    protected readonly apiEndpoint = "/voice";
+    constructor(args: {
+        URL: string;
+        AuthToken?: string;
+        httpClient?: IHttpClient;
+    });
+    SendMessage(args?: IVoiceArgs): Promise<MessagingApiSuccessResponseDTO | ErrorResponseDTO>;
+    protected createEntity(): VoiceModel;
+    protected singleDestinationFields(): Array<[string, string]>;
+    protected validate(entity: VoiceModel): ValidationResult;
+    protected processAttachments(entity: VoiceModel): Promise<void>;
+    protected createRequestDTO(entity: VoiceModel): MessagingBaseRequestDTO;
+    AddVoiceFile(field: string, file: string): this;
+    AddKeypad(tone: number, routeNumber: string, play_file?: string, playSection?: string): this;
+}