@larablox/monolog 0.1.0

package/out/Monolog/Handler/TestHandler.luau

@@ -0,0 +1,288 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local AbstractProcessingHandler = TS.import(script, script.Parent, "AbstractProcessingHandler").AbstractProcessingHandler
+local Level = TS.import(script, script.Parent.Parent, "Level").Level
+local Logger = TS.import(script, script.Parent.Parent, "Logger").Logger
+--* PHP: the `array{message: string, context?: mixed[]}` shape `hasRecord()` accepts. 
+--* PHP: the `callable(LogRecord, int): mixed $predicate` shape `hasRecordThatPasses()` accepts. 
+--* Deep-equality check for two context/extra bags -- PHP's `!==` on arrays compares recursively. 
+local function bagsEqual(a, b)
+	if a == b then
+		return true
+	end
+	local _a = a
+	local _condition = not (type(_a) == "table")
+	if not _condition then
+		local _b = b
+		_condition = not (type(_b) == "table")
+	end
+	if _condition then
+		return false
+	end
+	local aBag = a
+	local bBag = b
+	local seen = {}
+	for key, value in pairs(aBag) do
+		local stringKey = tostring(key)
+		seen[stringKey] = true
+		if not bagsEqual(value, bBag[stringKey]) then
+			return false
+		end
+	end
+	for key in pairs(bBag) do
+		local _arg0 = tostring(key)
+		if not (seen[_arg0] ~= nil) then
+			return false
+		end
+	end
+	return true
+end
+--[[
+	*
+	 * PHP: `Monolog\Handler\TestHandler`.
+	 *
+	 * Ships in Monolog's real (non-dev) autoload, not `autoload-dev`, because
+	 * library consumers use it in their own tests -- the same reason this port
+	 * carries it under `src/Monolog/Handler` rather than `tests/`, and the same
+	 * justification already made for `Monolog\Test\MonologTestCase`.
+	 *
+	 * Upstream's per-level shorthands (`hasWarning()`, `hasWarningRecords()`,
+	 * `hasWarningThatContains()`, `hasWarningThatMatches()`,
+	 * `hasWarningThatPasses()`, one set per `Level` case) are dispatched through
+	 * PHP's `__call` magic method: it regex-matches the requested method name
+	 * apart into a level name and a generic method name, then redirects to the
+	 * matching `hasRecord*()` method with the parsed `Level` appended. Luau has
+	 * no dynamic method dispatch to replicate that with, so every shorthand is
+	 * spelled out explicitly below instead -- one small delegating method per
+	 * level per kind, same names, same behavior.
+	 *
+	 * `hasRecordThatMatches()`/the `*ThatMatches()` shorthands use Luau string
+	 * patterns (`string.match`) rather than upstream's PCRE (`preg_match`) --
+	 * there is no PCRE engine on this platform. Pattern syntax differs
+	 * (`%d`/`%a`/... instead of `\d`/`\w`/...); callers passing a `regex` should
+	 * pass a Lua pattern, not a PCRE one.
+	 
+]]
+local TestHandler
+do
+	local super = AbstractProcessingHandler
+	TestHandler = setmetatable({}, {
+		__tostring = function()
+			return "TestHandler"
+		end,
+		__index = super,
+	})
+	TestHandler.__index = TestHandler
+	function TestHandler.new(...)
+		local self = setmetatable({}, TestHandler)
+		return self:constructor(...) or self
+	end
+	function TestHandler:constructor(...)
+		super.constructor(self, ...)
+		self.records = {}
+		self.recordsByLevel = {}
+		self.skipReset = false
+	end
+	function TestHandler:getRecords()
+		return self.records
+	end
+	function TestHandler:clear()
+		self.records = {}
+		self.recordsByLevel = {}
+	end
+	function TestHandler:reset()
+		if not self.skipReset then
+			self:clear()
+		end
+	end
+	function TestHandler:setSkipReset(skipReset)
+		self.skipReset = skipReset
+	end
+	function TestHandler:hasRecords(level)
+		local _recordsByLevel = self.recordsByLevel
+		local _arg0 = Logger:toMonologLevel(level)
+		return _recordsByLevel[_arg0] ~= nil
+	end
+	function TestHandler:hasRecord(recordAssertions, level)
+		local _recordAssertions = recordAssertions
+		local assertions = if type(_recordAssertions) == "string" then {
+			message = recordAssertions,
+		} else recordAssertions
+		return self:hasRecordThatPasses(function(record)
+			if record.message ~= assertions.message then
+				return false
+			end
+			if assertions.context ~= nil and not bagsEqual(record.context, assertions.context) then
+				return false
+			end
+			return true
+		end, level)
+	end
+	function TestHandler:hasRecordThatContains(message, level)
+		return self:hasRecordThatPasses(function(record)
+			local _message = record.message
+			local _message_1 = message
+			return (string.find(_message, _message_1, 1, true)) ~= nil
+		end, level)
+	end
+	function TestHandler:hasRecordThatMatches(regex, level)
+		return self:hasRecordThatPasses(function(record)
+			local _message = record.message
+			local _regex = regex
+			return (string.match(_message, _regex)) ~= nil
+		end, level)
+	end
+	function TestHandler:hasRecordThatPasses(predicate, level)
+		local resolvedLevel = Logger:toMonologLevel(level)
+		local records = self.recordsByLevel[resolvedLevel]
+		if records == nil then
+			return false
+		end
+		for index = 0, #records - 1 do
+			if predicate(records[index + 1], index) then
+				return true
+			end
+		end
+		return false
+	end
+	function TestHandler:write(record)
+		local _recordsByLevel = self.recordsByLevel
+		local _level = record.level
+		local _condition = _recordsByLevel[_level]
+		if _condition == nil then
+			_condition = {}
+		end
+		local byLevel = _condition
+		local _record = record
+		table.insert(byLevel, _record)
+		local _recordsByLevel_1 = self.recordsByLevel
+		local _level_1 = record.level
+		_recordsByLevel_1[_level_1] = byLevel
+		local _records = self.records
+		local _record_1 = record
+		table.insert(_records, _record_1)
+	end
+	function TestHandler:hasEmergencyRecords()
+		return self:hasRecords(Level.Emergency)
+	end
+	function TestHandler:hasEmergency(recordAssertions)
+		return self:hasRecord(recordAssertions, Level.Emergency)
+	end
+	function TestHandler:hasEmergencyThatContains(message)
+		return self:hasRecordThatContains(message, Level.Emergency)
+	end
+	function TestHandler:hasEmergencyThatMatches(regex)
+		return self:hasRecordThatMatches(regex, Level.Emergency)
+	end
+	function TestHandler:hasEmergencyThatPasses(predicate)
+		return self:hasRecordThatPasses(predicate, Level.Emergency)
+	end
+	function TestHandler:hasAlertRecords()
+		return self:hasRecords(Level.Alert)
+	end
+	function TestHandler:hasAlert(recordAssertions)
+		return self:hasRecord(recordAssertions, Level.Alert)
+	end
+	function TestHandler:hasAlertThatContains(message)
+		return self:hasRecordThatContains(message, Level.Alert)
+	end
+	function TestHandler:hasAlertThatMatches(regex)
+		return self:hasRecordThatMatches(regex, Level.Alert)
+	end
+	function TestHandler:hasAlertThatPasses(predicate)
+		return self:hasRecordThatPasses(predicate, Level.Alert)
+	end
+	function TestHandler:hasCriticalRecords()
+		return self:hasRecords(Level.Critical)
+	end
+	function TestHandler:hasCritical(recordAssertions)
+		return self:hasRecord(recordAssertions, Level.Critical)
+	end
+	function TestHandler:hasCriticalThatContains(message)
+		return self:hasRecordThatContains(message, Level.Critical)
+	end
+	function TestHandler:hasCriticalThatMatches(regex)
+		return self:hasRecordThatMatches(regex, Level.Critical)
+	end
+	function TestHandler:hasCriticalThatPasses(predicate)
+		return self:hasRecordThatPasses(predicate, Level.Critical)
+	end
+	function TestHandler:hasErrorRecords()
+		return self:hasRecords(Level.Error)
+	end
+	function TestHandler:hasError(recordAssertions)
+		return self:hasRecord(recordAssertions, Level.Error)
+	end
+	function TestHandler:hasErrorThatContains(message)
+		return self:hasRecordThatContains(message, Level.Error)
+	end
+	function TestHandler:hasErrorThatMatches(regex)
+		return self:hasRecordThatMatches(regex, Level.Error)
+	end
+	function TestHandler:hasErrorThatPasses(predicate)
+		return self:hasRecordThatPasses(predicate, Level.Error)
+	end
+	function TestHandler:hasWarningRecords()
+		return self:hasRecords(Level.Warning)
+	end
+	function TestHandler:hasWarning(recordAssertions)
+		return self:hasRecord(recordAssertions, Level.Warning)
+	end
+	function TestHandler:hasWarningThatContains(message)
+		return self:hasRecordThatContains(message, Level.Warning)
+	end
+	function TestHandler:hasWarningThatMatches(regex)
+		return self:hasRecordThatMatches(regex, Level.Warning)
+	end
+	function TestHandler:hasWarningThatPasses(predicate)
+		return self:hasRecordThatPasses(predicate, Level.Warning)
+	end
+	function TestHandler:hasNoticeRecords()
+		return self:hasRecords(Level.Notice)
+	end
+	function TestHandler:hasNotice(recordAssertions)
+		return self:hasRecord(recordAssertions, Level.Notice)
+	end
+	function TestHandler:hasNoticeThatContains(message)
+		return self:hasRecordThatContains(message, Level.Notice)
+	end
+	function TestHandler:hasNoticeThatMatches(regex)
+		return self:hasRecordThatMatches(regex, Level.Notice)
+	end
+	function TestHandler:hasNoticeThatPasses(predicate)
+		return self:hasRecordThatPasses(predicate, Level.Notice)
+	end
+	function TestHandler:hasInfoRecords()
+		return self:hasRecords(Level.Info)
+	end
+	function TestHandler:hasInfo(recordAssertions)
+		return self:hasRecord(recordAssertions, Level.Info)
+	end
+	function TestHandler:hasInfoThatContains(message)
+		return self:hasRecordThatContains(message, Level.Info)
+	end
+	function TestHandler:hasInfoThatMatches(regex)
+		return self:hasRecordThatMatches(regex, Level.Info)
+	end
+	function TestHandler:hasInfoThatPasses(predicate)
+		return self:hasRecordThatPasses(predicate, Level.Info)
+	end
+	function TestHandler:hasDebugRecords()
+		return self:hasRecords(Level.Debug)
+	end
+	function TestHandler:hasDebug(recordAssertions)
+		return self:hasRecord(recordAssertions, Level.Debug)
+	end
+	function TestHandler:hasDebugThatContains(message)
+		return self:hasRecordThatContains(message, Level.Debug)
+	end
+	function TestHandler:hasDebugThatMatches(regex)
+		return self:hasRecordThatMatches(regex, Level.Debug)
+	end
+	function TestHandler:hasDebugThatPasses(predicate)
+		return self:hasRecordThatPasses(predicate, Level.Debug)
+	end
+end
+return {
+	TestHandler = TestHandler,
+}

