namirasoft-core 1.5.2 → 1.5.3

package/src/FileOperation.ts

@@ -1,61 +1,61 @@
-let fs: any;
-let path: any;
-if (typeof window === 'undefined')
-{
-    fs = require('fs');
-    path = require('path');
-}
-export class FileOperation
-{
-    static findUp(fileName: string): string[]
-    {
-        let currentDir: string = __dirname;
-        const rootDir: string = process.cwd();
-        const foundFilePaths: string[] = [];
-        function searchRecursively(dir: string)
-        {
-            const files: string[] = fs.readdirSync(dir);
-            if (files.includes(fileName))
-                foundFilePaths.push(path.join(dir, fileName));
-            if (rootDir === dir)
-                return;
-            let new_dir = path.dirname(dir);
-            if (new_dir == dir)
-                return;
-            searchRecursively(new_dir);
-        }
-        searchRecursively(currentDir);
-        return foundFilePaths;
-    }
-    static async foreach(base: string, handler: (base: string, sub: string, name: string, full: string, isFolder: boolean) => Promise<boolean>, folders: boolean = true, files: boolean = true, level: number | null = null)
-    {
-        async function recursive(base: string, sub: string, number: number)
-        {
-            if (level)
-                if (number > level)
-                    return;
-            let names = fs.readdirSync(path.join(base, sub));
-            for (let name of names)
-            {
-                let newSub = path.join(sub, name)
-                let full = path.join(base, newSub);
-                if (fs.statSync(full).isDirectory())
-                {
-                    if (folders)
-                    {
-                        let moveon = await handler(base, sub, name, full, true);
-                        if (!moveon)
-                            continue;
-                    }
-                    await recursive(base, newSub, number + 1);
-                }
-                else
-                {
-                    if (files)
-                        await handler(base, sub, name, full, false);
-                }
-            }
-        }
-        await recursive(base, "", 1);
-    }
+let fs: any;
+let path: any;
+if (typeof window === 'undefined')
+{
+    fs = require('fs');
+    path = require('path');
+}
+export class FileOperation
+{
+    static findUp(fileName: string): string[]
+    {
+        let currentDir: string = __dirname;
+        const rootDir: string = process.cwd();
+        const foundFilePaths: string[] = [];
+        function searchRecursively(dir: string)
+        {
+            const files: string[] = fs.readdirSync(dir);
+            if (files.includes(fileName))
+                foundFilePaths.push(path.join(dir, fileName));
+            if (rootDir === dir)
+                return;
+            let new_dir = path.dirname(dir);
+            if (new_dir == dir)
+                return;
+            searchRecursively(new_dir);
+        }
+        searchRecursively(currentDir);
+        return foundFilePaths;
+    }
+    static async foreach(base: string, handler: (base: string, sub: string, name: string, full: string, isFolder: boolean) => Promise<boolean>, folders: boolean = true, files: boolean = true, level: number | null = null)
+    {
+        async function recursive(base: string, sub: string, number: number)
+        {
+            if (level)
+                if (number > level)
+                    return;
+            let names = fs.readdirSync(path.join(base, sub));
+            for (let name of names)
+            {
+                let newSub = path.join(sub, name)
+                let full = path.join(base, newSub);
+                if (fs.statSync(full).isDirectory())
+                {
+                    if (folders)
+                    {
+                        let moveon = await handler(base, sub, name, full, true);
+                        if (!moveon)
+                            continue;
+                    }
+                    await recursive(base, newSub, number + 1);
+                }
+                else
+                {
+                    if (files)
+                        await handler(base, sub, name, full, false);
+                }
+            }
+        }
+        await recursive(base, "", 1);
+    }
 }

package/src/FilterItem.ts

@@ -1,118 +1,118 @@
-import { BaseMetaColumn } from "./BaseMetaColumn";
-import { BaseMetaTable } from "./BaseMetaTable";
-import { EncodingOperation } from "./EncodingOperation";
-import { ErrorOperation } from "./ErrorOperation";
-import { FilterItemOperator } from "./FilterItemOperator";
-
-export class FilterItem
-{
-    public table: BaseMetaTable;
-    public column: BaseMetaColumn;
-    public not: boolean;
-    public operator: FilterItemOperator;
-    public values: string[];
-    public static encode(filters: FilterItem[] | null): string
-    {
-        let value = this.stringify(filters);
-        return EncodingOperation.Base64Encode(value);
-    }
-    public static decode(value: string): FilterItem[] | null
-    {
-        let encoded = EncodingOperation.Base64Decode(value);
-        return this.parse(encoded);
-    }
-    public static stringify(filters: FilterItem[] | null): string
-    {
-        if (filters)
-            return filters.map(x => x.getCommand()).join(";");
-        return "";
-    }
-    public static parse(item: string | null): FilterItem[]
-    {
-        let ans: FilterItem[] = [];
-        if (item)
-        {
-            let index = 0;
-            let items = item.split(/(?<!\\);/);
-            let thereIsMore = (): boolean =>
-            {
-                return index < items.length;
-            };
-            let next = (name: string): string =>
-            {
-                if (thereIsMore())
-                    return items[index++];
-                throw ErrorOperation.getHTTP(400, `Next value is required for '${name}'. Must be separated by ;`);
-            };
-            while (thereIsMore())
-            {
-                let value_table = next("Table");
-                let table = new BaseMetaTable(null, value_table, value_table);
-
-                let value_column = next("Column");
-                let column = new BaseMetaColumn(table, value_column, value_column, "", false)
-
-                let value_not = next("Not");
-                let not = value_not != "0"
-                if (value_not != "0" && value_not != "1")
-                    ErrorOperation.throwHTTP(400, `Invalid value '${value_not}' for FilterItem.not, Only 0 and 1 are allowed.`);
-
-                let value_operator = next("Operator");
-                let operator = FilterItemOperator.getByName(value_operator);
-
-                let values: string[] = [];
-                for (let j = 0; j < operator.count; j++)
-                {
-                    let value_value = next("Value Number " + (j + 1));
-                    let value = value_value.replace(/\\;/gm, ";");
-                    values.push(value);
-                }
-
-                ans.push(new FilterItem(table, column, not, operator, ...values));
-            }
-        }
-        return ans;
-    }
-    constructor(table: BaseMetaTable, column: BaseMetaColumn, not: boolean, operator: FilterItemOperator, ...values: string[])
-    {
-        this.table = table;
-        this.column = column;
-        this.not = not;
-        this.operator = operator;
-        this.values = values;
-        if (this.values.length != operator.count)
-            throw ErrorOperation.getHTTP(400, `Invalid count of values: ${this.values.length} is provided but ${operator.count} is required.`);
-    }
-    getCommand()
-    {
-        return [this.table.name, this.column.name, this.not ? "1" : "0", this.operator.name, ...this.values.map(x => (x ?? "").toString().replace(/;/gm, "\\;"))].join(";");
-    }
-    isAllColumns()
-    {
-        return this.column.name === "*";
-    }
-    toString()
-    {
-        let ans = [];
-        if (!this.isAllColumns())
-        {
-            let table;
-            let column;
-            if (this.table.text)
-                table = this.table.text;
-            else
-                table = this.table.name;
-            if (this.column.text)
-                column = this.column.text;
-            else
-                column = this.column.name;
-            ans.push([table, column].filter(x => x).join("."));
-        }
-        if (this.not)
-            ans.push("Not");
-        if (!this.isAllColumns() || this.operator != FilterItemOperator.all.equals || this.not)
-            ans.push(this.operator.name);
-        ans.push(this.values.join(", "));
-        return ans.filter(x => x).join(" ");
-    }
+import { BaseMetaColumn } from "./BaseMetaColumn";
+import { BaseMetaTable } from "./BaseMetaTable";
+import { EncodingOperation } from "./EncodingOperation";
+import { ErrorOperation } from "./ErrorOperation";
+import { FilterItemOperator } from "./FilterItemOperator";
+
+export class FilterItem
+{
+    public table: BaseMetaTable;
+    public column: BaseMetaColumn;
+    public not: boolean;
+    public operator: FilterItemOperator;
+    public values: string[];
+    public static encode(filters: FilterItem[] | null): string
+    {
+        let value = this.stringify(filters);
+        return EncodingOperation.Base64Encode(value);
+    }
+    public static decode(value: string): FilterItem[] | null
+    {
+        let encoded = EncodingOperation.Base64Decode(value);
+        return this.parse(encoded);
+    }
+    public static stringify(filters: FilterItem[] | null): string
+    {
+        if (filters)
+            return filters.map(x => x.getCommand()).join(";");
+        return "";
+    }
+    public static parse(item: string | null): FilterItem[]
+    {
+        let ans: FilterItem[] = [];
+        if (item)
+        {
+            let index = 0;
+            let items = item.split(/(?<!\\);/);
+            let thereIsMore = (): boolean =>
+            {
+                return index < items.length;
+            };
+            let next = (name: string): string =>
+            {
+                if (thereIsMore())
+                    return items[index++];
+                throw ErrorOperation.getHTTP(400, `Next value is required for '${name}'. Must be separated by ;`);
+            };
+            while (thereIsMore())
+            {
+                let value_table = next("Table");
+                let table = new BaseMetaTable(null, value_table, value_table);
+
+                let value_column = next("Column");
+                let column = new BaseMetaColumn(table, value_column, value_column, "", false)
+
+                let value_not = next("Not");
+                let not = value_not != "0"
+                if (value_not != "0" && value_not != "1")
+                    ErrorOperation.throwHTTP(400, `Invalid value '${value_not}' for FilterItem.not, Only 0 and 1 are allowed.`);
+
+                let value_operator = next("Operator");
+                let operator = FilterItemOperator.getByName(value_operator);
+
+                let values: string[] = [];
+                for (let j = 0; j < operator.count; j++)
+                {
+                    let value_value = next("Value Number " + (j + 1));
+                    let value = value_value.replace(/\\;/gm, ";");
+                    values.push(value);
+                }
+
+                ans.push(new FilterItem(table, column, not, operator, ...values));
+            }
+        }
+        return ans;
+    }
+    constructor(table: BaseMetaTable, column: BaseMetaColumn, not: boolean, operator: FilterItemOperator, ...values: string[])
+    {
+        this.table = table;
+        this.column = column;
+        this.not = not;
+        this.operator = operator;
+        this.values = values;
+        if (this.values.length != operator.count)
+            throw ErrorOperation.getHTTP(400, `Invalid count of values: ${this.values.length} is provided but ${operator.count} is required.`);
+    }
+    getCommand()
+    {
+        return [this.table.name, this.column.name, this.not ? "1" : "0", this.operator.name, ...this.values.map(x => (x ?? "").toString().replace(/;/gm, "\\;"))].join(";");
+    }
+    isAllColumns()
+    {
+        return this.column.name === "*";
+    }
+    toString()
+    {
+        let ans = [];
+        if (!this.isAllColumns())
+        {
+            let table;
+            let column;
+            if (this.table.text)
+                table = this.table.text;
+            else
+                table = this.table.name;
+            if (this.column.text)
+                column = this.column.text;
+            else
+                column = this.column.name;
+            ans.push([table, column].filter(x => x).join("."));
+        }
+        if (this.not)
+            ans.push("Not");
+        if (!this.isAllColumns() || this.operator != FilterItemOperator.all.equals || this.not)
+            ans.push(this.operator.name);
+        ans.push(this.values.join(", "));
+        return ans.filter(x => x).join(" ");
+    }
 }

package/src/FilterItemColumnType.ts

@@ -1,10 +1,10 @@
-export enum FilterItemColumnType 
-{
-    Unknown = "Unknown",
-    Boolean = "Boolean",
-    Number = "Number",
-    String = "String",
-    Date = "Date",
-    Time = "Time",
-    DateTime = "DateTime",
+export enum FilterItemColumnType 
+{
+    Unknown = "Unknown",
+    Boolean = "Boolean",
+    Number = "Number",
+    String = "String",
+    Date = "Date",
+    Time = "Time",
+    DateTime = "DateTime",
 };

package/src/FilterItemOperator.ts

@@ -1,53 +1,53 @@
-import { ErrorOperation } from "./ErrorOperation";
-import { FilterItemColumnType } from "./FilterItemColumnType";
-
-export class FilterItemOperator
-{
-    static all = {
-        equals: new FilterItemOperator("Equals", "=", 1, (type: FilterItemColumnType) => { return type != FilterItemColumnType.Unknown; }),
-        contains: new FilterItemOperator("Contains", ":", 1, (type: FilterItemColumnType) => { return type != FilterItemColumnType.Unknown && type != FilterItemColumnType.Boolean; }),
-        regex: new FilterItemOperator("Regex", "*", 1, (type: FilterItemColumnType) => { return type != FilterItemColumnType.Unknown && type != FilterItemColumnType.Boolean; }),
-        empty: new FilterItemOperator("Empty", "?", 0, (type: FilterItemColumnType) => { return type != FilterItemColumnType.Unknown; }),
-        exists: new FilterItemOperator("Exists", "??", 0, (_: FilterItemColumnType, required: boolean) => { return !required; }),
-        includes: new FilterItemOperator("Includes", "()", 1, (_: FilterItemColumnType, required: boolean) => { return !required; }),
-        startswith: new FilterItemOperator("Starts With", "(", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.String; }),
-        endswith: new FilterItemOperator("Ends With", ")", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.String; }),
-        lessthan: new FilterItemOperator("Less Than", "<", 1, (type: FilterItemColumnType) => { return [FilterItemColumnType.Number, FilterItemColumnType.DateTime, FilterItemColumnType.Date, FilterItemColumnType.Time].includes(type); }),
-        lessthanequal: new FilterItemOperator("Less Than Equal", "<=", 1, (type: FilterItemColumnType) => { return [FilterItemColumnType.Number, FilterItemColumnType.DateTime, FilterItemColumnType.Date, FilterItemColumnType.Time].includes(type); }),
-        morethan: new FilterItemOperator("More Than", ">", 1, (type: FilterItemColumnType) => { return [FilterItemColumnType.Number, FilterItemColumnType.DateTime, FilterItemColumnType.Date, FilterItemColumnType.Time].includes(type); }),
-        morethanequal: new FilterItemOperator("More Than Equal", ">=", 1, (type: FilterItemColumnType) => { return [FilterItemColumnType.Number, FilterItemColumnType.DateTime, FilterItemColumnType.Date, FilterItemColumnType.Time].includes(type); }),
-    };
-    static getAll(): FilterItemOperator[]
-    {
-        return Object.keys(FilterItemOperator.all).map(name => (FilterItemOperator.all as any)[name]);
-    }
-    static getAllByType(type: FilterItemColumnType, required: boolean): FilterItemOperator[]
-    {
-        return FilterItemOperator.getAll().filter(f => f.accepts(type, required));
-    }
-    static getByName(name: string): FilterItemOperator
-    {
-        let found = (FilterItemOperator.all as any)[name.toLowerCase()];
-        if (!found)
-            ErrorOperation.throwHTTP(400, `Could not find operator by name: '${name}'. Valid values are ${this.getAll().map(x => x.name).join(",")}`);
-        return found;
-    }
-    static getBySign(sign: string): FilterItemOperator
-    {
-        let found = FilterItemOperator.getAll().filter(x => x.sign == sign);
-        if (found.length == 0)
-            ErrorOperation.throwHTTP(400, `Could not find operator by sign: '${sign}'. Valid values are ${this.getAll().map(x => x.sign).join(",")}`);
-        return found[0];
-    }
-    name: string;
-    sign: string;
-    count: number;
-    accepts: (type: FilterItemColumnType, required: boolean) => boolean;
-    constructor(name: string, sign: string, count: number, accepts: (type: FilterItemColumnType, required: boolean) => boolean)
-    {
-        this.name = name;
-        this.sign = sign;
-        this.count = count;
-        this.accepts = accepts;
-    }
+import { ErrorOperation } from "./ErrorOperation";
+import { FilterItemColumnType } from "./FilterItemColumnType";
+
+export class FilterItemOperator
+{
+    static all = {
+        equals: new FilterItemOperator("Equals", "=", 1, (type: FilterItemColumnType) => { return type != FilterItemColumnType.Unknown; }),
+        contains: new FilterItemOperator("Contains", ":", 1, (type: FilterItemColumnType) => { return type != FilterItemColumnType.Unknown && type != FilterItemColumnType.Boolean; }),
+        regex: new FilterItemOperator("Regex", "*", 1, (type: FilterItemColumnType) => { return type != FilterItemColumnType.Unknown && type != FilterItemColumnType.Boolean; }),
+        empty: new FilterItemOperator("Empty", "?", 0, (type: FilterItemColumnType) => { return type != FilterItemColumnType.Unknown; }),
+        exists: new FilterItemOperator("Exists", "??", 0, (_: FilterItemColumnType, required: boolean) => { return !required; }),
+        includes: new FilterItemOperator("Includes", "()", 1, (_: FilterItemColumnType, required: boolean) => { return !required; }),
+        startswith: new FilterItemOperator("Starts With", "(", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.String; }),
+        endswith: new FilterItemOperator("Ends With", ")", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.String; }),
+        lessthan: new FilterItemOperator("Less Than", "<", 1, (type: FilterItemColumnType) => { return [FilterItemColumnType.Number, FilterItemColumnType.DateTime, FilterItemColumnType.Date, FilterItemColumnType.Time].includes(type); }),
+        lessthanequal: new FilterItemOperator("Less Than Equal", "<=", 1, (type: FilterItemColumnType) => { return [FilterItemColumnType.Number, FilterItemColumnType.DateTime, FilterItemColumnType.Date, FilterItemColumnType.Time].includes(type); }),
+        morethan: new FilterItemOperator("More Than", ">", 1, (type: FilterItemColumnType) => { return [FilterItemColumnType.Number, FilterItemColumnType.DateTime, FilterItemColumnType.Date, FilterItemColumnType.Time].includes(type); }),
+        morethanequal: new FilterItemOperator("More Than Equal", ">=", 1, (type: FilterItemColumnType) => { return [FilterItemColumnType.Number, FilterItemColumnType.DateTime, FilterItemColumnType.Date, FilterItemColumnType.Time].includes(type); }),
+    };
+    static getAll(): FilterItemOperator[]
+    {
+        return Object.keys(FilterItemOperator.all).map(name => (FilterItemOperator.all as any)[name]);
+    }
+    static getAllByType(type: FilterItemColumnType, required: boolean): FilterItemOperator[]
+    {
+        return FilterItemOperator.getAll().filter(f => f.accepts(type, required));
+    }
+    static getByName(name: string): FilterItemOperator
+    {
+        let found = (FilterItemOperator.all as any)[name.toLowerCase()];
+        if (!found)
+            ErrorOperation.throwHTTP(400, `Could not find operator by name: '${name}'. Valid values are ${this.getAll().map(x => x.name).join(",")}`);
+        return found;
+    }
+    static getBySign(sign: string): FilterItemOperator
+    {
+        let found = FilterItemOperator.getAll().filter(x => x.sign == sign);
+        if (found.length == 0)
+            ErrorOperation.throwHTTP(400, `Could not find operator by sign: '${sign}'. Valid values are ${this.getAll().map(x => x.sign).join(",")}`);
+        return found[0];
+    }
+    name: string;
+    sign: string;
+    count: number;
+    accepts: (type: FilterItemColumnType, required: boolean) => boolean;
+    constructor(name: string, sign: string, count: number, accepts: (type: FilterItemColumnType, required: boolean) => boolean)
+    {
+        this.name = name;
+        this.sign = sign;
+        this.count = count;
+        this.accepts = accepts;
+    }
 }

