@xrystal/core 3.2.3

package/source/loader/logger/index.js

@@ -0,0 +1,130 @@
+import winston, { format } from 'winston';
+import 'winston-daily-rotate-file';
+import path from 'path';
+import { Kafka, Partitioners } from 'kafkajs';
+import { LoggerLayerEnum } from '../../utils';
+const customLevels = {
+    critical: LoggerLayerEnum.CRITICAL, // 0
+    error: LoggerLayerEnum.ERROR, // 1
+    info: LoggerLayerEnum.INFO, // 2
+    debug: LoggerLayerEnum.DEBUG // 3
+};
+const customColors = {
+    critical: 'red',
+    error: 'magenta',
+    warn: 'yellow',
+    info: 'green',
+    http: 'cyan',
+    debug: 'blue'
+};
+export default class LoggerService {
+    serviceName = "";
+    environment = "";
+    kafkaProducer = null;
+    kafkaTopic = "";
+    isKafkaReady = false;
+    getConsoleFormat() {
+        return format.combine(format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), format.colorize({ all: true }), format.printf((info) => {
+            const msg = typeof info.message === 'object' ? JSON.stringify(info.message) : info.message;
+            return `${info.timestamp} [${this.serviceName}] ${info.level}: ${msg}`;
+        }));
+    }
+    winston = winston.createLogger({
+        level: 'debug',
+        levels: customLevels,
+        transports: [
+            new winston.transports.Console({
+                format: this.getConsoleFormat()
+            })
+        ]
+    });
+    constructor() {
+        winston.addColors(customColors);
+    }
+    load = async (config) => {
+        this.serviceName = config.serviceName;
+        this.environment = config.env;
+        this.kafkaTopic = config.kafkaTopic;
+        this.winstonLoader({
+            loadPath: config.loadPath,
+            loggerLevel: config.loggerLevel
+        });
+        const brokers = config.kafkaBrokers ? config.kafkaBrokers.split(',').map((b) => b.trim()) : [];
+        if (brokers.length > 0) {
+            try {
+                const kafka = new Kafka({
+                    clientId: config.serviceName,
+                    brokers: brokers,
+                    retry: {
+                        initialRetryTime: 100,
+                        retries: 3
+                    }
+                });
+                this.kafkaProducer = kafka.producer({ createPartitioner: Partitioners.LegacyPartitioner });
+                await this.kafkaProducer.connect();
+                this.isKafkaReady = true;
+                this.winston.info('Logger connected to Kafka successfully');
+            }
+            catch (err) {
+                console.error(`[LoggerService] Kafka connection failed: ${err.message}. Logging will continue only to files/console.`);
+                this.isKafkaReady = false;
+                this.kafkaProducer = null;
+            }
+        }
+    };
+    winstonLoader = ({ loadPath, loggerLevel }) => {
+        const { combine, timestamp, json, errors } = format;
+        const jsonFileFormat = combine(timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), errors({ stack: true }), json());
+        const winstonLogger = winston.createLogger({
+            level: loggerLevel,
+            levels: customLevels,
+            transports: [
+                new winston.transports.Console({
+                    format: this.getConsoleFormat()
+                }),
+                new winston.transports.DailyRotateFile({
+                    filename: path.resolve(loadPath, 'error', '%DATE%_error.log'),
+                    level: 'error',
+                    format: jsonFileFormat,
+                    maxSize: '2mb',
+                    maxFiles: '7d'
+                }),
+                new winston.transports.DailyRotateFile({
+                    filename: path.resolve(loadPath, 'critical', '%DATE%_critical.log'),
+                    level: 'critical',
+                    format: jsonFileFormat,
+                    maxSize: '2mb',
+                    maxFiles: '14d'
+                })
+            ]
+        });
+        winstonLogger.on('data', (info) => {
+            if (this.isKafkaReady) {
+                this.logToKafka(info);
+            }
+        });
+        this.winston = winstonLogger;
+        return winstonLogger;
+    };
+    async logToKafka(info) {
+        if (!this.kafkaProducer || !this.isKafkaReady)
+            return;
+        try {
+            await this.kafkaProducer.send({
+                topic: this.kafkaTopic,
+                messages: [{
+                        value: JSON.stringify({
+                            ...info,
+                            service: this.serviceName,
+                            env: this.environment,
+                            timestamp: new Date().toISOString()
+                        })
+                    }]
+            });
+        }
+        catch (err) {
+            this.isKafkaReady = false;
+            console.error('Kafka send error, disabling Kafka logging temporarily:', err);
+        }
+    }
+}