package/out/Monolog/Level.d.ts

@@ -0,0 +1,38 @@
+/**
+ * PHP: `Monolog\Level`, a backed enum.
+ *
+ * TypeScript enums carry no statics and roblox-ts does not merge namespaces, so
+ * `Level::fromName()` and friends live on `Levels` beside the enum.
+ */
+export declare enum Level {
+    Debug = 100,
+    Info = 200,
+    Notice = 250,
+    Warning = 300,
+    Error = 400,
+    Critical = 500,
+    Alert = 550,
+    Emergency = 600
+}
+export declare class Levels {
+    /** PHP: `Level::VALUES`. */
+    static readonly VALUES: Array<Level>;
+    /** PHP: `Level::NAMES`. */
+    static readonly NAMES: Array<string>;
+    /** PHP: `Level::fromName()`. */
+    static fromName(name: string): Level | undefined;
+    /** PHP: `Level::fromValue()`. */
+    static fromValue(value: number): Level | undefined;
+    /** PHP: `Level->getName()`. */
+    static getName(level: Level): string;
+    /** PHP: `Level->toPsrLogLevel()`. */
+    static toPsrLogLevel(level: Level): string;
+    /** PHP: `Level->toRFC5424Level()`. */
+    static toRFC5424Level(level: Level): number;
+    /** PHP: `Level->includes()` -- true when the given level is at least this one. */
+    static includes(level: Level, other: Level): boolean;
+    /** PHP: `Level->isHigherThan()`. */
+    static isHigherThan(level: Level, other: Level): boolean;
+    /** PHP: `Level->isLowerThan()`. */
+    static isLowerThan(level: Level, other: Level): boolean;
+}

