@aptana/multichannel-common 2.9.12

package/core/modules/health/useCases/healthIndicator/message-broker/rabbitmqHealthIndicator.js

@@ -0,0 +1,66 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitmqHealthIndicator = void 0;
+const HealthIndicator_1 = require("../HealthIndicator");
+const ConnectionNotFoundError_1 = require("../../../errors/ConnectionNotFoundError");
+const TimeoutError_1 = require("../../../errors/TimeoutError");
+const HealthCheckError_1 = require("../../../errors/HealthCheckError");
+const promise_1 = require("../../../utils/promise");
+const Connection_1 = require("../../../../../../core/infrastructure/events/Connection");
+const Container_1 = require("../../../../../../core/infrastructure/Container");
+let RabbitmqHealthIndicator = class RabbitmqHealthIndicator extends HealthIndicator_1.HealthIndicator {
+    /**
+     * Checks if the RabbitMQ responds in (default) 1000ms and
+     * returns a result object corresponding to the result
+     *
+     * @example
+     * rabbitmqHealthIndicator.pingCheck('rabbitmq', { timeout: 1000 });
+     */
+    async pingCheck(key, options) {
+        let isHealthy = false;
+        const connection = options?.connection || this.getContextConnection();
+        const timeout = options?.timeout || 1000;
+        if (!connection) {
+            throw new ConnectionNotFoundError_1.ConnectionNotFoundError();
+        }
+        try {
+            await this.pingMQ(connection, timeout);
+            isHealthy = true;
+        }
+        catch (err) {
+            if (err instanceof TimeoutError_1.TimeoutError) {
+                throw new TimeoutError_1.TimeoutError(timeout);
+            }
+        }
+        if (isHealthy) {
+            return this.getStatus(key, isHealthy);
+        }
+        else {
+            throw this.getStatus(key, isHealthy, {
+                error: new HealthCheckError_1.HealthCheckError(`${key} is not available`).message
+            });
+        }
+    }
+    async pingMQ(connection, timeout) {
+        const promise = connection.isConnected() ? Promise.resolve() : Promise.reject();
+        return await (0, promise_1.promiseTimeout)(timeout, promise);
+    }
+    getContextConnection() {
+        try {
+            return Connection_1.Connection.getConnection();
+        }
+        catch (error) {
+            return null;
+        }
+    }
+};
+RabbitmqHealthIndicator = __decorate([
+    (0, Container_1.Service)()
+], RabbitmqHealthIndicator);
+exports.RabbitmqHealthIndicator = RabbitmqHealthIndicator;

package/core/modules/health/utils/promise.d.ts

@@ -0,0 +1 @@
+export declare const promiseTimeout: (ms: number, promise: Promise<any>) => Promise<any>;

package/core/modules/health/utils/promise.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseTimeout = void 0;
+const TimeoutError_1 = require("../errors/TimeoutError");
+const promiseTimeout = function (ms, promise) {
+    let timer;
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => (timer = setTimeout(() => reject(new TimeoutError_1.TimeoutError(ms)), ms))),
+    ]).finally(() => clearTimeout(timer));
+};
+exports.promiseTimeout = promiseTimeout;

package/core/modules/service/useCases/detail/DetailController.d.ts