package/source/loader/system/index.d.ts

@@ -0,0 +1,8 @@
+export default class SystemService {
+    private static _tmp;
+    load: ({ tmp, }: {
+        tmp: any;
+    }) => Promise<void>;
+    private _systemLoader;
+    static get tmp(): any;
+}

package/source/loader/system/index.js

@@ -0,0 +1,14 @@
+export default class SystemService {
+    static _tmp;
+    load = async ({ tmp, }) => {
+        SystemService._tmp = tmp;
+        await this._systemLoader({});
+    };
+    _systemLoader = async ({}) => {
+        //console.log(this._tmp)
+    };
+    // => getters
+    static get tmp() {
+        return SystemService._tmp;
+    }
+}

package/source/project/index.d.ts

@@ -0,0 +1,7 @@
+import webpack from 'webpack';
+import * as webpackMerge from 'webpack-merge';
+import nodeExternals from 'webpack-node-externals';
+import MiniCssExtractPlugin from 'mini-css-extract-plugin';
+declare const coreLoader: any;
+export { webpack, webpackMerge, nodeExternals, MiniCssExtractPlugin };
+export default coreLoader;

package/source/project/index.js

@@ -0,0 +1,94 @@
+// => import dependencies
+import path from 'path';
+import webpack from 'webpack';
+import * as webpackMerge from 'webpack-merge';
+import nodeExternals from 'webpack-node-externals';
+import MiniCssExtractPlugin from 'mini-css-extract-plugin';
+import { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService } from '../loader/index';
+import { packageName, tmpFileDefaultName, tmpFileDefaultExt, findFileRecursively, TmpFileLoader, x, kafkaBrokers, systemLoggerLayer, } from '../utils/index';
+//
+let coreHasRun = false;
+const coreLoader = async () => {
+    let response = {};
+    let r = {};
+    let rootFolderPath = '';
+    let ownerTmpFilePath = null;
+    let resolvedTmpFileJson = null;
+    if (coreHasRun) {
+        return response;
+    }
+    try {
+        ownerTmpFilePath = findFileRecursively('.', tmpFileDefaultName, tmpFileDefaultExt);
+        if (!ownerTmpFilePath) {
+            console.error(`${tmpFileDefaultName} file not found.`);
+        }
+        const tmpFileObject = new TmpFileLoader({
+            filePath: ownerTmpFilePath
+        });
+        resolvedTmpFileJson = tmpFileObject.getResolvedTmpFile();
+        r = resolvedTmpFileJson;
+        response = {
+            _: r
+        };
+        rootFolderPath = resolvedTmpFileJson.configs.rootFolderPath;
+        // => LOADER
+        const serviceName = r.configs.service;
+        const nodeEnv = process.env.NODE_ENV;
+        try {
+            x.set({
+                service: SystemService,
+                reference: SystemService
+            });
+            x.set({
+                service: ConfigsService,
+                reference: ConfigsService
+            });
+            x.set({
+                service: LoggerService,
+                reference: LoggerService
+            });
+            x.set({
+                service: EventsService,
+                reference: EventsService
+            });
+            x.set({
+                service: LocalizationsService,
+                reference: LocalizationsService
+            });
+            await x.get(SystemService).load({
+                tmp: response
+            });
+            await x.get(ConfigsService).load({
+                tmpFolderPath: rootFolderPath,
+                systemService: x.get(SystemService),
+                envLoadPath: `${rootFolderPath}/${r.configs.loaders.configs.envLoadPath}`,
+                ...(r.configs.loaders.configs.globalEnvFileName ? { globalEnvFileName: r.configs.loaders.configs.globalEnvFileName } : null)
+            });
+            await x.get(LoggerService).load({
+                loadPath: `${rootFolderPath}/${r.configs.loaders.loggers.loadPath}`,
+                loggerLevel: systemLoggerLayer || r.configs.loaders.loggers.logLevel,
+                serviceName,
+                env: nodeEnv,
+                kafkaBrokers: kafkaBrokers || '',
+                kafkaTopic: r.configs.loaders.loggers.topic
+            });
+            await x.get(EventsService).load({});
+            await x.get(LocalizationsService).load({
+                loadPath: path.resolve(`${rootFolderPath}/${r.configs.loaders.localization.loadPath}`),
+                fallbackLang: r.configs.loaders.localization.fallbackLang,
+                preloadLang: r.configs.loaders.localization.preloadLangs,
+            });
+        }
+        catch (error) {
+            console.log(`x:${error}`);
+        }
+        //
+        coreHasRun = true;
+        return response;
+    }
+    catch (error) {
+        console.error(`${packageName} x:`, error?.message);
+    }
+};
+export { webpack, webpackMerge, nodeExternals, MiniCssExtractPlugin };
+export default coreLoader;