package/out/Monolog/Level.luau

@@ -0,0 +1,119 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * PHP: `Monolog\Level`, a backed enum.
+	 *
+	 * TypeScript enums carry no statics and roblox-ts does not merge namespaces, so
+	 * `Level::fromName()` and friends live on `Levels` beside the enum.
+	 
+]]
+local Level
+do
+	local _inverse = {}
+	Level = setmetatable({}, {
+		__index = _inverse,
+	})
+	Level.Debug = 100
+	_inverse[100] = "Debug"
+	Level.Info = 200
+	_inverse[200] = "Info"
+	Level.Notice = 250
+	_inverse[250] = "Notice"
+	Level.Warning = 300
+	_inverse[300] = "Warning"
+	Level.Error = 400
+	_inverse[400] = "Error"
+	Level.Critical = 500
+	_inverse[500] = "Critical"
+	Level.Alert = 550
+	_inverse[550] = "Alert"
+	Level.Emergency = 600
+	_inverse[600] = "Emergency"
+end
+local BY_NAME = {
+	debug = Level.Debug,
+	info = Level.Info,
+	notice = Level.Notice,
+	warning = Level.Warning,
+	error = Level.Error,
+	critical = Level.Critical,
+	alert = Level.Alert,
+	emergency = Level.Emergency,
+}
+local BY_VALUE = {
+	[Level.Debug] = "DEBUG",
+	[Level.Info] = "INFO",
+	[Level.Notice] = "NOTICE",
+	[Level.Warning] = "WARNING",
+	[Level.Error] = "ERROR",
+	[Level.Critical] = "CRITICAL",
+	[Level.Alert] = "ALERT",
+	[Level.Emergency] = "EMERGENCY",
+}
+local BY_RFC5424 = {
+	[Level.Debug] = 7,
+	[Level.Info] = 6,
+	[Level.Notice] = 5,
+	[Level.Warning] = 4,
+	[Level.Error] = 3,
+	[Level.Critical] = 2,
+	[Level.Alert] = 1,
+	[Level.Emergency] = 0,
+}
+local Levels
+do
+	Levels = setmetatable({}, {
+		__tostring = function()
+			return "Levels"
+		end,
+	})
+	Levels.__index = Levels
+	function Levels.new(...)
+		local self = setmetatable({}, Levels)
+		return self:constructor(...) or self
+	end
+	function Levels:constructor()
+	end
+	function Levels:fromName(name)
+		local _arg0 = string.lower(name)
+		return BY_NAME[_arg0]
+	end
+	function Levels:fromValue(value)
+		local _value = value
+		return if BY_VALUE[_value] ~= nil then value else nil
+	end
+	function Levels:getName(level)
+		local _level = level
+		local _condition = BY_VALUE[_level]
+		if _condition == nil then
+			_condition = "DEBUG"
+		end
+		return _condition
+	end
+	function Levels:toPsrLogLevel(level)
+		return string.lower(Levels:getName(level))
+	end
+	function Levels:toRFC5424Level(level)
+		local _level = level
+		local _condition = BY_RFC5424[_level]
+		if _condition == nil then
+			_condition = 7
+		end
+		return _condition
+	end
+	function Levels:includes(level, other)
+		return level <= other
+	end
+	function Levels:isHigherThan(level, other)
+		return level > other
+	end
+	function Levels:isLowerThan(level, other)
+		return level < other
+	end
+	Levels.VALUES = { Level.Debug, Level.Info, Level.Notice, Level.Warning, Level.Error, Level.Critical, Level.Alert, Level.Emergency }
+	Levels.NAMES = { "DEBUG", "INFO", "NOTICE", "WARNING", "ERROR", "CRITICAL", "ALERT", "EMERGENCY" }
+end
+return {
+	Level = Level,
+	Levels = Levels,
+}

