@salesforce/core 4.0.0 → 4.0.1

package/lib/logger.js

@@ -11,14 +11,15 @@ const events_1 = require("events");
 const os = require("os");
 const path = require("path");
 const stream_1 = require("stream");
+const fs = require("fs");
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 const Bunyan = require("@salesforce/bunyan");
 const kit_1 = require("@salesforce/kit");
 const ts_types_1 = require("@salesforce/ts-types");
 const Debug = require("debug");
 const global_1 = require("./global");
-const sfdxError_1 = require("./sfdxError");
-const fs_1 = require("./util/fs");
+const sfError_1 = require("./sfError");
 /**
  * Standard `Logger` levels.
  *
@@ -34,7 +35,7 @@ var LoggerLevel;
     LoggerLevel[LoggerLevel["FATAL"] = 60] = "FATAL";
 })(LoggerLevel = exports.LoggerLevel || (exports.LoggerLevel = {}));
 /**
- *  `Logger` format types.
+ * `Logger` format types.
  */
 var LoggerFormat;
 (function (LoggerFormat) {
@@ -68,10 +69,21 @@ class Logger {
      *
      * @param optionsOrName A set of `LoggerOptions` or name to use with the default options.
      *
-     * **Throws** *{@link SfdxError}{ name: 'RedundantRootLoggerError' }* More than one attempt is made to construct the root
+     * **Throws** *{@link SfError}{ name: 'RedundantRootLoggerError' }* More than one attempt is made to construct the root
      * `Logger`.
      */
     constructor(optionsOrName) {
+        /**
+         * The default rotation period for logs. Example '1d' will rotate logs daily (at midnight).
+         * See 'period' docs here: https://github.com/forcedotcom/node-bunyan#stream-type-rotating-file
+         */
+        this.logRotationPeriod = new kit_1.Env().getString('SF_LOG_ROTATION_PERIOD') ?? '1d';
+        /**
+         * The number of backup rotated log files to keep.
+         * Example: '3' will have the base sf.log file, and the past 3 (period) log files.
+         * See 'count' docs here: https://github.com/forcedotcom/node-bunyan#stream-type-rotating-file
+         */
+        this.logRotationCount = new kit_1.Env().getNumber('SF_LOG_ROTATION_COUNT') ?? 2;
         /**
          * Whether debug is enabled for this Logger.
          */
@@ -102,11 +114,11 @@ class Logger {
             options = optionsOrName;
         }
         if (Logger.rootLogger && options.name === Logger.ROOT_NAME) {
-            throw new sfdxError_1.SfdxError('Can not create another root logger.', 'RedundantRootLoggerError');
+            throw new sfError_1.SfError('Can not create another root logger.', 'RedundantRootLoggerError');
         }
         // Inspect format to know what logging format to use then delete from options to
         // ensure it doesn't conflict with Bunyan.
-        this.format = options.format || LoggerFormat.JSON;
+        this.format = options.format ?? LoggerFormat.JSON;
         delete options.format;
         // If the log format is LOGFMT, we need to convert any stream(s) into a LOGFMT type stream.
         if (this.format === LoggerFormat.LOGFMT && options.stream) {
@@ -127,7 +139,7 @@ class Logger {
             this.bunyan.streams = [];
         }
         // all SFDX loggers must filter sensitive data
-        this.addFilter((...args) => _filter(...args));
+        this.addFilter((...args) => filterSecrets(...args));
         if (global_1.Global.getEnvironmentMode() !== global_1.Mode.TEST) {
             Logger.lifecycle.on('uncaughtException', this.uncaughtExceptionHandler);
             Logger.lifecycle.on('exit', this.exitHandler);
@@ -143,7 +155,8 @@ class Logger {
         }
         const rootLogger = (this.rootLogger = new Logger(Logger.ROOT_NAME).setLevel());
         // disable log file writing, if applicable
-        if (process.env.SFDX_DISABLE_LOG_FILE !== 'true' && global_1.Global.getEnvironmentMode() !== global_1.Mode.TEST) {
+        const disableLogFile = new kit_1.Env().getString('SF_DISABLE_LOG_FILE');
+        if (disableLogFile !== 'true' && global_1.Global.getEnvironmentMode() !== global_1.Mode.TEST) {
             await rootLogger.addLogFileStream(global_1.Global.LOG_FILE_PATH);
         }
         rootLogger.enableDEBUG();
@@ -198,13 +211,13 @@ class Logger {
      *
      * @param {string} levelName The level name to convert to a `LoggerLevel` enum value.
      *
-     * **Throws** *{@link SfdxError}{ name: 'UnrecognizedLoggerLevelNameError' }* The level name was not case-insensitively recognized as a valid `LoggerLevel` value.
+     * **Throws** *{@link SfError}{ name: 'UnrecognizedLoggerLevelNameError' }* The level name was not case-insensitively recognized as a valid `LoggerLevel` value.
      * @see {@Link LoggerLevel}
      */
     static getLevelByName(levelName) {
         levelName = levelName.toUpperCase();
         if (!(0, ts_types_1.isKeyOf)(LoggerLevel, levelName)) {
-            throw new sfdxError_1.SfdxError(`Invalid log level "${levelName}".`, 'UnrecognizedLoggerLevelNameError');
+            throw new sfError_1.SfError(`Invalid log level "${levelName}".`, 'UnrecognizedLoggerLevelNameError');
         }
         return LoggerLevel[levelName];
     }
@@ -228,34 +241,37 @@ class Logger {
     async addLogFileStream(logFile) {
         try {
             // Check if we have write access to the log file (i.e., we created it already)
-            await fs_1.fs.access(logFile, fs_1.fs.constants.W_OK);
+            await fs.promises.access(logFile, fs.constants.W_OK);
         }
         catch (err1) {
             try {
-                await fs_1.fs.mkdirp(path.dirname(logFile), {
-                    mode: fs_1.fs.DEFAULT_USER_DIR_MODE,
-                });
+                if (process.platform === 'win32') {
+                    await fs.promises.mkdir(path.dirname(logFile), { recursive: true });
+                }
+                else {
+                    await fs.promises.mkdir(path.dirname(logFile), { recursive: true, mode: 0o700 });
+                }
             }
             catch (err2) {
-                // noop; directory exists already
+                throw sfError_1.SfError.wrap(err2);
             }
             try {
-                await fs_1.fs.writeFile(logFile, '', { mode: fs_1.fs.DEFAULT_USER_FILE_MODE });
+                await fs.promises.writeFile(logFile, '', { mode: '600' });
             }
             catch (err3) {
-                throw sfdxError_1.SfdxError.wrap(err3);
+                throw sfError_1.SfError.wrap(err3);
             }
         }
         // avoid multiple streams to same log file
         if (!this.bunyan.streams.find(
         // No bunyan typings
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (stream) => stream.type === 'file' && stream.path === logFile)) {
-            // TODO: rotating-file
-            // https://github.com/trentm/node-bunyan#stream-type-rotating-file
+        (stream) => stream.type === 'rotating-file' && stream.path === logFile)) {
             this.addStream({
-                type: 'file',
+                type: 'rotating-file',
                 path: logFile,
+                period: this.logRotationPeriod,
+                count: this.logRotationCount,
                 level: this.bunyan.level(),
             });
         }
@@ -268,34 +284,37 @@ class Logger {
     addLogFileStreamSync(logFile) {
         try {
             // Check if we have write access to the log file (i.e., we created it already)
-            fs_1.fs.accessSync(logFile, fs_1.fs.constants.W_OK);
+            fs.accessSync(logFile, fs.constants.W_OK);
         }
         catch (err1) {
             try {
-                fs_1.fs.mkdirpSync(path.dirname(logFile), {
-                    mode: fs_1.fs.DEFAULT_USER_DIR_MODE,
-                });
+                if (process.platform === 'win32') {
+                    fs.mkdirSync(path.dirname(logFile), { recursive: true });
+                }
+                else {
+                    fs.mkdirSync(path.dirname(logFile), { recursive: true, mode: 0o700 });
+                }
             }
             catch (err2) {
-                // noop; directory exists already
+                throw sfError_1.SfError.wrap(err2);
             }
             try {
-                fs_1.fs.writeFileSync(logFile, '', { mode: fs_1.fs.DEFAULT_USER_FILE_MODE });
+                fs.writeFileSync(logFile, '', { mode: '600' });
             }
             catch (err3) {
-                throw sfdxError_1.SfdxError.wrap(err3);
+                throw sfError_1.SfError.wrap(err3);
             }
         }
         // avoid multiple streams to same log file
         if (!this.bunyan.streams.find(
         // No bunyan typings
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (stream) => stream.type === 'file' && stream.path === logFile)) {
-            // TODO: rotating-file
-            // https://github.com/trentm/node-bunyan#stream-type-rotating-file
+        (stream) => stream.type === 'rotating-file' && stream.path === logFile)) {
             this.addStream({
-                type: 'file',
+                type: 'rotating-file',
                 path: logFile,
+                period: this.logRotationPeriod,
+                count: this.logRotationCount,
                 level: this.bunyan.level(),
             });
         }
@@ -319,7 +338,7 @@ class Logger {
      *
      * @param {LoggerLevelValue} [level] The logger level.
      *
-     * **Throws** *{@link SfdxError}{ name: 'UnrecognizedLoggerLevelNameError' }* A value of `level` read from `SFDX_LOG_LEVEL`
+     * **Throws** *{@link SfError}{ name: 'UnrecognizedLoggerLevelNameError' }* A value of `level` read from `SFDX_LOG_LEVEL`
      * was invalid.
      *
      * ```
@@ -335,7 +354,8 @@ class Logger {
      */
     setLevel(level) {
         if (level == null) {
-            level = process.env.SFDX_LOG_LEVEL ? Logger.getLevelByName(process.env.SFDX_LOG_LEVEL) : Logger.DEFAULT_LEVEL;
+            const logLevelFromEnvVar = new kit_1.Env().getString('SF_LOG_LEVEL');
+            level = logLevelFromEnvVar ? Logger.getLevelByName(logLevelFromEnvVar) : Logger.DEFAULT_LEVEL;
         }
         this.bunyan.level(level);
         return this;
@@ -343,7 +363,9 @@ class Logger {
     /**
      * Gets the underlying Bunyan logger.
      */
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    // leave this typed as any to keep if from trying to export the type from the untyped bunyan module
+    // this prevents consumers from getting node_modules/@salesforce/core/lib/logger.d.ts:281:24 - error TS2304: Cannot find name 'Bunyan'.
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     getBunyanLogger() {
         return this.bunyan;
     }
@@ -400,7 +422,8 @@ class Logger {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             this.bunyan.streams.forEach(async (stream) => {
                 if (stream.type === 'file') {
-                    content += await fs_1.fs.readFile(stream.path, 'utf8');
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    content += await fs.promises.readFile(stream.path, 'utf8');
                 }
             });
             return content;
@@ -412,7 +435,6 @@ class Logger {
      * @param filter A function with signature `(...args: any[]) => any[]` that transforms log message arguments.
      */
     addFilter(filter) {
-        // eslint disable-line @typescript-eslint/no-explicit-any
         if (!this.bunyan.filters) {
             this.bunyan.filters = [];
         }
@@ -421,8 +443,7 @@ class Logger {
     /**
      * Close the logger, including any streams, and remove all listeners.
      *
-     * @param fn A function with signature `(stream: LoggerStream) => void` to call for each stream with
-     *                        the stream as an arg.
+     * @param fn A function with signature `(stream: LoggerStream) => void` to call for each stream with the stream as an arg.
      */
     close(fn) {
         if (this.bunyan.streams) {
@@ -452,7 +473,7 @@ class Logger {
      */
     child(name, fields = {}) {
         if (!name) {
-            throw new sfdxError_1.SfdxError('LoggerNameRequired');
+            throw new sfError_1.SfError('LoggerNameRequired');
         }
         fields.log = name;
         const child = new Logger(name);
@@ -480,6 +501,7 @@ class Logger {
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     trace(...args) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         this.bunyan.trace(this.applyFilters(LoggerLevel.TRACE, ...args));
         return this;
     }
@@ -542,8 +564,10 @@ class Logger {
      */
     fatal(...args) {
         // always show fatal to stderr
-        // eslint-disable-next-line no-console
-        console.error(...args);
+        // IMPORTANT:
+        // Do not use console.error() here, if fatal() is called from the uncaughtException handler, it
+        // will be re-thrown and caught again by the uncaughtException handler, causing an infinite loop.
+        console.log(...args); // eslint-disable-line no-console
         this.bunyan.fatal(this.applyFilters(LoggerLevel.FATAL, ...args));
         return this;
     }
@@ -561,6 +585,7 @@ class Logger {
                 stream: new stream_1.Writable({
                     write: (chunk, encoding, next) => {
                         try {
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                             const json = (0, kit_1.parseJsonMap)(chunk.toString());
                             const logLevel = (0, ts_types_1.ensureNumber)(json.level);
                             if (this.getLevel() <= logLevel) {
@@ -595,11 +620,14 @@ class Logger {
         }
         return args && args.length === 1 ? args[0] : args;
     }
+    // eslint-disable-next-line class-methods-use-this
     createLogFmtFormatterStream(loggerStream) {
         const logFmtWriteableStream = new stream_1.Writable({
             write: (chunk, enc, cb) => {
                 try {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                     const parsedJSON = JSON.parse(chunk.toString());
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                     const keys = Object.keys(parsedJSON);
                     let logEntry = '';
                     keys.forEach((key) => {
@@ -662,50 +690,48 @@ const FILTERED_KEYS = [
     { name: 'sfdxauthurl', regex: 'sfdx[^\'"]*auth[^\'"]*url' },
 ];
 // SFDX code and plugins should never show tokens or connect app information in the logs
-const _filter = (...args) => {
-    return args.map((arg) => {
-        if ((0, ts_types_1.isArray)(arg)) {
-            return _filter(...arg);
-        }
-        if (arg) {
-            let _arg;
-            // Normalize all objects into a string. This include errors.
-            if (arg instanceof Buffer) {
-                _arg = '<Buffer>';
-            }
-            else if ((0, ts_types_1.isObject)(arg)) {
-                _arg = JSON.stringify(arg);
-            }
-            else if ((0, ts_types_1.isString)(arg)) {
-                _arg = arg;
-            }
-            else {
-                _arg = '';
-            }
-            const HIDDEN = 'HIDDEN';
-            FILTERED_KEYS.forEach((key) => {
-                let expElement = key;
-                let expName = key;
-                // Filtered keys can be strings or objects containing regular expression components.
-                if ((0, ts_types_1.isPlainObject)(key)) {
-                    expElement = key.regex;
-                    expName = key.name;
-                }
-                const hiddenAttrMessage = `"<${expName} - ${HIDDEN}>"`;
-                // Match all json attribute values case insensitive: ex. {" Access*^&(*()^* Token " : " 45143075913458901348905 \n\t" ...}
-                const regexTokens = new RegExp(`(['"][^'"]*${expElement}[^'"]*['"]\\s*:\\s*)['"][^'"]*['"]`, 'gi');
-                _arg = _arg.replace(regexTokens, `$1${hiddenAttrMessage}`);
-                // Match all key value attribute case insensitive: ex. {" key\t"    : ' access_token  ' , " value " : "  dsafgasr431 " ....}
-                const keyRegex = new RegExp(`(['"]\\s*key\\s*['"]\\s*:)\\s*['"]\\s*${expElement}\\s*['"]\\s*.\\s*['"]\\s*value\\s*['"]\\s*:\\s*['"]\\s*[^'"]*['"]`, 'gi');
-                _arg = _arg.replace(keyRegex, `$1${hiddenAttrMessage}`);
-            });
-            _arg = _arg.replace(/(00D\w{12,15})![.\w]*/, `<${HIDDEN}>`);
-            // return an object if an object was logged; otherwise return the filtered string.
-            return (0, ts_types_1.isObject)(arg) ? (0, kit_1.parseJson)(_arg) : _arg;
+const filterSecrets = (...args) => args.map((arg) => {
+    if ((0, ts_types_1.isArray)(arg)) {
+        return filterSecrets(...arg);
+    }
+    if (arg) {
+        let mutableArg;
+        // Normalize all objects into a string. This includes errors.
+        if (arg instanceof Buffer) {
+            mutableArg = '<Buffer>';
         }
-        else {
-            return arg;
+        else if ((0, ts_types_1.isObject)(arg)) {
+            mutableArg = JSON.stringify(arg);
         }
-    });
-};
+        else if ((0, ts_types_1.isString)(arg)) {
+            mutableArg = arg;
+        }
+        else {
+            mutableArg = '';
+        }
+        const HIDDEN = 'HIDDEN';
+        FILTERED_KEYS.forEach((key) => {
+            let expElement = key;
+            let expName = key;
+            // Filtered keys can be strings or objects containing regular expression components.
+            if ((0, ts_types_1.isPlainObject)(key)) {
+                expElement = key.regex;
+                expName = key.name;
+            }
+            const hiddenAttrMessage = `"<${expName} - ${HIDDEN}>"`;
+            // Match all json attribute values case insensitive: ex. {" Access*^&(*()^* Token " : " 45143075913458901348905 \n\t" ...}
+            const regexTokens = new RegExp(`(['"][^'"]*${expElement}[^'"]*['"]\\s*:\\s*)['"][^'"]*['"]`, 'gi');
+            mutableArg = mutableArg.replace(regexTokens, `$1${hiddenAttrMessage}`);
+            // Match all key value attribute case insensitive: ex. {" key\t"    : ' access_token  ' , " value " : "  dsafgasr431 " ....}
+            const keyRegex = new RegExp(`(['"]\\s*key\\s*['"]\\s*:)\\s*['"]\\s*${expElement}\\s*['"]\\s*.\\s*['"]\\s*value\\s*['"]\\s*:\\s*['"]\\s*[^'"]*['"]`, 'gi');
+            mutableArg = mutableArg.replace(keyRegex, `$1${hiddenAttrMessage}`);
+        });
+        mutableArg = mutableArg.replace(/(00D\w{12,15})![.\w]*/, `<${HIDDEN}>`);
+        // return an object if an object was logged; otherwise return the filtered string.
+        return (0, ts_types_1.isObject)(arg) ? (0, kit_1.parseJson)(mutableArg) : mutableArg;
+    }
+    else {
+        return arg;
+    }
+});
 //# sourceMappingURL=logger.js.map

package/lib/messages.d.ts

@@ -1,16 +1,21 @@
 import { AnyJson } from '@salesforce/ts-types';
-import { SfdxError } from './sfdxError';
-export declare type Tokens = Array<string | boolean | number | null | undefined>;
+import { SfError } from './sfError';
+export type Tokens = Array<string | boolean | number | null | undefined>;
+export type StructuredMessage = {
+    message: string;
+    name: string;
+    actions?: string[];
+};
 /**
  * A loader function to return messages.
  *
  * @param locale The local set by the framework.
  */
-export declare type LoaderFunction<T extends string> = (locale: string) => Messages<T>;
-export declare type StoredMessage = string | string[] | {
+export type LoaderFunction<T extends string> = (locale: string) => Messages<T>;
+export type StoredMessage = string | string[] | {
     [s: string]: StoredMessage;
 };
-export declare type StoredMessageMap = Map<string, StoredMessage>;
+export type StoredMessageMap = Map<string, StoredMessage>;
 /**
  * The core message framework manages messages and allows them to be accessible by
  * all plugins and consumers of sfdx-core. It is set up to handle localization down
@@ -75,14 +80,14 @@ export declare type StoredMessageMap = Map<string, StoredMessage>;
  *
  * // Now you can use the messages from anywhere in your code or file.
  * // If using importMessageDirectory, the bundle name is the file name.
- * const messages: Messages = Messages.load(packageName, bundleName);
+ * const messages: Messages = Messages.loadMessages(packageName, bundleName);
  *
  * // Messages now contains all the message in the bundleName file.
  * messages.getMessage('authInfoCreationError');
  * ```
  */
 export declare class Messages<T extends string> {
-    private messages;
+    readonly messages: StoredMessageMap;
     private static loaders;
     private static bundles;
     /**
@@ -96,7 +101,7 @@ export declare class Messages<T extends string> {
     /**
      * Create a new messages bundle.
      *
-     * **Note:** Use {Messages.load} unless you are writing your own loader function.
+     * **Note:** Use {Messages.loadMessages} unless you are writing your own loader function.
      *
      * @param bundleName The bundle name.
      * @param locale The locale.
@@ -117,7 +122,7 @@ export declare class Messages<T extends string> {
      */
     static getLocale(): string;
     /**
-     * Set a custom loader function for a package and bundle that will be called on {@link Messages.load}.
+     * Set a custom loader function for a package and bundle that will be called on {@link Messages.loadMessages}.
      *
      * @param packageName The npm package name.
      * @param bundle The name of the bundle.
@@ -143,7 +148,7 @@ export declare class Messages<T extends string> {
     static importMessageFile(packageName: string, filePath: string): void;
     /**
      * Import all json and js files in a messages directory. Use the file name as the bundle key when
-     * {@link Messages.load} is called. By default, we're assuming the moduleDirectoryPart is a
+     * {@link Messages.loadMessages} is called. By default, we're assuming the moduleDirectoryPart is a
      * typescript project and will truncate to root path (where the package.json file is). If your messages
      * directory is in another spot or you are not using typescript, pass in false for truncateToProjectPath.
      *
@@ -162,38 +167,15 @@ export declare class Messages<T extends string> {
      * Load messages for a given package and bundle. If the bundle is not already cached, use the loader function
      * created from {@link Messages.setLoaderFunction} or {@link Messages.importMessagesDirectory}.
      *
-     * **NOTE: Use {@link Messages.load} instead for safe message validation and usage.**
-     *
      * ```typescript
      * Messages.importMessagesDirectory(__dirname);
-     * const messages = Messages.load('packageName', 'bundleName');
+     * const messages = Messages.loadMessages('packageName', 'bundleName');
      * ```
      *
      * @param packageName The name of the npm package.
      * @param bundleName The name of the bundle to load.
      */
     static loadMessages(packageName: string, bundleName: string): Messages<string>;
-    /**
-     * Load messages for a given package and bundle. If the bundle is not already cached, use the loader function
-     * created from {@link Messages.setLoaderFunction} or {@link Messages.importMessagesDirectory}.
-     *
-     * The message keys that will be used must be passed in for validation. This prevents runtime errors if messages are used but not defined.
-     *
-     * **NOTE: This should be defined at the top of the file so validation is done at load time rather than runtime.**
-     *
-     * ```typescript
-     * Messages.importMessagesDirectory(__dirname);
-     * const messages = Messages.load('packageName', 'bundleName', [
-     *   'messageKey1',
-     *   'messageKey2',
-     * ]);
-     * ```
-     *
-     * @param packageName The name of the npm package.
-     * @param bundleName The name of the bundle to load.
-     * @param keys The message keys that will be used.
-     */
-    static load<T extends string>(packageName: string, bundleName: string, keys: [T, ...T[]]): Messages<T>;
     /**
      * Check if a bundle already been loaded.
      *
@@ -244,9 +226,44 @@ export declare class Messages<T extends string> {
      * @param key The key of the error message.
      * @param tokens The error message tokens.
      * @param actionTokens The action messages tokens.
-     * @param exitCodeOrCause The exit code which will be used by SfdxCommand or he underlying error that caused this error to be raised.
+     * @param exitCodeOrCause The exit code which will be used by SfdxCommand or the underlying error that caused this error to be raised.
      * @param cause The underlying error that caused this error to be raised.
      */
-    createError(key: T, tokens?: Tokens, actionTokens?: Tokens, exitCodeOrCause?: number | Error, cause?: Error): SfdxError;
+    createError(key: T, tokens?: Tokens, actionTokens?: Tokens, exitCodeOrCause?: number | Error, cause?: Error): SfError;
+    /**
+     * Convenience method to create warning using message labels.
+     *
+     * `warning.name` will be the upper-cased key, remove prefixed `warning.` and will always end in Warning.
+     * `warning.actions` will be loaded using `${key}.actions` if available.
+     *
+     * @param key The key of the warning message.
+     * @param tokens The warning message tokens.
+     * @param actionTokens The action messages tokens.
+     */
+    createWarning(key: T, tokens?: Tokens, actionTokens?: Tokens): StructuredMessage;
+    /**
+     * Convenience method to create info using message labels.
+     *
+     * `info.name` will be the upper-cased key, remove prefixed `info.` and will always end in Info.
+     * `info.actions` will be loaded using `${key}.actions` if available.
+     *
+     * @param key The key of the warning message.
+     * @param tokens The warning message tokens.
+     * @param actionTokens The action messages tokens.
+     */
+    createInfo(key: T, tokens?: Tokens, actionTokens?: Tokens): StructuredMessage;
+    /**
+     * Formats message contents given a message type, key, tokens and actions tokens
+     *
+     * `<type>.name` will be the upper-cased key, remove prefixed `<type>.` and will always end in 'Error | Warning | Info.
+     * `<type>.actions` will be loaded using `${key}.actions` if available.
+     *
+     * @param type The type of the message set must 'error' | 'warning' | 'info'.
+     * @param key The key of the warning message.
+     * @param tokens The warning message tokens.
+     * @param actionTokens The action messages tokens.
+     * @param preserveName Do not require that the name end in the type ('error' | 'warning' | 'info').
+     */
+    private formatMessageContents;
     private getMessageWithMap;
 }