package/source/utils/constants/index.d.ts

@@ -0,0 +1,8 @@
+export declare const packageName: string;
+export declare const tmpFileDefaultMainFolderName: string;
+export declare const tmpFileDefaultName: string;
+export declare const tmpFileDefaultExt = ".yml";
+export declare const defaultTmpFilePath: string;
+export declare const defaultOwnerTmpFilePath: string;
+export declare const systemLoggerLayer: string;
+export declare const kafkaBrokers: string;

package/source/utils/constants/index.js

@@ -0,0 +1,10 @@
+import path from 'path';
+import { __dirname } from '../helpers/path';
+export const packageName = 'tmp-project-tool';
+export const tmpFileDefaultMainFolderName = 'x';
+export const tmpFileDefaultName = 'tmp';
+export const tmpFileDefaultExt = '.yml';
+export const defaultTmpFilePath = path.resolve(__dirname(import.meta.url), `../../${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`);
+export const defaultOwnerTmpFilePath = path.resolve(`./${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`);
+export const systemLoggerLayer = process.env.SYSTEM_LOGGER_LAYER;
+export const kafkaBrokers = process.env.KAFKA_BROKERS;

package/source/utils/helpers/date/index.d.ts

@@ -0,0 +1,16 @@
+import { PolarityTypeEnum } from "../../models";
+export declare function dateZoneConverter({ polarity, date, zone, factor }: {
+    polarity: PolarityTypeEnum;
+    date: Date;
+    zone: number;
+    factor?: number;
+}): string;
+export declare function convertDate(date: string, splitCharacter?: string, replaceCharacter?: string): string[];
+export declare function convertTime(time: string, splitCharacter?: string, replaceCharacter?: string): string[];
+export declare function getDateAndTime({ getDate, getTime, dateCharacter, timeCharacter, separatorCharacter }: {
+    getDate: boolean;
+    getTime: boolean;
+    dateCharacter: string;
+    timeCharacter: string;
+    separatorCharacter: string;
+}): string;

package/source/utils/helpers/date/index.js

@@ -0,0 +1,48 @@
+import { PolarityTypeEnum } from "../../models";
+export function dateZoneConverter({ polarity, date, zone, factor = 1000 }) {
+    let convertedZoneTime = null;
+    if (polarity === PolarityTypeEnum.NEGATIVE) {
+        convertedZoneTime = date.getTime() - factor * zone;
+    }
+    else {
+        convertedZoneTime = date.getTime() + factor * zone;
+    }
+    return new Date(convertedZoneTime).toISOString();
+}
+export function convertDate(date, splitCharacter = '/', replaceCharacter = '-') {
+    const convertDate = date.split(splitCharacter).map((value, index) => index !== 2 ? replaceCharacter : value);
+    return convertDate;
+}
+export function convertTime(time, splitCharacter = ':', replaceCharacter = '-') {
+    const convertDate = time.split(splitCharacter).map((value, index) => index !== 2 ? replaceCharacter : value);
+    return convertDate;
+}
+export function getDateAndTime({ getDate = true, getTime = true, dateCharacter = '-', timeCharacter = ':', separatorCharacter = '&' }) {
+    const date = new Date();
+    let formattedDate = '';
+    if (!getDate && !getTime) {
+        throw new Error("Invalid options! Required one true value");
+    }
+    if (getDate) {
+        const day = date.getDate().toString().padStart(2, '0');
+        const month = (date.getMonth() + 1).toString().padStart(2, '0');
+        const year = date.getFullYear();
+        formattedDate = `${year}${dateCharacter}${month}${dateCharacter}${day}`;
+    }
+    if (getTime) {
+        const hours = date.getHours().toString().padStart(2, '0');
+        const minutes = date.getMinutes().toString().padStart(2, '0');
+        const seconds = date.getSeconds().toString().padStart(2, '0');
+        formattedDate = `${hours}${timeCharacter}${minutes}${timeCharacter}${seconds}`;
+    }
+    if (getDate && getTime) {
+        const day = date.getDate().toString().padStart(2, '0');
+        const month = (date.getMonth() + 1).toString().padStart(2, '0');
+        const year = date.getFullYear();
+        const hours = date.getHours().toString().padStart(2, '0');
+        const minutes = date.getMinutes().toString().padStart(2, '0');
+        const seconds = date.getSeconds().toString().padStart(2, '0');
+        formattedDate = `${year}${dateCharacter}${month}${dateCharacter}${day}${separatorCharacter}${hours}${timeCharacter}${minutes}${timeCharacter}${seconds}`;
+    }
+    return formattedDate;
+}