package/out/Monolog/LogRecord.d.ts

@@ -0,0 +1,43 @@
+import { Level } from "./Level";
+/** PHP: `array<mixed>` for context and extra. */
+export type RecordBag = Record<string, unknown>;
+/**
+ * PHP: `Monolog\LogRecord`.
+ *
+ * `datetime` is a Unix timestamp rather than a `DateTimeImmutable`; there is no
+ * date/time object on this platform. `ArrayAccess` is not ported.
+ */
+export declare class LogRecord {
+    readonly datetime: number;
+    readonly channel: string;
+    readonly level: Level;
+    readonly message: string;
+    readonly context: RecordBag;
+    extra: RecordBag;
+    formatted?: string | undefined;
+    constructor(datetime: number, channel: string, level: Level, message: string, context?: RecordBag, extra?: RecordBag, formatted?: string | undefined);
+    /** PHP: `LogRecord::with()`. Returns a copy with the given fields replaced. */
+    with(changes: {
+        datetime?: number;
+        channel?: string;
+        level?: Level;
+        message?: string;
+        context?: RecordBag;
+        extra?: RecordBag;
+    }): LogRecord;
+    /** PHP: `LogRecord::toArray()`. */
+    toArray(): RecordBag;
+    /**
+     * A shallow copy, as PHP's `clone` before handing a record to a handler.
+     *
+     * `extra` is copied into a new table rather than shared by reference:
+     * a PHP array is a value type, so mutating one handler's `$record->extra`
+     * (a per-handler processor commonly does exactly that) never touches a
+     * sibling handler's `clone($record)`. A Luau table has no such copy-on-
+     * write behavior -- sharing the same `extra` table across every handler's
+     * clone would let one handler's processor mutation leak into another's.
+     * `context` is `readonly` and never mutated in place, so it doesn't need
+     * the same treatment.
+     */
+    clone(): LogRecord;
+}

