windmill-cli 1.475.0 → 1.476.0

package/types/deps/jsr.io/@std/log/0.224.14/logger.d.ts

@@ -1,622 +0,0 @@
-import type { LevelName, LogLevel } from "./levels.js";
-import type { BaseHandler } from "./base_handler.js";
-/** Any function that can be called with any arguments and return any value. */
-export type GenericFunction = (...args: any[]) => any;
-/**
- * Options for {@linkcode LogRecord}.
- */
-export interface LogRecordOptions {
-    /** The message to log. */
-    msg: string;
-    /** The arguments to log. */
-    args: unknown[];
-    /** The log level of the message. */
-    level: LogLevel;
-    /** The name of the logger that created the log record. */
-    loggerName: string;
-}
-/**
- * Configuration options for a logger instance.
- *
- * @example Usage
- *
- * ```ts
- * import { ConsoleHandler, getLogger, setup, type LogConfig} from "@std/log";
- * import { assert } from "@std/assert";
- *
- * const handler = new ConsoleHandler("INFO");
- * const logConfig: LogConfig = {
- *     handlers: {
- *         default: handler,
- *     },
- *     loggers: {
- *         default: {
- *             level: "INFO",
- *             handlers: ["default"],
- *         },
- *     },
- * }
- * setup(logConfig);
- * const logger = getLogger();
- *
- * assert(logger.handlers.at(0) instanceof ConsoleHandler);
- * ```
- */
-export declare class LoggerConfig {
-    /** The minimum log level for the logger.
-     *
-     * @example Usage
-     *
-     * ```ts
-     * import { ConsoleHandler, getLogger, setup, type LogConfig} from "@std/log";
-     * import { assert } from "@std/assert";
-     *
-     * const handler = new ConsoleHandler("INFO");
-     * const logConfig: LogConfig = {
-     *     handlers: {
-     *         default: handler,
-     *     },
-     *     loggers: {
-     *         default: {
-     *             level: "INFO",
-     *             handlers: ["default"],
-     *         },
-     *     },
-     * }
-     * setup(logConfig);
-     * const logger = getLogger();
-     *
-     * assert(logger.handlers.at(0) instanceof ConsoleHandler);
-     * ```
-     */
-    level?: LevelName;
-    /** A list of handler names attached to this logger.
-     *
-     * @example Usage
-     *
-     * ```ts
-     * import { ConsoleHandler, getLogger, setup, type LogConfig} from "@std/log";
-     * import { assert } from "@std/assert";
-     *
-     * const handler = new ConsoleHandler("INFO");
-     * const logConfig: LogConfig = {
-     *     handlers: {
-     *         default: handler,
-     *     },
-     *     loggers: {
-     *         default: {
-     *             level: "INFO",
-     *             handlers: ["default"],
-     *         },
-     *     },
-     * }
-     * setup(logConfig);
-     * const logger = getLogger();
-     *
-     * assert(logger.handlers.at(0) instanceof ConsoleHandler);
-     * ``` */
-    handlers?: string[];
-}
-/**
- * Configuration for logger setup.
- */
-export interface LogConfig {
-    /** A dictionary of named handlers for logging. */
-    handlers?: {
-        [name: string]: BaseHandler;
-    };
-    /** A dictionary of named loggers and their configurations. */
-    loggers?: {
-        [name: string]: LoggerConfig;
-    };
-}
-/**
- * An object that encapsulates provided message and arguments as well some
- * metadata that can be later used when formatting a message.
- *
- * @example Usage
- * ```ts
- * import { LogRecord } from "@std/log/logger";
- * import { LogLevels } from "@std/log/levels";
- * import { assertEquals } from "@std/assert/equals";
- *
- * const record = new LogRecord({
- *   msg: "Hello, world!",
- *   args: ["foo", "bar"],
- *   level: LogLevels.INFO,
- *   loggerName: "example",
- * });
- *
- * assertEquals(record.msg, "Hello, world!");
- * assertEquals(record.args, ["foo", "bar"]);
- * assertEquals(record.level, LogLevels.INFO);
- * assertEquals(record.loggerName, "example");
- * ```
- */
-export declare class LogRecord {
-    #private;
-    /** The message to log.
-     *
-     * @example Usage
-     * ```ts
-     * import { LogRecord } from "@std/log/logger";
-     * import { LogLevels } from "@std/log/levels";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const record = new LogRecord({
-     *   msg: "Hello, world!",
-     *   args: ["foo", "bar"],
-     *   level: LogLevels.INFO,
-     *   loggerName: "example",
-     * });
-     *
-     * assertEquals(record.msg, "Hello, world!");
-     * ```
-     */
-    readonly msg: string;
-    /**
-     * The numeric log level of the log record.
-     *
-     * @example Usage
-     * ```ts
-     * import { LogRecord } from "@std/log/logger";
-     * import { LogLevels } from "@std/log/levels";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const record = new LogRecord({
-     *   msg: "Hello, world!",
-     *   args: ["foo", "bar"],
-     *   level: LogLevels.INFO,
-     *   loggerName: "example",
-     * });
-     *
-     * assertEquals(record.level, LogLevels.INFO);
-     * ```
-     */
-    readonly level: number;
-    /**
-     * The name of the log level of the log record.
-     *
-     * @example Usage
-     * ```ts
-     * import { LogRecord } from "@std/log/logger";
-     * import { LogLevels } from "@std/log/levels";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const record = new LogRecord({
-     *   msg: "Hello, world!",
-     *   args: ["foo", "bar"],
-     *   level: LogLevels.INFO,
-     *   loggerName: "example",
-     * });
-     *
-     * assertEquals(record.levelName, "INFO");
-     * ```
-     */
-    readonly levelName: string;
-    /**
-     * The name of the logger that created the log record.
-     *
-     * @example Usage
-     * ```ts
-     * import { LogRecord } from "@std/log/logger";
-     * import { LogLevels } from "@std/log/levels";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const record = new LogRecord({
-     *   msg: "Hello, world!",
-     *   args: ["foo", "bar"],
-     *   level: LogLevels.INFO,
-     *   loggerName: "example",
-     * });
-     *
-     * assertEquals(record.loggerName, "example");
-     * ```
-     */
-    readonly loggerName: string;
-    /**
-     * Constructs a new instance.
-     *
-     * @param options The options to create a new log record.
-     *
-     * @example Usage
-     * ```ts
-     * import { LogRecord } from "@std/log/logger";
-     * import { LogLevels } from "@std/log/levels";
-     *
-     * const record = new LogRecord({
-     *   msg: "Hello, world!",
-     *   args: ["foo", "bar"],
-     *   level: LogLevels.INFO,
-     *   loggerName: "example",
-     * });
-     * ```
-     */
-    constructor(options: LogRecordOptions);
-    /**
-     * Getter for the arguments to log.
-     *
-     * @example Usage
-     * ```ts
-     * import { LogRecord } from "@std/log/logger";
-     * import { LogLevels } from "@std/log/levels";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const record = new LogRecord({
-     *   msg: "Hello, world!",
-     *   args: ["foo", "bar"],
-     *   level: LogLevels.INFO,
-     *   loggerName: "example",
-     * });
-     *
-     * assertEquals(record.args, ["foo", "bar"]);
-     * ```
-     *
-     * @returns A copy of the arguments to log.
-     */
-    get args(): unknown[];
-    /**
-     * Getter for the date and time the log record was created.
-     *
-     * @example Usage
-     * ```ts
-     * import { LogRecord } from "@std/log/logger";
-     * import { LogLevels } from "@std/log/levels";
-     * import { assertAlmostEquals } from "@std/assert/almost-equals";
-     *
-     * const record = new LogRecord({
-     *   msg: "Hello, world!",
-     *   args: ["foo", "bar"],
-     *   level: LogLevels.INFO,
-     *   loggerName: "example",
-     * });
-     *
-     * assertAlmostEquals(record.datetime.getTime(), Date.now(), 1);
-     * ```
-     *
-     * @returns The date and time the log record was created.
-     */
-    get datetime(): Date;
-}
-/** Options for {@linkcode Logger}. */
-export interface LoggerOptions {
-    /** The handlers to use for the logger. */
-    handlers?: BaseHandler[];
-}
-/**
- * A logger that can log messages at different levels.
- *
- * @example Usage
- * ```ts
- * import { Logger } from "@std/log/logger";
- * import { assertEquals } from "@std/assert/equals";
- *
- * const logger = new Logger("example", "INFO");
- * const result = logger.info("Hello, world!");
- *
- * assertEquals(result, "Hello, world!");
- * ```
- */
-export declare class Logger {
-    #private;
-    /**
-     * The handlers to use for the logger.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { ConsoleHandler } from "@std/log/console-handler";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const handler = new ConsoleHandler("INFO");
-     * const logger = new Logger("example", "INFO", {
-     *  handlers: [handler],
-     * });
-     *
-     * assertEquals(logger.handlers, [handler]);
-     * ```
-     */
-    handlers: BaseHandler[];
-    /**
-     * Constructs a new instance.
-     *
-     * @param loggerName The name of the logger.
-     * @param levelName The name of the log level.
-     * @param options The options to create a new logger.
-     */
-    constructor(loggerName: string, levelName: LevelName, options?: LoggerOptions);
-    /**
-     * Getter for the log level.
-     *
-     * @returns The log level.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { LogLevels } from "@std/log/levels";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     * assertEquals(logger.level, LogLevels.INFO);
-     * ```
-     */
-    get level(): LogLevel;
-    /**
-     * Setter for the log level.
-     *
-     * @param level The log level to set.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { LogLevels } from "@std/log/levels";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     * logger.level = LogLevels.DEBUG;
-     *
-     * assertEquals(logger.level, LogLevels.DEBUG);
-     * ```
-     */
-    set level(level: LogLevel);
-    /**
-     * Getter for the name of the log level.
-     *
-     * @returns The name of the log level.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     * assertEquals(logger.levelName, "INFO");
-     * ```
-     */
-    get levelName(): LevelName;
-    /**
-     * Setter for the name of the log level.
-     *
-     * @param levelName The name of the log level to set.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { LogLevels } from "@std/log/levels";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     * logger.levelName = "DEBUG";
-     *
-     * assertEquals(logger.level, LogLevels.DEBUG);
-     * ```
-     */
-    set levelName(levelName: LevelName);
-    /**
-     * Getter for the name of the logger.
-     *
-     * @returns The name of the logger.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     *
-     * assertEquals(logger.loggerName, "example");
-     * ```
-     */
-    get loggerName(): string;
-    /**
-     * Log at the debug level.
-     *
-     * @template T The type of the message to log.
-     * @param msg The message to log.
-     * @param args Arguments to be formatted into the message.
-     * @returns The message that was logged.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     *
-     * assertEquals(logger.debug("Hello, world!"), "Hello, world!");
-     *
-     * assertEquals(logger.debug(() => "Hello, world!"), undefined);
-     * ```
-     */
-    debug<T>(msg: () => T, ...args: unknown[]): T | undefined;
-    /**
-     * Log at the debug level.
-     *
-     * @template T The type of the message to log.
-     * @param msg The message to log.
-     * @param args Arguments to be formatted into the message.
-     * @returns The message that was logged.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     *
-     * assertEquals(logger.debug("Hello, world!"), "Hello, world!");
-     *
-     * assertEquals(logger.debug(() => "Hello, world!"), undefined);
-     * ```
-     */
-    debug<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
-    /**
-     * Log at the info level.
-     *
-     * @template T The type of the message to log.
-     * @param msg The message to log.
-     * @param args Arguments to be formatted into the message.
-     * @returns The message that was logged.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     *
-     * assertEquals(logger.info("Hello, world!"), "Hello, world!");
-     *
-     * assertEquals(logger.info(() => "Hello, world!"), "Hello, world!");
-     * ```
-     */
-    info<T>(msg: () => T, ...args: unknown[]): T | undefined;
-    /**
-     * Log at the info level.
-     *
-     * @template T The type of the message to log.
-     * @param msg The message to log.
-     * @param args Arguments to be formatted into the message.
-     * @returns The message that was logged.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     *
-     * assertEquals(logger.info("Hello, world!"), "Hello, world!");
-     *
-     * assertEquals(logger.info(() => "Hello, world!"), "Hello, world!");
-     * ```
-     */
-    info<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
-    /**
-     * Log at the warning level.
-     *
-     * @template T The type of the message to log.
-     * @param msg The message to log.
-     * @param args Arguments to be formatted into the message.
-     * @returns The message that was logged.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     *
-     * assertEquals(logger.warn("Hello, world!"), "Hello, world!");
-     *
-     * assertEquals(logger.warn(() => "Hello, world!"), "Hello, world!");
-     * ```
-     */
-    warn<T>(msg: () => T, ...args: unknown[]): T | undefined;
-    /**
-     * Log at the warning level.
-     *
-     * @template T The type of the message to log.
-     * @param msg The message to log.
-     * @param args Arguments to be formatted into the message.
-     * @returns The message that was logged.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     *
-     * assertEquals(logger.warn("Hello, world!"), "Hello, world!");
-     *
-     * assertEquals(logger.warn(() => "Hello, world!"), "Hello, world!");
-     * ```
-     */
-    warn<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
-    /**
-     * Log at the error level.
-     *
-     * @template T The type of the message to log.
-     * @param msg The message to log.
-     * @param args Arguments to be formatted into the message.
-     * @returns The message that was logged.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     *
-     * assertEquals(logger.error("Hello, world!"), "Hello, world!");
-     *
-     * assertEquals(logger.error(() => "Hello, world!"), "Hello, world!");
-     * ```
-     */
-    error<T>(msg: () => T, ...args: unknown[]): T | undefined;
-    /**
-     * Log at the error level.
-     *
-     * @template T The type of the message to log.
-     * @param msg The message to log.
-     * @param args Arguments to be formatted into the message.
-     * @returns The message that was logged.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     *
-     * assertEquals(logger.error("Hello, world!"), "Hello, world!");
-     *
-     * assertEquals(logger.error(() => "Hello, world!"), "Hello, world!");
-     * ```
-     */
-    error<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
-    /**
-     * Log at the critical level.
-     *
-     * @template T The type of the message to log.
-     * @param msg The message to log.
-     * @param args Arguments to be formatted into the message.
-     * @returns The message that was logged.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     *
-     * assertEquals(logger.critical("Hello, world!"), "Hello, world!");
-     *
-     * assertEquals(logger.critical(() => "Hello, world!"), "Hello, world!");
-     * ```
-     */
-    critical<T>(msg: () => T, ...args: unknown[]): T | undefined;
-    /**
-     * Log at the critical level.
-     *
-     * @template T The type of the message to log.
-     * @param msg The message to log.
-     * @param args Arguments to be formatted into the message.
-     * @returns The message that was logged.
-     *
-     * @example Usage
-     * ```ts
-     * import { Logger } from "@std/log/logger";
-     * import { assertEquals } from "@std/assert/equals";
-     *
-     * const logger = new Logger("example", "INFO");
-     *
-     * assertEquals(logger.critical("Hello, world!"), "Hello, world!");
-     *
-     * assertEquals(logger.critical(() => "Hello, world!"), "Hello, world!");
-     * ```
-     */
-    critical<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
-}
-//# sourceMappingURL=logger.d.ts.map