package/source/utils/helpers/filters/index.d.ts

@@ -0,0 +1,17 @@
+declare function mongoFilter(start: any, end: any, objPath: string): any;
+declare function filterUniqueOnce<T extends Record<string, any>>({ arr, key, uniqueOnceValues }: {
+    arr: T[];
+    key: keyof T;
+    uniqueOnceValues: (T[keyof T])[];
+}): T[];
+declare function filterSortByPropOrder<T extends Record<string, any>>({ arr, key, desiredOrder }: {
+    arr: T[];
+    key: keyof T;
+    desiredOrder: T[keyof T][];
+}): T[];
+declare function filterRemoveItemsByProps<T extends Record<string, any>>({ arr, key, valuesToRemove }: {
+    arr: T[];
+    key: keyof T;
+    valuesToRemove: (T[keyof T])[];
+}): T[];
+export { mongoFilter, filterUniqueOnce, filterSortByPropOrder, filterRemoveItemsByProps };

package/source/utils/helpers/filters/index.js

@@ -0,0 +1,44 @@
+function mongoFilter(start, end, objPath) {
+    const filter = {};
+    if (!objPath) {
+        throw new Error('MongoFilter helper property is required.');
+    }
+    filter[objPath] = filter[objPath] || {};
+    if (start && end) {
+        filter[objPath].$gte = start;
+        filter[objPath].$lte = end;
+    }
+    else if (start) {
+        filter[objPath].$gte = start;
+    }
+    else if (end) {
+        filter[objPath].$lte = end;
+    }
+    return filter;
+}
+function filterUniqueOnce({ arr, key, uniqueOnceValues }) {
+    const seen = new Set();
+    return arr.filter(item => {
+        const val = item[key];
+        if (uniqueOnceValues.includes(val)) {
+            if (seen.has(val))
+                return false;
+            seen.add(val);
+            return true;
+        }
+        return true;
+    });
+}
+function filterSortByPropOrder({ arr, key, desiredOrder }) {
+    const orderMap = new Map();
+    desiredOrder.forEach((value, index) => orderMap.set(value, index));
+    return [...arr].sort((a, b) => {
+        const aIndex = orderMap.get(a[key]) ?? Infinity;
+        const bIndex = orderMap.get(b[key]) ?? Infinity;
+        return aIndex - bIndex;
+    });
+}
+function filterRemoveItemsByProps({ arr, key, valuesToRemove }) {
+    return arr.filter(item => !valuesToRemove.includes(item[key]));
+}
+export { mongoFilter, filterUniqueOnce, filterSortByPropOrder, filterRemoveItemsByProps };

package/source/utils/helpers/hash/crypto.d.ts

@@ -0,0 +1,3 @@
+export declare function generateSHA256Hash(secret: any, payload?: any): string;
+export declare function generateNumberAndLetter(length?: number): string;
+export declare function generateCodeChallenge(codeVerifier: string): string;

package/source/utils/helpers/hash/crypto.js