package/src/GeoOperation.ts

@@ -1,19 +1,19 @@
-export class GeoOperation
-{
-    static distance(lat1: number, lng1: number, lat2: number, lng2: number)
-    {
-        function degreeToRadian(degree: number)
-        {
-            return degree * Math.PI / 180;
-        }
-        let R = 6371; // km
-        let dLat = degreeToRadian(lat2 - lat1);
-        let dLng = degreeToRadian(lng2 - lng1);
-        lat1 = degreeToRadian(lat1);
-        lat2 = degreeToRadian(lat2);
-        let a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-            Math.sin(dLng / 2) * Math.sin(dLng / 2) * Math.cos(lat1) * Math.cos(lat2);
-        let c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-        return R * c;
-    }
+export class GeoOperation
+{
+    static distance(lat1: number, lng1: number, lat2: number, lng2: number)
+    {
+        function degreeToRadian(degree: number)
+        {
+            return degree * Math.PI / 180;
+        }
+        let R = 6371; // km
+        let dLat = degreeToRadian(lat2 - lat1);
+        let dLng = degreeToRadian(lng2 - lng1);
+        lat1 = degreeToRadian(lat1);
+        lat2 = degreeToRadian(lat2);
+        let a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+            Math.sin(dLng / 2) * Math.sin(dLng / 2) * Math.cos(lat1) * Math.cos(lat2);
+        let c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+        return R * c;
+    }
 }

package/src/HTTPError.ts

@@ -1,9 +1,9 @@
-export class HTTPError extends Error
-{
-    code: number;
-    constructor(code: number, message: string)
-    {
-        super(message);
-        this.code = code;
-    }
+export class HTTPError extends Error
+{
+    code: number;
+    constructor(code: number, message: string)
+    {
+        super(message);
+        this.code = code;
+    }
 }

package/src/HTTPMethod.ts

@@ -1,8 +1,8 @@
-export enum HTTPMethod
-{
-    GET = "GET",
-    POST = "POST",
-    PUT = "PUT",
-    PATCH = "PATCH",
-    DELETE = "DELETE"
+export enum HTTPMethod
+{
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE"
 }

package/src/HashOperation.ts

@@ -1,25 +1,25 @@
-import * as crypto from 'node:crypto';
-
-export class HashOperation
-{
-    static SHA256<T>(message: T): string
-    {
-        const hash = crypto.createHash('sha256');
-        hash.update(JSON.stringify(message));
-        return hash.digest('hex');
-    }
-    static SHA256Secret<T>(secret: string, message: T): string
-    {
-        const hash = crypto.createHmac('sha256', secret);
-        hash.update(JSON.stringify(message));
-        return hash.digest('hex');
-    }
-    static isValidSHA256(values: any, signature: string)
-    {
-        return this.SHA256(values).toLowerCase() === signature.toLowerCase();
-    }
-    static isValidSHA256Secret(secret: string, values: any, signature: string)
-    {
-        return this.SHA256Secret(secret, values).toLowerCase() === signature.toLowerCase();
-    }
+import * as crypto from 'node:crypto';
+
+export class HashOperation
+{
+    static SHA256<T>(message: T): string
+    {
+        const hash = crypto.createHash('sha256');
+        hash.update(JSON.stringify(message));
+        return hash.digest('hex');
+    }
+    static SHA256Secret<T>(secret: string, message: T): string
+    {
+        const hash = crypto.createHmac('sha256', secret);
+        hash.update(JSON.stringify(message));
+        return hash.digest('hex');
+    }
+    static isValidSHA256(values: any, signature: string)
+    {
+        return this.SHA256(values).toLowerCase() === signature.toLowerCase();
+    }
+    static isValidSHA256Secret(secret: string, values: any, signature: string)
+    {
+        return this.SHA256Secret(secret, values).toLowerCase() === signature.toLowerCase();
+    }
 }

package/src/ILogger.ts

@@ -1,18 +1,18 @@
-import { LogLevel } from "./LogLevel";
-
-export interface ILogger
-{
-    log(level: LogLevel, ...messages: any[]): void;
-    trace(...messages: any[]): void;
-    verbose(...messages: any[]): void;
-    debug(...messages: any[]): void;
-    info(...messages: any[]): void;
-    success(...messages: any[]): void;
-    warning(...messages: any[]): void;
-    error(...messages: any[]): void;
-    critical(...messages: any[]): void;
-    fatal(...messages: any[]): void;
-    onCatchError(error: Error | unknown): void;
-    onCatchCritical(error: Error | unknown): void;
-    onCatchFatal(error: Error | unknown): void;
+import { LogLevel } from "./LogLevel";
+
+export interface ILogger
+{
+    log(level: LogLevel, ...messages: any[]): void;
+    trace(...messages: any[]): void;
+    verbose(...messages: any[]): void;
+    debug(...messages: any[]): void;
+    info(...messages: any[]): void;
+    success(...messages: any[]): void;
+    warning(...messages: any[]): void;
+    error(...messages: any[]): void;
+    critical(...messages: any[]): void;
+    fatal(...messages: any[]): void;
+    onCatchError(error: Error | unknown): void;
+    onCatchCritical(error: Error | unknown): void;
+    onCatchFatal(error: Error | unknown): void;
 }