package/out/Monolog/LogRecord.luau

@@ -0,0 +1,77 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Levels = TS.import(script, script.Parent, "Level").Levels
+--* PHP: `array<mixed>` for context and extra. 
+--[[
+	*
+	 * PHP: `Monolog\LogRecord`.
+	 *
+	 * `datetime` is a Unix timestamp rather than a `DateTimeImmutable`; there is no
+	 * date/time object on this platform. `ArrayAccess` is not ported.
+	 
+]]
+local LogRecord
+do
+	LogRecord = setmetatable({}, {
+		__tostring = function()
+			return "LogRecord"
+		end,
+	})
+	LogRecord.__index = LogRecord
+	function LogRecord.new(...)
+		local self = setmetatable({}, LogRecord)
+		return self:constructor(...) or self
+	end
+	function LogRecord:constructor(datetime, channel, level, message, context, extra, formatted)
+		if context == nil then
+			context = {}
+		end
+		if extra == nil then
+			extra = {}
+		end
+		self.datetime = datetime
+		self.channel = channel
+		self.level = level
+		self.message = message
+		self.context = context
+		self.extra = extra
+		self.formatted = formatted
+	end
+	function LogRecord:with(changes)
+		local _condition = changes.datetime
+		if _condition == nil then
+			_condition = self.datetime
+		end
+		local _condition_1 = changes.channel
+		if _condition_1 == nil then
+			_condition_1 = self.channel
+		end
+		local _exp = changes.level or self.level
+		local _condition_2 = changes.message
+		if _condition_2 == nil then
+			_condition_2 = self.message
+		end
+		return LogRecord.new(_condition, _condition_1, _exp, _condition_2, changes.context or self.context, changes.extra or self.extra, self.formatted)
+	end
+	function LogRecord:toArray()
+		return {
+			message = self.message,
+			context = self.context,
+			level = self.level,
+			level_name = Levels:getName(self.level),
+			channel = self.channel,
+			datetime = self.datetime,
+			extra = self.extra,
+		}
+	end
+	function LogRecord:clone()
+		local extra = {}
+		for key, value in pairs(self.extra) do
+			extra[key] = value
+		end
+		return LogRecord.new(self.datetime, self.channel, self.level, self.message, self.context, extra, self.formatted)
+	end
+end
+return {
+	LogRecord = LogRecord,
+}

package/out/Monolog/Logger.d.ts