@@ -0,0 +1,22 @@
+import crypto from 'crypto';
+export function generateSHA256Hash(secret, payload) {
+    return crypto
+        .createHmac('sha256', secret)
+        .update(payload ? payload : '')
+        .digest('hex');
+}
+export function generateNumberAndLetter(length = 8) {
+    const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const array = new Uint8Array(length);
+    crypto.getRandomValues(array);
+    return Array.from(array, byte => charset[byte % charset.length]).join('');
+}
+export function generateCodeChallenge(codeVerifier) {
+    return crypto
+        .createHash('sha256')
+        .update(codeVerifier)
+        .digest('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/, '');
+}

package/source/utils/helpers/id/index.d.ts

@@ -0,0 +1,13 @@
+export declare const serverIdNameGenerator: ({ prefix, payload, suffix }: {
+    prefix?: string;
+    payload: any;
+    suffix?: string;
+}) => string;
+export declare function generateRandomKey(options: {
+    length?: number;
+    format?: 'hex' | 'base64';
+    prefix?: string;
+    suffix?: string;
+    separator?: string;
+}): string;
+export declare function generateReferenceCode(length: number, prefix?: string, middle?: string, suffix?: string): string;

package/source/utils/helpers/id/index.js

@@ -0,0 +1,24 @@
+import crypto from 'crypto';
+export const serverIdNameGenerator = ({ prefix, payload, suffix }) => {
+    return `${prefix}-${payload.toString()}-${suffix}`;
+};
+export function generateRandomKey(options) {
+    const { length = 48, format = 'hex', prefix = '', suffix = '', separator = '-', } = options;
+    const randomPart = crypto.randomBytes(length).toString(format);
+    const parts = [prefix, randomPart, suffix].filter(Boolean);
+    return parts.join(separator);
+}
+export function generateReferenceCode(length, prefix = "", middle = "", suffix = "") {
+    const totalLength = prefix.length + length + middle.length + suffix.length;
+    if (totalLength <= 0) {
+        throw new Error("The total length (including prefix, middle, and suffix) must be greater than 0.");
+    }
+    let referenceCode = "";
+    for (let i = 0; i < length; i++) {
+        const randomDigit = Math.floor(Math.random() * 10);
+        referenceCode += randomDigit.toString();
+    }
+    const middleIndex = Math.floor(referenceCode.length / 2);
+    const referenceWithMiddle = referenceCode.slice(0, middleIndex) + middle + referenceCode.slice(middleIndex);
+    return `${prefix}${referenceWithMiddle}${suffix}`;
+}

package/source/utils/helpers/index.d.ts

@@ -0,0 +1,16 @@
+export * from './tmp/index';
+export * from './path/index';
+export * from './is/index';
+export * from './id/index';
+export * from './validates/index';
+export * from './ip/index';
+export * from './hash/crypto';
+export * from './string/index';
+export * from './objects/index';
+export * from './locales/index';
+export * from './timer/index';
+export * from './date/index';
+export * from './math/index';
+export * from './regex/checkSpecialRegexControl';
+export * from './filters/index';
+export * from './locales/index';

package/source/utils/helpers/index.js

@@ -0,0 +1,16 @@
+export * from './tmp/index';
+export * from './path/index';
+export * from './is/index';
+export * from './id/index';
+export * from './validates/index';
+export * from './ip/index';
+export * from './hash/crypto';
+export * from './string/index';
+export * from './objects/index';
+export * from './locales/index';
+export * from './timer/index';
+export * from './date/index';
+export * from './math/index';
+export * from './regex/checkSpecialRegexControl';
+export * from './filters/index';
+export * from './locales/index';

package/source/utils/helpers/ip/index.d.ts

@@ -0,0 +1 @@
+export declare const getClientIp: (req: any) => any;

package/source/utils/helpers/ip/index.js

@@ -0,0 +1,3 @@
+export const getClientIp = (req) => {
+    return req.headers["x-forwarded-for"]?.split(",")[0] || req.socket.remoteAddress;
+};

package/source/utils/helpers/is/index.d.ts

@@ -0,0 +1,11 @@
+export declare function isFalsy(value: unknown, options: {
+    ignoreFalse?: boolean;
+    ignoreZero?: boolean;
+    ignoreEmptyString?: boolean;
+    ignoreNull?: boolean;
+    ignoreUndefined?: boolean;
+    ignoreNaN?: boolean;
+}): boolean;
+export declare function isType(data: any, type: any): boolean;
+export declare function isInstance(data: any, type: any): boolean;
+export declare function isBcryptHash(value: string): boolean;

package/source/utils/helpers/is/index.js

@@ -0,0 +1,35 @@
+export function isFalsy(value, options) {
+    if (!options.ignoreFalse && value === false)
+        return true;
+    if (!options.ignoreZero && value === 0)
+        return true;
+    if (!options.ignoreEmptyString && value === '')
+        return true;
+    if (!options.ignoreNull && value === null)
+        return true;
+    if (!options.ignoreUndefined && value === undefined)
+        return true;
+    if (!options.ignoreNaN && typeof value === 'number' && isNaN(value))
+        return true;
+    return false;
+}
+export function isType(data, type) {
+    if (typeof data === type) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function isInstance(data, type) {
+    if (data instanceof type) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function isBcryptHash(value) {
+    const bcryptRegex = /^\$2[aby]\$\d{2}\$.{53}$/;
+    return bcryptRegex.test(value);
+}

package/source/utils/helpers/locales/index.d.ts

@@ -0,0 +1,52 @@
+export declare const responseMessageHelper: {
+    successFully: (process?: string, event?: string, t?: any) => string;
+    unsuccessful: (process?: string, event?: string, t?: any) => string;
+    notFound: (process?: string, event?: string, t?: any) => string;
+    notMatch: (process?: string, event?: string, t?: any) => string;
+    notUse: (process?: string, event?: string, t?: any) => string;
+    invalid: (process?: string, event?: string, t?: any) => string;
+    checked: (process?: string, event?: string, t?: any) => string;
+    process: (process?: string, event?: string, t?: any) => string;
+    missingData: (process?: string, event?: string, t?: any) => string;
+    allreadyHave: (process?: string, event?: string, t?: any) => string;
+    wrongFormat: (process?: string, event?: string, t?: any) => string;
+    externalApiError: (process?: string, event?: string, t?: any) => string;
+    unauthorizedUrl: (process?: string, event?: string, t?: any) => string;
+    endpointNotWorking: (endpoint?: string, t?: any) => string;
+    schemaMissingDataChecks: (t?: any) => string;
+    schemaInvalidDataChecks: (t?: any) => string;
+    schemaUnknowErrorChecks: (a: any, b: any, t?: any) => string;
+    schemaUnknowErrorLogic: (a: any, b: any, t?: any) => string;
+    schemaUnknowErrorResponse: (a: any, b: any, t?: any) => string;
+    schemaUnknowErrorMain: (a: any, b: any, t?: any) => string;
+    dbQueryError: (process?: string, event?: string, t?: any) => string;
+    unknowError: (process?: string, event?: string, t?: any) => string;
+    serverError: (process?: string, event?: string, t?: any) => string;
+    emailWelcomeTemplateTitle: (t?: any) => string;
+    emailWelcomeTemplateExplanation: (t?: any) => string;
+    emailForgotPasswordTemplateTitle: (t?: any) => string;
+    emailForgotPasswordTemplateExplanation: (t?: any) => string;
+    allRightsReserved: (extra1?: string, extra2?: string, t?: any) => string;
+    emailButtonText: (t?: any) => string;
+    emailIgnoreText: (t?: any) => string;
+    welcomeMessage: (username?: string, t?: any) => string;
+    userIsBlocked: (extra1?: string, t?: any) => string;
+    passwordChangeCode: (username?: string, t?: any) => string;
+    notEnoughWalletBalance: (money?: string, currency?: string, t?: any) => string;
+    openAuthConsumerOverhang: (param1?: string, param2?: string, t?: any) => string;
+    thirdPartySystemOverhang: (param1?: string, param2?: string, t?: any) => string;
+    deviceOverhang: (param1?: string, param2?: string, t?: any) => string;
+    provisionOverhang: (money?: string, currency?: string, t?: any) => string;
+    balanceOverhang: (money?: string, currency?: string, t?: any) => string;
+    debtOverhang: (money?: string, currency?: string, t?: any) => string;
+    shipmentNotAccepted: (value1?: string, value2?: string, t?: any) => string;
+    optionsMethod: (methods?: string, t?: any) => string;
+    notAllowedCORS: (methods?: string, t?: any) => string;
+    missingCRSFToken: (t?: any) => string;
+    invalidCRSFToken: (t?: any) => string;
+    tooManyRequest: (t?: any) => string;
+    endpointNotFound: (t?: any) => string;
+    roleAccess: (error?: string, t?: any) => string;
+    authenticationRequiredTokenExpired: (t?: any) => string;
+    authenticationRequired: (t?: any) => string;
+};