@@ -0,0 +1,6 @@
+import { Request, Response } from 'express';
+import { Controller } from '../../../../../core/infrastructure/Controller';
+export default class DetailController extends Controller {
+    registerRoutes(): void;
+    show(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+}

package/core/modules/service/useCases/detail/DetailController.js

@@ -0,0 +1,25 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Container_1 = require("../../../../../core/infrastructure/Container");
+const Controller_1 = require("../../../../../core/infrastructure/Controller");
+let DetailController = class DetailController extends Controller_1.Controller {
+    registerRoutes() {
+        this.router.get('/', this.show.bind(this));
+    }
+    async show(req, res) {
+        return this.ok(res, {
+            name: process.env.npm_package_name,
+            version: process.env.npm_package_version
+        });
+    }
+};
+DetailController = __decorate([
+    (0, Container_1.Service)()
+], DetailController);
+exports.default = DetailController;

package/core/utils/Crypto.d.ts

@@ -0,0 +1,24 @@
+export declare enum CryptoAlgorithm {
+    AES256CTR = "aes-256-ctr",
+    AES256GCM = "aes-256-gcm",
+    AES256ECB = "aes-256-ecb"
+}
+export declare class Crypto {
+    static secretKey: string;
+    /**
+     * Make a encrypted text using key process.env.SECRET_KEY with the spesific algorithm.
+     * Please see CryptoAlgorithm enum for supported algorithm
+     * @param plain string
+     * @param algorithm CryptoAlgorithm
+     * @returns string
+     */
+    static encrypt: (plain: string, algorithm?: string) => string;
+    /**
+     * Decrypt the chipper message using key process.env.SECRET_KEY with the spesific algorithm.
+     * Please see CryptoAlgorithm enum for supported algorithm
+     * @param cryptedMessage string
+     * @param algorithm CryptoAlgorithm
+     * @returns string
+     */
+    static decrypt: (cryptedMessage: string, algorithm?: string) => string;
+}

package/core/utils/Crypto.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Crypto = exports.CryptoAlgorithm = void 0;
+const crypto_1 = require("crypto");
+var CryptoAlgorithm;
+(function (CryptoAlgorithm) {
+    CryptoAlgorithm["AES256CTR"] = "aes-256-ctr";
+    CryptoAlgorithm["AES256GCM"] = "aes-256-gcm";
+    CryptoAlgorithm["AES256ECB"] = "aes-256-ecb";
+})(CryptoAlgorithm = exports.CryptoAlgorithm || (exports.CryptoAlgorithm = {}));
+var CryptoError;
+(function (CryptoError) {
+    CryptoError["UNKNOWN_ALGORITHM"] = "Unknown algorithm.";
+    CryptoError["INVALID_ENCRYPTED_FORMAT"] = "Invalid encrypted data format.";
+})(CryptoError || (CryptoError = {}));
+class Crypto {
+    static secretKey = process.env.SECRET_KEY ?? "this-is-secret-key";
+    /**
+     * Make a encrypted text using key process.env.SECRET_KEY with the spesific algorithm.
+     * Please see CryptoAlgorithm enum for supported algorithm
+     * @param plain string
+     * @param algorithm CryptoAlgorithm
+     * @returns string
+     */
+    static encrypt = (plain, algorithm = CryptoAlgorithm.AES256CTR) => {
+        if (algorithm == CryptoAlgorithm.AES256CTR) {
+            const key = (0, crypto_1.createHash)("sha256").update(Crypto.secretKey).digest();
+            const nonce = (0, crypto_1.randomBytes)(16);
+            const cipher = (0, crypto_1.createCipheriv)("aes-256-ctr", key, nonce);
+            let encrypted = cipher.update(plain, "utf8", "hex");
+            encrypted += cipher.final("hex");
+            return nonce.toString("hex") + ":" + encrypted;
+        }
+        if (algorithm == CryptoAlgorithm.AES256GCM) {
+            const keyBuffer = (0, crypto_1.createHash)("sha256").update(this.secretKey).digest();
+            const iv = (0, crypto_1.randomBytes)(12); // 96-bit IV for AES-GCM
+            const cipher = (0, crypto_1.createCipheriv)("aes-256-gcm", keyBuffer, iv);
+            let encrypted = cipher.update(plain, "utf8", "hex");
+            encrypted += cipher.final("hex");
+            const tag = cipher.getAuthTag();
+            return `${iv.toString("hex")}-${tag.toString("hex")}-${encrypted}`;
+        }
+        if (algorithm == CryptoAlgorithm.AES256ECB) {
+            const key = (0, crypto_1.createHash)("sha256").update(Crypto.secretKey).digest();
+            const cipher = (0, crypto_1.createCipheriv)("aes-256-ecb", key, null);
+            let encrypted = cipher.update(plain, "utf8", "hex");
+            encrypted += cipher.final("hex");
+            return encrypted;
+        }
+        throw new Error(CryptoError.UNKNOWN_ALGORITHM);
+    };
+    /**
+     * Decrypt the chipper message using key process.env.SECRET_KEY with the spesific algorithm.
+     * Please see CryptoAlgorithm enum for supported algorithm
+     * @param cryptedMessage string
+     * @param algorithm CryptoAlgorithm
+     * @returns string
+     */
+    static decrypt = (cryptedMessage, algorithm = CryptoAlgorithm.AES256CTR) => {
+        if (algorithm == CryptoAlgorithm.AES256CTR) {
+            const parts = cryptedMessage.split(":");
+            if (parts.length !== 2)
+                throw new Error(CryptoError.INVALID_ENCRYPTED_FORMAT);
+            const nonce = Buffer.from(parts[0], "hex");
+            const content = parts[1];
+            const key = (0, crypto_1.createHash)("sha256").update(Crypto.secretKey).digest();
+            const decipher = (0, crypto_1.createDecipheriv)("aes-256-ctr", key, nonce);
+            let decrypted = decipher.update(content, "hex", "utf8");
+            decrypted += decipher.final("utf8");
+            return decrypted;
+        }
+        if (algorithm == CryptoAlgorithm.AES256GCM) {
+            const keyBuffer = (0, crypto_1.createHash)("sha256").update(this.secretKey).digest();
+            const parts = cryptedMessage.split("-");
+            if (parts.length !== 3)
+                throw new Error(CryptoError.INVALID_ENCRYPTED_FORMAT);
+            const decipher = (0, crypto_1.createDecipheriv)("aes-256-gcm", keyBuffer, Buffer.from(parts[0], "hex"));
+            decipher.setAuthTag(Buffer.from(parts[1], "hex"));
+            let decrypted = decipher.update(parts[2], "hex", "utf8");
+            decrypted += decipher.final("utf8");
+            return decrypted;
+        }
+        if (algorithm == CryptoAlgorithm.AES256ECB) {
+            const key = (0, crypto_1.createHash)("sha256").update(Crypto.secretKey).digest();
+            const decipher = (0, crypto_1.createDecipheriv)("aes-256-ecb", key, null);
+            let decrypted = decipher.update(cryptedMessage, "hex", "utf8");
+            decrypted += decipher.final("utf8");
+            return decrypted;
+        }
+        throw new Error(CryptoError.UNKNOWN_ALGORITHM);
+    };
+}
+exports.Crypto = Crypto;

package/core/utils/Hash.d.ts

@@ -0,0 +1,6 @@
+export declare class Hash {
+    static make: (text: string) => string;
+    static compare: (text: string, hash: string) => boolean;
+    static sha256: (text: string) => string;
+    private static encrypt;
+}

package/core/utils/Hash.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hash = void 0;
+const crypto_1 = require("crypto");
+class Hash {
+    static make = (text) => {
+        const salt = (0, crypto_1.randomBytes)(16).toString('hex');
+        return Hash.encrypt(text, salt) + salt;
+    };
+    static compare = (text, hash) => {
+        const salt = hash.slice(64);
+        const originalTextHash = hash.slice(0, 64);
+        const currentTextHash = Hash.encrypt(text, salt);
+        return originalTextHash === currentTextHash;
+    };
+    static sha256 = (text) => {
+        return (0, crypto_1.createHash)('sha256').update(text).digest('hex');
+    };
+    static encrypt = (text, salt) => {
+        return (0, crypto_1.scryptSync)(text, salt, 32).toString('hex');
+    };
+}
+exports.Hash = Hash;

package/core/utils/cache.d.ts

@@ -0,0 +1 @@
+export declare function cache<T>(key: string, callback: Function, ttl?: number): Promise<any>;

package/core/utils/cache.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cache = void 0;
+const Container_1 = require("../../core/infrastructure/Container");
+async function cache(key, callback, ttl = 30) {
+    const cache = Container_1.Container.get('cacheService');
+    const value = await cache.get(key);
+    if (value) {
+        return value;
+    }
+    return callback().then(async (data) => {
+        await cache.set(key, data, ttl);
+        return data;
+    });
+}
+exports.cache = cache;

package/core/utils/commands.d.ts

@@ -0,0 +1,2 @@
+import { Command } from '../../core/domain/Command';
+export declare function executor(command: Command): Promise<any>;

package/core/utils/commands.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executor = void 0;
+async function executor(command) {
+    return await command.execute();
+}
+exports.executor = executor;

package/core/utils/events.d.ts

@@ -0,0 +1,3 @@
+import { Event, EventOptions } from "../../core/domain/events/Event";
+export declare function dispatcher(publisher: Event, options?: EventOptions): Promise<any>;
+export declare function dispatcherWithoutPersistence(publisher: Event, options?: EventOptions): Promise<any>;

package/core/utils/events.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatcherWithoutPersistence = exports.dispatcher = void 0;
+async function dispatcher(publisher, options) {
+    return await publisher.init().publish(options);
+}
+exports.dispatcher = dispatcher;
+async function dispatcherWithoutPersistence(publisher, options) {
+    return await publisher.init().publishWithoutPersistence(options);
+}
+exports.dispatcherWithoutPersistence = dispatcherWithoutPersistence;

package/core/utils/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("winston").Logger;
+export default logger;

package/core/utils/logger.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const winston_1 = require("winston");
+exports.logger = (0, winston_1.createLogger)({
+    level: process.env.LOG_LEVEL,
+    format: winston_1.format.combine(winston_1.format.splat(), winston_1.format.json()),
+    transports: [
+        new winston_1.transports.Console()
+    ],
+    exceptionHandlers: [
+        new winston_1.transports.Console()
+    ]
+});
+exports.default = exports.logger;

package/core/utils/response.d.ts

@@ -0,0 +1,4 @@
+import { Response } from 'express';
+import { ErrorMessage } from '../../core/errors/AppError';
+export declare function sendSuccessResponse(res: Response, data: any, status?: number): Response<any, Record<string, any>>;
+export declare function sendErrorResponse(res: Response, error: ErrorMessage[], status?: number): Response<any, Record<string, any>>;

package/core/utils/response.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendErrorResponse = exports.sendSuccessResponse = void 0;
+function sendSuccessResponse(res, data, status = 200) {
+    return res.status(status).json({ status, data });
+}
+exports.sendSuccessResponse = sendSuccessResponse;
+function sendErrorResponse(res, error, status = 500) {
+    return res.status(status).json({ status, error });
+}
+exports.sendErrorResponse = sendErrorResponse;

package/core/utils/validator.d.ts

@@ -0,0 +1,4 @@
+import { ValidatorOptions } from 'class-validator';
+export type Klass<T> = new (...args: any[]) => T;
+export declare function transformAndValidate<T extends object>(klass: Klass<T>, object: object, options?: ValidatorOptions): T;
+export default transformAndValidate;

package/core/utils/validator.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformAndValidate = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const RequestValidationError_1 = require("../../core/errors/RequestValidationError");
+function transformAndValidate(klass, object, options) {
+    object = normalizeObject(object);
+    const classObject = (0, class_transformer_1.plainToClass)(klass, object, { enableImplicitConversion: false });
+    const errors = (0, class_validator_1.validateSync)(classObject, options ? options : void 0);
+    if (errors.length) {
+        throw new RequestValidationError_1.RequestValidationError(errors);
+    }
+    return classObject;
+}
+exports.transformAndValidate = transformAndValidate;
+function normalizeObject(object) {
+    let normalObject = {};
+    for (let key in object) {
+        const newKey = key.replace(/\[(.*?)\]/, '$1');
+        if (typeof object[key] !== 'object') {
+            normalObject[newKey] = object[key];
+        }
+        else if (Array.isArray(object[key])) {
+            normalObject[newKey] = normilizeArray(object[key]);
+        }
+        else if (object.hasOwnProperty(key)) {
+            normalObject[newKey] = normalizeObject(object[key]);
+        }
+    }
+    return normalObject;
+}
+function normilizeArray(array) {
+    let normalArray = [];
+    normalArray = array.map((item) => {
+        if (typeof item !== 'object') {
+            return item;
+        }
+        else if (Array.isArray(item)) {
+            return normilizeArray(item);
+        }
+        else {
+            return normalizeObject(item);
+        }
+    });
+    return normalArray;
+}
+exports.default = transformAndValidate;

package/domain/BalanceMutation.d.ts

@@ -0,0 +1,18 @@
+export declare enum BalanceMutationType {
+    Credit = "credit",
+    Debit = "debit"
+}
+export interface BalanceMutation {
+    accountId: string;
+    account?: any;
+    creatorId?: string;
+    creatorName?: string;
+    amount: number;
+    resource: string;
+    resourceName: string;
+    type: BalanceMutationType;
+    notes: string;
+    before?: number;
+    after?: number;
+}
+export default BalanceMutation;

package/domain/BalanceMutation.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BalanceMutationType = void 0;
+var BalanceMutationType;
+(function (BalanceMutationType) {
+    BalanceMutationType["Credit"] = "credit";
+    BalanceMutationType["Debit"] = "debit";
+})(BalanceMutationType = exports.BalanceMutationType || (exports.BalanceMutationType = {}));

package/domain/ChannelWhatsapp.d.ts

@@ -0,0 +1,18 @@
+export interface ProviderConfig {
+    accessToken?: string;
+    client?: string;
+    expiry?: string;
+    uid?: string;
+    wabaId?: string;
+    version?: string;
+    phoneNumberId?: string;
+}
+export interface ChannelWhatsapp {
+    _id?: string;
+    accountId: string;
+    account?: any;
+    phone: string;
+    provider?: string;
+    providerConfig?: ProviderConfig;
+}
+export default ChannelWhatsapp;

package/domain/ChannelWhatsapp.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/domain/MessageTemplate.d.ts

@@ -0,0 +1,26 @@
+export declare enum MessageTemplateStatus {
+    Draft = "draft",
+    Scheduled = "scheduled",
+    Published = "published",
+    Approved = "approved",
+    Declined = "declined",
+    Failed = "failed"
+}
+export interface MessageTemplate {
+    _id?: string;
+    name: string;
+    payload: any;
+    status: MessageTemplateStatus;
+    createdAt: any;
+    updatedAt: any;
+    senderId?: any;
+    sender?: any;
+    sourceId?: string;
+    sourceStatus?: string;
+    sourceReason?: string;
+    accountId: any;
+    account?: any;
+    notes?: any;
+    sentAt?: Date;
+}
+export default MessageTemplate;

package/domain/MessageTemplate.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageTemplateStatus = void 0;
+var MessageTemplateStatus;
+(function (MessageTemplateStatus) {
+    MessageTemplateStatus["Draft"] = "draft";
+    MessageTemplateStatus["Scheduled"] = "scheduled";
+    MessageTemplateStatus["Published"] = "published";
+    MessageTemplateStatus["Approved"] = "approved";
+    MessageTemplateStatus["Declined"] = "declined";
+    MessageTemplateStatus["Failed"] = "failed";
+})(MessageTemplateStatus = exports.MessageTemplateStatus || (exports.MessageTemplateStatus = {}));

package/domain/MessageTemplateCategoryUpdate.d.ts

@@ -0,0 +1,8 @@
+export interface MessageTemplateCategoryUpdate {
+    sourceId: string;
+    sourceName: string;
+    sourceLanguage: string;
+    category: string;
+    categoryOld: string;
+}
+export default MessageTemplateCategoryUpdate;

package/domain/MessageTemplateCategoryUpdate.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/domain/MessageTemplateStatusUpdate.d.ts

@@ -0,0 +1,8 @@
+export interface MessageTemplateStatusUpdate {
+    sourceId: string;
+    sourceStatus?: string;
+    sourceReason?: string;
+    status: string;
+    notes?: string;
+}
+export default MessageTemplateStatusUpdate;

package/domain/MessageTemplateStatusUpdate.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/domain/Payment.d.ts

@@ -0,0 +1,14 @@
+export declare enum PaymentType {
+    Credit = "credit",
+    Debit = "debit"
+}
+export interface Payment {
+    accountId: string;
+    account?: any;
+    amount: number;
+    resource?: string;
+    resourceName?: string;
+    type: PaymentType;
+    notes: string;
+}
+export default Payment;

package/domain/Payment.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentType = void 0;
+var PaymentType;
+(function (PaymentType) {
+    PaymentType["Credit"] = "credit";
+    PaymentType["Debit"] = "debit";
+})(PaymentType = exports.PaymentType || (exports.PaymentType = {}));

package/domain/Report.d.ts

@@ -0,0 +1,33 @@
+export interface Report {
+    accountId: string;
+    params: ReportParams;
+    status: string;
+    file?: string;
+}
+export interface ReportParams {
+    transactionDate?: ParamsDate;
+    createdDate?: ParamsDate;
+    sentDate?: ParamsDate;
+    deliveryReportDate?: ParamsDate;
+    area?: string;
+    customerId?: string;
+    senderId?: string;
+    creatorId?: string;
+    senderName?: string;
+    vendor?: string;
+    operator?: string;
+    productName?: string;
+    category?: string;
+    status?: string;
+    type?: string;
+}
+export declare class ParamsDate {
+    dateSince: Date;
+    dateUntil: Date;
+}
+export declare enum ReportStatus {
+    Created = "created",
+    Completed = "completed",
+    Empty = "empty",
+    Failed = "failed"
+}

package/domain/Report.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportStatus = exports.ParamsDate = void 0;
+class ParamsDate {
+    dateSince;
+    dateUntil;
+}
+exports.ParamsDate = ParamsDate;
+var ReportStatus;
+(function (ReportStatus) {
+    ReportStatus["Created"] = "created";
+    ReportStatus["Completed"] = "completed";
+    ReportStatus["Empty"] = "empty";
+    ReportStatus["Failed"] = "failed";
+})(ReportStatus = exports.ReportStatus || (exports.ReportStatus = {}));

package/domain/TransactionMessaging.d.ts

@@ -0,0 +1,33 @@
+export declare enum TransactionMessagingStatus {
+    Created = "created",
+    Paid = "paid",
+    Published = "published",
+    Succeeded = "succeeded",
+    Failed = "failed"
+}
+export interface TransactionMessaging {
+    _id?: string;
+    accountId: any;
+    account?: any;
+    campaignId: any;
+    campaign?: any;
+    sku: string;
+    amount: number;
+    msisdn: any;
+    status: TransactionMessagingStatus;
+    schedule: boolean;
+    scheduleAt?: Date;
+    scheduleZone?: string;
+    notes?: any;
+    productId?: string;
+    product?: any;
+    content?: any;
+    payment?: any;
+    senderId?: string;
+    sender?: any;
+    sourceId?: string;
+    sourceStatus?: string;
+    sourceReason?: string;
+    sentAt?: Date;
+}
+export default TransactionMessaging;