@@ -0,0 +1,93 @@
+import { Level } from "./Level";
+import { LogRecord } from "./LogRecord";
+import type { HandlerInterface } from "./Handler/HandlerInterface";
+import type { LogContext, LogLevel, LoggerInterface as LoggerContract } from "./LoggerInterface";
+import type { Processor } from "./Processor/ProcessorInterface";
+import type { RecordBag } from "./LogRecord";
+import type { ResettableInterface } from "./ResettableInterface";
+/** PHP: `Closure` passed to `Logger::setExceptionHandler()`. */
+export type LoggerExceptionHandler = (error: unknown, record: LogRecord) => void;
+/**
+ * PHP: `Monolog\Logger`.
+ *
+ * Holds the handler stack and the processor stack, builds a `LogRecord` and
+ * walks the handlers until one stops the bubbling chain.
+ *
+ * Not ported: timezones and microsecond timestamps (`os.time` is what a place
+ * has) and the serialization hooks (`__serialize`/`__unserialize`, no PHP
+ * magic serialization here). The infinite-logging-loop guard is kept, but
+ * keyed by a single instance counter rather than a `Fiber`-keyed `WeakMap` --
+ * there is no fiber concept on this platform.
+ */
+export declare class Logger implements LoggerContract, ResettableInterface {
+    protected name: string;
+    /** The handler stack. */
+    protected handlers: HandlerInterface[];
+    /** The processor stack. */
+    protected processors: Processor[];
+    /** PHP: `Logger::$exceptionHandler`. */
+    protected exceptionHandler?: LoggerExceptionHandler;
+    /** PHP: `Logger::$logDepth`. Not fiber-keyed -- see the class comment. */
+    private logDepth;
+    constructor(name: string, handlers?: Array<HandlerInterface>, processors?: Array<Processor>);
+    /** Get the logging channel name. */
+    getName(): string;
+    /** Return a new cloned instance with the name changed. */
+    withName(name: string): Logger;
+    /** Pushes a handler on to the stack. */
+    pushHandler(handler: HandlerInterface): this;
+    /** Pops a handler from the stack. */
+    popHandler(): HandlerInterface | undefined;
+    /** Set handlers, replacing all existing ones. */
+    setHandlers(handlers: Array<HandlerInterface>): this;
+    /** Get the handler stack. */
+    getHandlers(): Array<HandlerInterface>;
+    /** Adds a processor on to the stack. */
+    pushProcessor(processor: Processor): this;
+    /** Removes the processor on top of the stack and returns it. */
+    popProcessor(): Processor | undefined;
+    /** Get the processor stack. */
+    getProcessors(): Array<Processor>;
+    /** Adds a log record. */
+    addRecord(level: Level | number, message: string, context?: RecordBag): boolean;
+    /** The loop-depth-checked body of `addRecord`, split out so the counter above always unwinds. */
+    private addRecordAtDepth;
+    /**
+     * PHP: `Logger::toMonologLevel()`. Accepts a Level or a PSR level name.
+     *
+     * PHP throws `Psr\Log\InvalidArgumentException` for an unrecognized name;
+     * there is no port of that exception type, so this throws a plain error
+     * with the same message shape instead -- an unrecognized string is a
+     * caller bug (a typo'd level from outside TS's own type checking, e.g.
+     * deserialized from a string), not something to silently downgrade to
+     * `Debug`.
+     */
+    static toMonologLevel(level: Level | LogLevel): Level;
+    /** PHP: `Logger::RFC_5424_LEVELS` remap, applied in `addRecord()`/`log()` before `toMonologLevel()`. */
+    private static remapRFC5424;
+    /** Checks whether the Logger has a handler that listens on the given level. */
+    isHandling(level: Level | LogLevel): boolean;
+    /** Set a custom exception handler called if adding a new record fails. */
+    setExceptionHandler(callback?: LoggerExceptionHandler): this;
+    /** Get the custom exception handler, if any. */
+    getExceptionHandler(): LoggerExceptionHandler | undefined;
+    /**
+     * Delegates exception management to the custom exception handler, or
+     * re-raises if no custom handler is set.
+     */
+    protected handleException(error_: unknown, record: LogRecord): void;
+    /** Ends a log cycle and frees all resources used by handlers. */
+    close(): void;
+    /** Ends a log cycle and resets all handlers and processors that support it. */
+    reset(): void;
+    emergency(message: unknown, context?: LogContext): void;
+    alert(message: unknown, context?: LogContext): void;
+    critical(message: unknown, context?: LogContext): void;
+    error(message: unknown, context?: LogContext): void;
+    warning(message: unknown, context?: LogContext): void;
+    notice(message: unknown, context?: LogContext): void;
+    info(message: unknown, context?: LogContext): void;
+    debug(message: unknown, context?: LogContext): void;
+    /** Logs with an arbitrary level, named as PSR does. */
+    log(level: Level | LogLevel | number, message: unknown, context?: LogContext): void;
+}