semola 0.5.3 → 0.6.0

package/dist/lib/errors/index.d.cts

@@ -1,5 +1,6 @@
-import { CommonError } from "../../errors/types.cjs";
-
+//#region src/lib/errors/types.d.ts
+type CommonError = "NotFoundError" | "UnauthorizedError" | "InternalServerError" | "ValidationError" | "MigrationError" | "SchemaError" | (string & {});
+//#endregion
 //#region src/lib/errors/index.d.ts
 declare const ok: <T>(data: T) => readonly [null, T];
 declare const err: <T extends CommonError>(type: T, message: string) => readonly [{
@@ -9,5 +10,4 @@ declare const err: <T extends CommonError>(type: T, message: string) => readonly
 declare const mightThrowSync: <T, E = Error>(fn: () => T) => readonly [null, T] | readonly [E, null];
 declare const mightThrow: <T, E = Error>(promise: Promise<T>) => Promise<readonly [null, T] | readonly [E, null]>;
 //#endregion
-export { err, mightThrow, mightThrowSync, ok };
-//# sourceMappingURL=index.d.cts.map
+export { err, mightThrow, mightThrowSync, ok };

package/dist/lib/errors/index.d.mts

@@ -1,5 +1,6 @@
-import { CommonError } from "../../errors/types.mjs";
-
+//#region src/lib/errors/types.d.ts
+type CommonError = "NotFoundError" | "UnauthorizedError" | "InternalServerError" | "ValidationError" | "MigrationError" | "SchemaError" | (string & {});
+//#endregion
 //#region src/lib/errors/index.d.ts
 declare const ok: <T>(data: T) => readonly [null, T];
 declare const err: <T extends CommonError>(type: T, message: string) => readonly [{
@@ -9,5 +10,4 @@ declare const err: <T extends CommonError>(type: T, message: string) => readonly
 declare const mightThrowSync: <T, E = Error>(fn: () => T) => readonly [null, T] | readonly [E, null];
 declare const mightThrow: <T, E = Error>(promise: Promise<T>) => Promise<readonly [null, T] | readonly [E, null]>;
 //#endregion
-export { err, mightThrow, mightThrowSync, ok };
-//# sourceMappingURL=index.d.mts.map
+export { err, mightThrow, mightThrowSync, ok };

package/dist/lib/errors/index.mjs

@@ -24,5 +24,3 @@ const mightThrow = async (promise) => {
 };
 //#endregion
 export { err, mightThrow, mightThrowSync, ok };
-
-//# sourceMappingURL=index.mjs.map

package/dist/lib/i18n/index.d.cts

@@ -1,5 +1,14 @@
-import { BuildParamObject, GetNestedValue, NestedKeyOf } from "../../i18n/types.cjs";
-
+//#region src/lib/i18n/types.d.ts
+type ExtractParamType<T extends string> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : never;
+type BuildParamObject<T extends string, Acc = {}> = T extends `${infer _Start}{${infer Name}:${infer Type}}${infer Rest}` ? BuildParamObject<Rest, Acc & Record<Name, ExtractParamType<Type>>> : Acc;
+type IsString<T> = T extends string ? true : false;
+type IsArray<T> = T extends readonly unknown[] ? true : false;
+type IsObject<T> = T extends object ? T extends readonly unknown[] ? false : true : false;
+type ArrayKeys<T extends readonly unknown[]> = { [K in keyof T & `${number}`]: `${K}` }[keyof T & `${number}`];
+type ObjectPropertyKeys<K extends string, V> = IsString<V> extends true ? K : IsArray<V> extends true ? V extends readonly unknown[] ? `${K}.${NestedKeyOf<V>}` : never : IsObject<V> extends true ? `${K}.${NestedKeyOf<V>}` : never;
+type NestedKeyOf<T> = IsArray<T> extends true ? T extends readonly unknown[] ? ArrayKeys<T> : never : IsObject<T> extends true ? { [K in keyof T & string]: ObjectPropertyKeys<K, T[K]> }[keyof T & string] : never;
+type GetNestedValue<T, K extends string> = K extends `${infer First}.${infer Rest}` ? First extends keyof T ? GetNestedValue<T[First], Rest> : never : K extends keyof T ? T[K] : never;
+//#endregion
 //#region src/lib/i18n/index.d.ts
 declare class I18n<const TLocales extends Record<string, Record<string, unknown>>, TDefaultLocale extends keyof TLocales> {
   private locales;
@@ -16,5 +25,4 @@ declare class I18n<const TLocales extends Record<string, Record<string, unknown>
   private substituteParams;
 }
 //#endregion
-export { I18n };
-//# sourceMappingURL=index.d.cts.map
+export { I18n };

package/dist/lib/i18n/index.d.mts

@@ -1,5 +1,14 @@
-import { BuildParamObject, GetNestedValue, NestedKeyOf } from "../../i18n/types.mjs";
-
+//#region src/lib/i18n/types.d.ts
+type ExtractParamType<T extends string> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : never;
+type BuildParamObject<T extends string, Acc = {}> = T extends `${infer _Start}{${infer Name}:${infer Type}}${infer Rest}` ? BuildParamObject<Rest, Acc & Record<Name, ExtractParamType<Type>>> : Acc;
+type IsString<T> = T extends string ? true : false;
+type IsArray<T> = T extends readonly unknown[] ? true : false;
+type IsObject<T> = T extends object ? T extends readonly unknown[] ? false : true : false;
+type ArrayKeys<T extends readonly unknown[]> = { [K in keyof T & `${number}`]: `${K}` }[keyof T & `${number}`];
+type ObjectPropertyKeys<K extends string, V> = IsString<V> extends true ? K : IsArray<V> extends true ? V extends readonly unknown[] ? `${K}.${NestedKeyOf<V>}` : never : IsObject<V> extends true ? `${K}.${NestedKeyOf<V>}` : never;
+type NestedKeyOf<T> = IsArray<T> extends true ? T extends readonly unknown[] ? ArrayKeys<T> : never : IsObject<T> extends true ? { [K in keyof T & string]: ObjectPropertyKeys<K, T[K]> }[keyof T & string] : never;
+type GetNestedValue<T, K extends string> = K extends `${infer First}.${infer Rest}` ? First extends keyof T ? GetNestedValue<T[First], Rest> : never : K extends keyof T ? T[K] : never;
+//#endregion
 //#region src/lib/i18n/index.d.ts
 declare class I18n<const TLocales extends Record<string, Record<string, unknown>>, TDefaultLocale extends keyof TLocales> {
   private locales;
@@ -16,5 +25,4 @@ declare class I18n<const TLocales extends Record<string, Record<string, unknown>
   private substituteParams;
 }
 //#endregion
-export { I18n };
-//# sourceMappingURL=index.d.mts.map
+export { I18n };

package/dist/lib/i18n/index.mjs

@@ -39,5 +39,3 @@ var I18n = class {
 };
 //#endregion
 export { I18n };
-
-//# sourceMappingURL=index.mjs.map

package/dist/lib/logging/index.cjs

@@ -1,18 +1,388 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_index = require("../../logging/formatter/index.cjs");
-const require_index$1 = require("../../logging/core/index.cjs");
-const require_types = require("../../logging/core/types.cjs");
-const require_index$2 = require("../../logging/provider/index.cjs");
-exports.AbstractLogger = require_index$1.AbstractLogger;
-exports.BaseFormatter = require_index.BaseFormatter;
-exports.ConsoleProvider = require_index$2.ConsoleProvider;
-exports.FileProvider = require_index$2.FileProvider;
-exports.Formatter = require_index.Formatter;
-exports.JSONFormatter = require_index.JSONFormatter;
-exports.LogLevel = require_types.LogLevel;
-exports.Logger = require_index$1.Logger;
-exports.LoggerProvider = require_index$2.LoggerProvider;
-exports.dmyFormat = require_index.dmyFormat;
-exports.isoDateFormat = require_index.isoDateFormat;
-exports.isoDateTimeFormat = require_index.isoDateTimeFormat;
-exports.mdyFormat = require_index.mdyFormat;
+require("../../chunk-CKQMccvm.cjs");
+const require_lib_errors_index = require("../errors/index.cjs");
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+//#region src/lib/logging/formatter/index.ts
+var Formatter = class {
+	dateFmt;
+	constructor(dateFmt) {
+		this.dateFmt = dateFmt;
+	}
+};
+var BaseFormatter = class extends Formatter {
+	constructor(dateFmt = isoDateTimeFormat) {
+		super(dateFmt);
+	}
+	format(logData) {
+		let { prefix, level, msg, fileName, row, column, method } = logData;
+		const timestamp = this.dateFmt();
+		const levelType = level.toUpperCase();
+		if (typeof msg === "object") msg = JSON.stringify(msg);
+		const fileData = `${prefix}/${fileName}:${row}:${column}`;
+		let header = `[${levelType}]`;
+		if (method) header = `${header}\t[${method}]\t[${fileData}]`;
+		else header = `${header}\t[${fileData}]`;
+		return `${timestamp}  ${header} : ${msg}`;
+	}
+	formatError(logData, error) {
+		const { prefix, fileName, row, column, method } = logData;
+		const timestamp = this.dateFmt();
+		const fileData = `${prefix}/${fileName}:${row}:${column}`;
+		let errorMsg = `Error name="${error.name}" Error message="${error.message}"`;
+		let header = "[ERROR]";
+		if (method) header = `${header}\t[${method}]\t[${fileData}]`;
+		else header = `${header}\t[${fileData}]`;
+		if (error.cause) errorMsg = `${errorMsg}\n\tError cause="${error.cause}"`;
+		if (error.stack) errorMsg = `${errorMsg}\n\tStack trace="${error.stack}"`;
+		return `${timestamp}  ${header} : ${errorMsg}`;
+	}
+};
+var JSONFormatter = class extends Formatter {
+	constructor(dateFmt = isoDateTimeFormat) {
+		super(dateFmt);
+	}
+	format(logData) {
+		const { prefix, level, msg, fileName, row, column, method } = logData;
+		const timestamp = this.dateFmt();
+		const levelType = level.toUpperCase();
+		let position = {};
+		if (method) position = { method };
+		position = {
+			...position,
+			fileName,
+			row,
+			column
+		};
+		return JSON.stringify({
+			timestamp,
+			level: levelType,
+			prefix,
+			position,
+			msg
+		});
+	}
+	formatError(logData, error) {
+		const { prefix, fileName, row, column, method } = logData;
+		const timestamp = this.dateFmt();
+		let errorMsg = {
+			errorName: error.name,
+			errorMessage: error.message
+		};
+		let position = {};
+		if (method) position = { method };
+		position = {
+			...position,
+			fileName,
+			row,
+			column
+		};
+		if (error.cause) errorMsg = {
+			...errorMsg,
+			errorCause: error.cause
+		};
+		if (error.stack) errorMsg = {
+			...errorMsg,
+			stackTrace: error.stack
+		};
+		return JSON.stringify({
+			timestamp,
+			level: "ERROR",
+			prefix,
+			position,
+			msg: errorMsg
+		});
+	}
+};
+function isoDateTimeFormat() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isoDateFormat() {
+	const date = isoDateTimeFormat().split("T")[0];
+	if (!date) return "";
+	return date;
+}
+function dmyFormat() {
+	const isoDate = isoDateFormat();
+	if (!isoDate) return "";
+	const info = isoDate.split("-");
+	return `${info[2]}-${info[1]}-${info[0]}`;
+}
+function mdyFormat() {
+	const isoDate = isoDateFormat();
+	if (!isoDate) return "";
+	const info = isoDate.split("-");
+	return `${info[1]}-${info[2]}-${info[0]}`;
+}
+//#endregion
+//#region src/lib/logging/core/index.ts
+const PROVIDER_OPTION_DEFAULT = {
+	formatter: new BaseFormatter(),
+	level: "debug"
+};
+const STACK_FRAME_IDX = 1;
+var StackData = class {
+	stack = [];
+	constructor(fn) {
+		const oldStackTrace = Error.prepareStackTrace;
+		const [stackTraceError] = require_lib_errors_index.mightThrowSync(() => {
+			Error.prepareStackTrace = (_, stack) => {
+				return stack.map((callSite) => {
+					return {
+						fileName: callSite.getFileName(),
+						column: callSite.getColumnNumber(),
+						row: callSite.getLineNumber(),
+						functionCall: callSite.getFunctionName()
+					};
+				});
+			};
+			Error.captureStackTrace(this, fn);
+			this.stack;
+		});
+		Error.prepareStackTrace = oldStackTrace;
+		if (stackTraceError) this.stack = [];
+	}
+	retrieveFrame() {
+		if (this.stack.length === 0) return void 0;
+		return this.stack[STACK_FRAME_IDX];
+	}
+};
+var AbstractLogger = class {
+	providers;
+	prefix;
+	constructor(prefix, providers) {
+		this.prefix = prefix;
+		this.providers = providers;
+	}
+	createLogData(level, msg, prefix) {
+		const logCall = new StackData(this.createLogData).retrieveFrame();
+		let logData = {
+			level,
+			msg,
+			prefix
+		};
+		if (!logCall) return logData;
+		const { column, fileName, functionCall, row } = logCall;
+		if (fileName) logData = {
+			...logData,
+			fileName: (0, node_path.basename)(fileName)
+		};
+		if (column) logData = {
+			...logData,
+			column: String(column)
+		};
+		if (row) logData = {
+			...logData,
+			row: String(row)
+		};
+		if (functionCall) logData = {
+			...logData,
+			method: functionCall
+		};
+		return logData;
+	}
+};
+var Logger = class extends AbstractLogger {
+	debug(msg) {
+		const data = this.createLogData("debug", msg, this.prefix);
+		this.run(data);
+	}
+	info(msg) {
+		const data = this.createLogData("info", msg, this.prefix);
+		this.run(data);
+	}
+	warning(msg) {
+		const data = this.createLogData("warning", msg, this.prefix);
+		this.run(data);
+	}
+	error(msg) {
+		const data = this.createLogData("error", msg, this.prefix);
+		this.run(data);
+	}
+	critical(msg) {
+		const data = this.createLogData("critical", msg, this.prefix);
+		this.run(data);
+	}
+	run(data) {
+		for (let i = 0; i < this.providers.length; i++) this.providers[i]?.execute(data);
+	}
+};
+//#endregion
+//#region src/lib/logging/core/types.ts
+const LogLevel = {
+	debug: 10,
+	info: 20,
+	warning: 30,
+	error: 40,
+	critical: 50
+};
+//#endregion
+//#region src/lib/logging/provider/index.ts
+const DEFAULT_MAX_SIZE = 4 * 1024;
+const DurationUnit = {
+	hour: 1e3 * 60 * 60,
+	day: 1e3 * 60 * 60 * 24,
+	week: 1e3 * 60 * 60 * 24 * 7,
+	month: 1e3 * 60 * 60 * 24 * 7 * 4.345
+};
+var LoggerProvider = class {
+	options;
+	constructor(options = PROVIDER_OPTION_DEFAULT) {
+		this.options = {
+			...PROVIDER_OPTION_DEFAULT,
+			...options
+		};
+	}
+	getLogLevel() {
+		if (!this.options.level) return LogLevel.debug;
+		return LogLevel[this.options.level];
+	}
+};
+const FILE_PROVIDER_OPTION_DEFAULT = {
+	...PROVIDER_OPTION_DEFAULT,
+	policy: { type: "size" }
+};
+var FileProvider = class extends LoggerProvider {
+	filePath;
+	counter;
+	file;
+	policy;
+	constructor(file, options = FILE_PROVIDER_OPTION_DEFAULT) {
+		super({
+			formatter: options.formatter ?? PROVIDER_OPTION_DEFAULT.formatter,
+			level: options.level ?? PROVIDER_OPTION_DEFAULT.level
+		});
+		this.policy = options.policy ?? FILE_PROVIDER_OPTION_DEFAULT.policy;
+		this.filePath = file;
+		this.counter = 0;
+		this.file = this.createNewFileName();
+	}
+	execute(data) {
+		if (this.getLogLevel() > LogLevel[data.level]) return;
+		const [error, formattedMessage] = require_lib_errors_index.mightThrowSync(() => {
+			if (this.isJSONFile()) return JSON.stringify({
+				timestamp: isoDateTimeFormat(),
+				level: data.level,
+				message: data.msg
+			});
+			const { formatter } = this.options;
+			return formatter?.format(data) ?? "";
+		});
+		const [fsError] = require_lib_errors_index.mightThrowSync(() => {
+			if (error && error instanceof Error) {
+				const { formatter } = this.options;
+				const errorMsg = formatter?.formatError(data, error);
+				(0, node_fs.appendFileSync)(this.file, `${errorMsg}\n`);
+			}
+			if (this.canRollFile()) {
+				this.counter += 1;
+				this.file = this.createNewFileName();
+			}
+			if (error || !formattedMessage) return;
+			(0, node_fs.appendFileSync)(this.file, `${formattedMessage}\n`);
+		});
+		if (fsError && fsError instanceof Error) throw fsError;
+	}
+	canRollFile() {
+		if (!this.policy) return false;
+		switch (this.policy.type) {
+			case "size":
+				if (this.policy.maxSize) return this.getFileSize() >= this.policy.maxSize;
+				return this.getFileSize() >= DEFAULT_MAX_SIZE;
+			case "time": {
+				if (!(0, node_fs.existsSync)(this.file)) return false;
+				const { duration, instant } = this.policy;
+				const { birthtime } = (0, node_fs.statSync)(this.file);
+				const creationTimeMs = birthtime.getTime();
+				const currenTimeMs = Date.now();
+				const diffMs = currenTimeMs - creationTimeMs;
+				switch (instant) {
+					case "hour": return Math.floor(diffMs / DurationUnit.hour) >= duration;
+					case "day": return Math.floor(diffMs / DurationUnit.day) >= duration;
+					case "week": return Math.floor(diffMs / DurationUnit.week) >= duration;
+					case "month": {
+						const currentDate = new Date(currenTimeMs);
+						const monthsDiff = (currentDate.getFullYear() - birthtime.getFullYear()) * 12 + (currentDate.getMonth() - birthtime.getMonth());
+						return (currentDate.getDate() >= birthtime.getDate() ? monthsDiff : monthsDiff - 1) >= duration;
+					}
+				}
+			}
+		}
+	}
+	getFileSize() {
+		if (!(0, node_fs.existsSync)(this.file)) return 0;
+		const [statError, size] = require_lib_errors_index.mightThrowSync(() => {
+			const { size } = (0, node_fs.statSync)(this.file);
+			return size;
+		});
+		if (statError && statError instanceof Error) return 0;
+		if (!size) return 0;
+		return size;
+	}
+	isJSONFile() {
+		return (0, node_path.extname)(this.filePath) === ".json";
+	}
+	createNewFileName() {
+		const fileName = (0, node_path.basename)(this.filePath);
+		const directory = (0, node_path.dirname)(this.filePath);
+		if (!(0, node_fs.existsSync)(directory)) (0, node_fs.mkdirSync)(directory, { recursive: true });
+		const fileInfo = fileName.split(".");
+		const extension = fileInfo.pop();
+		return (0, node_path.join)(directory, [
+			...fileInfo,
+			this.counter,
+			extension
+		].join("."));
+	}
+};
+var ConsoleProvider = class extends LoggerProvider {
+	execute(data) {
+		const level = this.getLogLevel();
+		const userLevel = LogLevel[data.level];
+		if (level > userLevel) return;
+		const [error, formattedMessage] = require_lib_errors_index.mightThrowSync(() => {
+			const { formatter } = this.options;
+			return formatter?.format(data) ?? "";
+		});
+		if (error && error instanceof Error) {
+			const { formatter } = this.options;
+			console.error(formatter?.formatError(data, error));
+			return;
+		}
+		if (!formattedMessage) return;
+		switch (userLevel) {
+			case LogLevel.debug:
+				console.debug(formattedMessage);
+				break;
+			case LogLevel.info:
+				console.info(formattedMessage);
+				break;
+			case LogLevel.warning:
+				console.warn(formattedMessage);
+				break;
+			case LogLevel.error:
+				console.error(formattedMessage);
+				break;
+			case LogLevel.critical:
+				console.error(formattedMessage);
+				break;
+			default:
+				console.debug(formattedMessage);
+				break;
+		}
+	}
+};
+//#endregion
+exports.AbstractLogger = AbstractLogger;
+exports.BaseFormatter = BaseFormatter;
+exports.ConsoleProvider = ConsoleProvider;
+exports.FileProvider = FileProvider;
+exports.Formatter = Formatter;
+exports.JSONFormatter = JSONFormatter;
+exports.LogLevel = LogLevel;
+exports.Logger = Logger;
+exports.LoggerProvider = LoggerProvider;
+exports.dmyFormat = dmyFormat;
+exports.isoDateFormat = isoDateFormat;
+exports.isoDateTimeFormat = isoDateTimeFormat;
+exports.mdyFormat = mdyFormat;

package/dist/lib/logging/index.d.cts

@@ -1,7 +1,108 @@
-import { LogDataType, LogLevel, LogLevelType, LogMessageType } from "../../logging/core/types.cjs";
-import { DateFmtFnType } from "../../logging/formatter/types.cjs";
-import { BaseFormatter, Formatter, JSONFormatter, dmyFormat, isoDateFormat, isoDateTimeFormat, mdyFormat } from "../../logging/formatter/index.cjs";
-import { FileProviderOptions, ProviderOptions, SizeBasedPolicyType, TimeBasedPolicyType } from "../../logging/provider/types.cjs";
-import { ConsoleProvider, FileProvider, LoggerProvider } from "../../logging/provider/index.cjs";
-import { AbstractLogger, Logger } from "../../logging/core/index.cjs";
+//#region src/lib/logging/core/types.d.ts
+declare const LogLevel: {
+  readonly debug: 10;
+  readonly info: 20;
+  readonly warning: 30;
+  readonly error: 40;
+  readonly critical: 50;
+};
+type LogLevelType = keyof typeof LogLevel;
+type LogMessageType = string | object | number | boolean;
+type LogDataType = {
+  prefix: string;
+  level: LogLevelType;
+  msg: LogMessageType;
+  row?: string;
+  column?: string;
+  fileName?: string;
+  method?: string;
+};
+//#endregion
+//#region src/lib/logging/formatter/types.d.ts
+type DateFmtFnType = () => string;
+//#endregion
+//#region src/lib/logging/formatter/index.d.ts
+declare abstract class Formatter {
+  protected dateFmt: DateFmtFnType;
+  constructor(dateFmt: DateFmtFnType);
+  abstract format(logData: LogDataType): string;
+  abstract formatError(logData: LogDataType, error: Error): string;
+}
+declare class BaseFormatter extends Formatter {
+  constructor(dateFmt?: DateFmtFnType);
+  format(logData: LogDataType): string;
+  formatError(logData: LogDataType, error: Error): string;
+}
+declare class JSONFormatter extends Formatter {
+  constructor(dateFmt?: DateFmtFnType);
+  format(logData: LogDataType): string;
+  formatError(logData: LogDataType, error: Error): string;
+}
+declare function isoDateTimeFormat(): string;
+declare function isoDateFormat(): string;
+declare function dmyFormat(): string;
+declare function mdyFormat(): string;
+//#endregion
+//#region src/lib/logging/provider/types.d.ts
+type ProviderOptions = {
+  level?: LogLevelType;
+  formatter?: Formatter;
+};
+interface SizeBasedPolicyType {
+  type: "size";
+  maxSize?: number;
+}
+interface TimeBasedPolicyType {
+  type: "time";
+  instant: "hour" | "day" | "week" | "month";
+  duration: number;
+}
+type FileProviderOptions = ProviderOptions & {
+  policy?: SizeBasedPolicyType | TimeBasedPolicyType;
+};
+//#endregion
+//#region src/lib/logging/provider/index.d.ts
+declare abstract class LoggerProvider {
+  protected options: ProviderOptions;
+  constructor(options?: ProviderOptions);
+  abstract execute(data: LogDataType): void;
+  getLogLevel(): number;
+}
+declare class FileProvider extends LoggerProvider {
+  private readonly filePath;
+  private counter;
+  private file;
+  private policy?;
+  constructor(file: string, options?: FileProviderOptions);
+  execute(data: LogDataType): void;
+  private canRollFile;
+  private getFileSize;
+  private isJSONFile;
+  private createNewFileName;
+}
+declare class ConsoleProvider extends LoggerProvider {
+  execute(data: LogDataType): void;
+}
+//#endregion
+//#region src/lib/logging/core/index.d.ts
+declare abstract class AbstractLogger {
+  protected providers: LoggerProvider[];
+  protected prefix: string;
+  constructor(prefix: string, providers: [LoggerProvider, ...LoggerProvider[]]);
+  abstract debug(msg: LogMessageType): void;
+  abstract info(msg: LogMessageType): void;
+  abstract warning(msg: LogMessageType): void;
+  abstract error(msg: LogMessageType): void;
+  abstract critical(msg: LogMessageType): void;
+  protected createLogData(level: LogLevelType, msg: LogMessageType, prefix: string): LogDataType;
+}
+declare class Logger extends AbstractLogger {
+  debug(msg: LogMessageType): void;
+  info(msg: LogMessageType): void;
+  warning(msg: LogMessageType): void;
+  error(msg: LogMessageType): void;
+  critical(msg: LogMessageType): void;
+  private run;
+}
+//#endregion
 export { AbstractLogger, BaseFormatter, ConsoleProvider, type DateFmtFnType, FileProvider, type FileProviderOptions, Formatter, JSONFormatter, type LogDataType, LogLevel, type LogLevelType, type LogMessageType, Logger, LoggerProvider, type ProviderOptions, type SizeBasedPolicyType, type TimeBasedPolicyType, dmyFormat, isoDateFormat, isoDateTimeFormat, mdyFormat };