package/types/deps/jsr.io/@std/log/0.224.14/logger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/logger.ts"],"names":[],"mappings":"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"}

package/types/deps/jsr.io/@std/log/0.224.14/mod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/mod.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0XG;AAEH,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}

package/types/deps/jsr.io/@std/log/0.224.14/rotating_file_handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rotating_file_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/rotating_file_handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AASzE,UAAU,0BAA2B,SAAQ,kBAAkB;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;;gBAKtC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,0BAA0B;IAM5D,KAAK;IAyCL,GAAG,CAAC,GAAG,EAAE,MAAM;IAaxB,cAAc;CAkBf"}

package/types/deps/jsr.io/@std/log/0.224.14/setup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/setup.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,SAAS,EAAU,MAAM,aAAa,CAAC;AAGrD,2BAA2B;AAC3B,wBAAgB,KAAK,CAAC,MAAM,EAAE,SAAS,QAwCtC"}

package/types/deps/jsr.io/@std/log/0.224.14/warn.d.ts

@@ -1,53 +0,0 @@
-import type { GenericFunction } from "./logger.js";
-import "./setup.js";
-export type { GenericFunction };
-/**
- * Log at the warning level.
- *
- * This function is a pass-through to the default logger's `warn` method. By
- * default, the default logger is configured to use {@linkcode console.log} and
- * print in yellow text.
- *
- * @template T The type of the message to log.
- * @param msg The message to log.
- * @param args Arguments to be formatted into the message.
- * @returns The message that was logged.
- *
- * @example Usage
- * ```ts
- * import { warn } from "@std/log/warn";
- * import { assertEquals } from "@std/assert/equals";
- *
- * assertEquals(warn("This is a warning message."), "This is a warning message.");
- * // Prints: "WARN This is a warning message."
- *
- * assertEquals(warn(() => "This is a warning message."), "This is a warning message.");
- * // Prints: "WARN This is a warning message."
- * ```
- */
-export declare function warn<T>(msg: () => T, ...args: unknown[]): T | undefined;
-/**
- * Log at the warning level.
- *
- * This function is a pass-through to the default logger's `warn` method. By
- * default, the default logger is configured to use {@linkcode console.log}.
- *
- * @template T The type of the message to log.
- * @param msg The message to log.
- * @param args Arguments to be formatted into the message.
- * @returns The message that was logged.
- *
- * @example Usage
- * ```ts
- * import { warn } from "@std/log/warn";
- * import { assertEquals } from "@std/assert/equals";
- *
- * assertEquals(warn("This is a warning message."), "This is a warning message.");
- * // Prints: "WARN This is a warning message."
- *
- * assertEquals(warn(() => "This is a warning message."), "This is a warning message.");
- * // Prints: "WARN This is a warning message."
- * ```
- */
-export declare function warn<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
-//# sourceMappingURL=warn.d.ts.map

package/types/deps/jsr.io/@std/log/0.224.14/warn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"warn.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/warn.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,YAAY,CAAC;AAEpB,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;AACzE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,GAAG,EAAE,CAAC,SAAS,eAAe,GAAG,KAAK,GAAG,CAAC,EAC1C,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,CAAC,CAAC"}