avo-cli 0.0.2 → 4.2.0.beta.1

data/payload/node_modules/@oclif/core/lib/command.d.ts

@@ -0,0 +1,192 @@
+import { Config } from './config';
+import { PrettyPrintableError } from './errors';
+import { LoadOptions } from './interfaces/config';
+import { CommandError } from './interfaces/errors';
+import { ArgInput, ArgOutput, ArgProps, BooleanFlagProps, Constraint, Deprecation, FlagInput, FlagOutput, Arg as IArg, Flag as IFlag, Input, OptionFlagProps, ParserOutput } from './interfaces/parser';
+import { Plugin } from './interfaces/plugin';
+/**
+ * An abstract class which acts as the base for each command
+ * in your project.
+ */
+export declare abstract class Command {
+    argv: string[];
+    config: Config;
+    private static readonly _base;
+    /** An array of aliases for this command. */
+    static aliases: string[];
+    /** An order-dependent object of arguments for the command */
+    static args: ArgInput;
+    static baseFlags: FlagInput;
+    static constraints: Constraint[];
+    /**
+     * Emit deprecation warning when a command alias is used
+     */
+    static deprecateAliases?: boolean;
+    static deprecationOptions?: Deprecation;
+    /**
+     * A full description of how to use the command.
+     *
+     * If no summary, the first line of the description will be used as the summary.
+     */
+    static description: string | undefined;
+    static enableJsonFlag: boolean;
+    /**
+     * An array of examples to show at the end of the command's help.
+     *
+     * IF only a string is provided, it will try to look for a line that starts
+     * with the cmd.bin as the example command and the rest as the description.
+     * If found, the command will be formatted appropriately.
+     *
+     * ```
+     * EXAMPLES:
+     *   A description of a particular use case.
+     *
+     *     $ <%= config.bin => command flags
+     * ```
+     */
+    static examples: Command.Example[];
+    /** A hash of flags for the command */
+    static flags: FlagInput;
+    static hasDynamicHelp: boolean;
+    static help: string | undefined;
+    /** Hide the command from help */
+    static hidden: boolean;
+    /** An array of aliases for this command that are hidden from help. */
+    static hiddenAliases: string[];
+    /** A command ID, used mostly in error or verbose reporting. */
+    static id: string;
+    static plugin: Plugin | undefined;
+    static readonly pluginAlias?: string;
+    static readonly pluginName?: string;
+    static readonly pluginType?: string;
+    /** Mark the command as a given state (e.g. beta or deprecated) in help */
+    static state?: 'beta' | 'deprecated' | string;
+    /** When set to false, allows a variable amount of arguments */
+    static strict: boolean;
+    /**
+     * The tweet-sized description for your class, used in a parent-commands
+     * sub-command listing and as the header for the command help.
+     */
+    static summary?: string;
+    /**
+     * An override string (or strings) for the default usage documentation.
+     */
+    static usage: string | string[] | undefined;
+    protected debug: (...args: any[]) => void;
+    id: string | undefined;
+    parsed: boolean;
+    constructor(argv: string[], config: Config);
+    /**
+     * instantiate and run the command
+     *
+     * @param {Command.Class} this - the command class
+     * @param {string[]} argv argv
+     * @param {LoadOptions} opts options
+     * @returns {Promise<unknown>} result
+     */
+    static run<T extends Command>(this: new (argv: string[], config: Config) => T, argv?: string[], opts?: LoadOptions): Promise<ReturnType<T['run']>>;
+    protected get ctor(): typeof Command;
+    protected _run<T>(): Promise<T>;
+    protected catch(err: CommandError): Promise<any>;
+    error(input: Error | string, options: {
+        code?: string;
+        exit: false;
+    } & PrettyPrintableError): void;
+    error(input: Error | string, options?: {
+        code?: string;
+        exit?: number;
+    } & PrettyPrintableError): never;
+    exit(code?: number): never;
+    protected finally(_: Error | undefined): Promise<any>;
+    protected init(): Promise<any>;
+    /**
+     * Determine if the command is being run with the --json flag in a command that supports it.
+     *
+     * @returns {boolean} true if the command supports json and the --json flag is present
+     */
+    jsonEnabled(): boolean;
+    log(message?: string, ...args: any[]): void;
+    protected logJson(json: unknown): void;
+    logToStderr(message?: string, ...args: any[]): void;
+    protected parse<F extends FlagOutput, B extends FlagOutput, A extends ArgOutput>(options?: Input<F, B, A>, argv?: string[]): Promise<ParserOutput<F, B, A>>;
+    /**
+     * actual command run code goes here
+     */
+    abstract run(): Promise<any>;
+    protected toErrorJson(err: unknown): any;
+    protected toSuccessJson(result: unknown): any;
+    warn(input: Error | string): Error | string;
+    protected warnIfCommandDeprecated(): void;
+    protected warnIfFlagDeprecated(flags: Record<string, unknown>): void;
+    private removeEnvVar;
+}
+export declare namespace Command {
+    /**
+     * The Command class exported by a command file.
+     */
+    type Class = typeof Command & {
+        id: string;
+        run(argv?: string[], config?: LoadOptions): Promise<any>;
+    };
+    /**
+     * A cached command that's had a `load` method attached to it.
+     *
+     * The `Plugin` class loads the commands from the manifest (if it exists) or requires and caches
+     * the commands directly from the commands directory inside the plugin. At this point the plugin
+     * is working with `Command.Cached`. It then appends a `load` method to each one. If the a command
+     * is executed then the `load` method is used to require the command class.
+     */
+    type Loadable = Cached & {
+        load(): Promise<Command.Class>;
+    };
+    /**
+     * A cached version of the command. This is created by the cachedCommand utility and
+     * stored in the oclif.manifest.json.
+     */
+    type Cached = {
+        [key: string]: unknown;
+        aliasPermutations?: string[] | undefined;
+        aliases: string[];
+        args: {
+            [name: string]: Arg.Cached;
+        };
+        deprecateAliases?: boolean | undefined;
+        deprecationOptions?: Deprecation | undefined;
+        description?: string | undefined;
+        examples?: Example[] | undefined;
+        flags: {
+            [name: string]: Flag.Cached;
+        };
+        hasDynamicHelp?: boolean;
+        hidden: boolean;
+        hiddenAliases: string[];
+        id: string;
+        isESM?: boolean | undefined;
+        permutations?: string[] | undefined;
+        pluginAlias?: string | undefined;
+        pluginName?: string | undefined;
+        pluginType?: string | undefined;
+        relativePath?: string[] | undefined;
+        state?: 'beta' | 'deprecated' | string | undefined;
+        strict?: boolean | undefined;
+        summary?: string | undefined;
+        type?: string | undefined;
+        usage?: string | string[] | undefined;
+    };
+    type Flag = IFlag<any>;
+    namespace Flag {
+        type Cached = Omit<Flag, 'input' | 'parse'> & (BooleanFlagProps | OptionFlagProps) & {
+            hasDynamicHelp?: boolean | undefined;
+        };
+        type Any = Cached | Flag;
+    }
+    type Arg = IArg<any>;
+    namespace Arg {
+        type Cached = Omit<Arg, 'input' | 'parse'> & ArgProps;
+        type Any = Arg | Cached;
+    }
+    type Example = {
+        command: string;
+        description: string;
+    } | string;
+}

data/payload/node_modules/@oclif/core/lib/command.js

@@ -0,0 +1,350 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+const node_url_1 = require("node:url");
+const node_util_1 = require("node:util");
+const cache_1 = __importDefault(require("./cache"));
+const config_1 = require("./config");
+const Errors = __importStar(require("./errors"));
+const util_1 = require("./help/util");
+const logger_1 = require("./logger");
+const Parser = __importStar(require("./parser"));
+const aggregate_flags_1 = require("./util/aggregate-flags");
+const ids_1 = require("./util/ids");
+const util_2 = require("./util/util");
+const ux_1 = require("./ux");
+const pjson = cache_1.default.getInstance().get('@oclif/core');
+/**
+ * swallows stdout epipe errors
+ * this occurs when stdout closes such as when piping to head
+ */
+process.stdout.on('error', (err) => {
+    if (err && err.code === 'EPIPE')
+        return;
+    throw err;
+});
+/**
+ * An abstract class which acts as the base for each command
+ * in your project.
+ */
+class Command {
+    argv;
+    config;
+    static _base = `${pjson.name}@${pjson.version}`;
+    /** An array of aliases for this command. */
+    static aliases = [];
+    /** An order-dependent object of arguments for the command */
+    static args = {};
+    static baseFlags;
+    static constraints;
+    /**
+     * Emit deprecation warning when a command alias is used
+     */
+    static deprecateAliases;
+    static deprecationOptions;
+    /**
+     * A full description of how to use the command.
+     *
+     * If no summary, the first line of the description will be used as the summary.
+     */
+    static description;
+    static enableJsonFlag = false;
+    /**
+     * An array of examples to show at the end of the command's help.
+     *
+     * IF only a string is provided, it will try to look for a line that starts
+     * with the cmd.bin as the example command and the rest as the description.
+     * If found, the command will be formatted appropriately.
+     *
+     * ```
+     * EXAMPLES:
+     *   A description of a particular use case.
+     *
+     *     $ <%= config.bin => command flags
+     * ```
+     */
+    static examples;
+    /** A hash of flags for the command */
+    static flags;
+    static hasDynamicHelp = false;
+    static help;
+    /** Hide the command from help */
+    static hidden;
+    /** An array of aliases for this command that are hidden from help. */
+    static hiddenAliases = [];
+    /** A command ID, used mostly in error or verbose reporting. */
+    static id;
+    static plugin;
+    static pluginAlias;
+    static pluginName;
+    static pluginType;
+    /** Mark the command as a given state (e.g. beta or deprecated) in help */
+    static state;
+    /** When set to false, allows a variable amount of arguments */
+    static strict = true;
+    /**
+     * The tweet-sized description for your class, used in a parent-commands
+     * sub-command listing and as the header for the command help.
+     */
+    static summary;
+    /**
+     * An override string (or strings) for the default usage documentation.
+     */
+    static usage;
+    debug;
+    id;
+    parsed = false;
+    constructor(argv, config) {
+        this.argv = argv;
+        this.config = config;
+        this.id = this.ctor.id;
+        try {
+            this.debug = (0, logger_1.makeDebug)(this.id ? `${this.config.bin}:${this.id}` : this.config.bin);
+        }
+        catch {
+            this.debug = () => {
+                // noop
+            };
+        }
+    }
+    /**
+     * instantiate and run the command
+     *
+     * @param {Command.Class} this - the command class
+     * @param {string[]} argv argv
+     * @param {LoadOptions} opts options
+     * @returns {Promise<unknown>} result
+     */
+    static async run(argv, opts) {
+        if (!argv)
+            argv = process.argv.slice(2);
+        // Handle the case when a file URL string is passed in such as 'import.meta.url'; covert to file path.
+        if (typeof opts === 'string' && opts.startsWith('file://')) {
+            opts = (0, node_url_1.fileURLToPath)(opts);
+        }
+        const config = await config_1.Config.load(opts || require.main?.filename || __dirname);
+        const cache = cache_1.default.getInstance();
+        if (!cache.has('config'))
+            cache.set('config', config);
+        const cmd = new this(argv, config);
+        if (!cmd.id) {
+            const id = cmd.constructor.name.toLowerCase();
+            cmd.id = id;
+            cmd.ctor.id = id;
+        }
+        return cmd._run();
+    }
+    get ctor() {
+        return this.constructor;
+    }
+    async _run() {
+        let err;
+        let result;
+        try {
+            // remove redirected env var to allow subsessions to run autoupdated client
+            this.removeEnvVar('REDIRECTED');
+            await this.init();
+            result = await this.run();
+        }
+        catch (error) {
+            err = error;
+            await this.catch(error);
+        }
+        finally {
+            await this.finally(err);
+        }
+        if (result && this.jsonEnabled())
+            this.logJson(this.toSuccessJson(result));
+        if (!this.parsed && !(0, util_2.isProd)()) {
+            process.emitWarning(`Command ${this.id} did not parse its arguments. Did you forget to call 'this.parse'?`, {
+                code: 'UnparsedCommand',
+            });
+        }
+        return result;
+    }
+    async catch(err) {
+        process.exitCode = process.exitCode ?? err.exitCode ?? 1;
+        if (this.jsonEnabled()) {
+            this.logJson(this.toErrorJson(err));
+        }
+        else {
+            if (!err.message)
+                throw err;
+            try {
+                ux_1.ux.action.stop(ux_1.ux.colorize('bold', ux_1.ux.colorize('red', '!')));
+            }
+            catch { }
+            throw err;
+        }
+    }
+    error(input, options = {}) {
+        return Errors.error(input, options);
+    }
+    exit(code = 0) {
+        Errors.exit(code);
+    }
+    async finally(_) { }
+    async init() {
+        this.debug('init version: %s argv: %o', this.ctor._base, this.argv);
+        const g = globalThis;
+        g['http-call'] = g['http-call'] || {};
+        g['http-call'].userAgent = this.config.userAgent;
+        this.warnIfCommandDeprecated();
+    }
+    /**
+     * Determine if the command is being run with the --json flag in a command that supports it.
+     *
+     * @returns {boolean} true if the command supports json and the --json flag is present
+     */
+    jsonEnabled() {
+        // If the command doesn't support json, return false
+        if (!this.ctor?.enableJsonFlag)
+            return false;
+        // If the CONTENT_TYPE env var is set to json, return true
+        if (this.config.scopedEnvVar?.('CONTENT_TYPE')?.toLowerCase() === 'json')
+            return true;
+        const passThroughIndex = this.argv.indexOf('--');
+        const jsonIndex = this.argv.indexOf('--json');
+        return passThroughIndex === -1
+            ? // If '--' is not present, then check for `--json` in this.argv
+                jsonIndex !== -1
+            : // If '--' is present, return true only the --json flag exists and is before the '--'
+                jsonIndex !== -1 && jsonIndex < passThroughIndex;
+    }
+    log(message = '', ...args) {
+        if (!this.jsonEnabled()) {
+            message = typeof message === 'string' ? message : (0, node_util_1.inspect)(message);
+            ux_1.ux.stdout(message, ...args);
+        }
+    }
+    logJson(json) {
+        ux_1.ux.stdout(ux_1.ux.colorizeJson(json, { pretty: true, theme: this.config.theme?.json }));
+    }
+    logToStderr(message = '', ...args) {
+        if (!this.jsonEnabled()) {
+            message = typeof message === 'string' ? message : (0, node_util_1.inspect)(message);
+            ux_1.ux.stderr(message, ...args);
+        }
+    }
+    async parse(options, argv = this.argv) {
+        if (!options)
+            options = this.ctor;
+        const opts = {
+            context: this,
+            ...options,
+            flags: (0, aggregate_flags_1.aggregateFlags)(options.flags, options.baseFlags, options.enableJsonFlag),
+        };
+        const hookResult = await this.config.runHook('preparse', { argv: [...argv], options: opts });
+        // Since config.runHook will only run the hook for the root plugin, hookResult.successes will always have a length of 0 or 1
+        // But to be extra safe, we find the result that matches the root plugin.
+        const argvToParse = hookResult.successes?.length
+            ? (hookResult.successes.find((s) => s.plugin.root === cache_1.default.getInstance().get('rootPlugin')?.root)?.result ??
+                argv)
+            : argv;
+        this.argv = [...argvToParse];
+        const results = await Parser.parse(argvToParse, opts);
+        this.warnIfFlagDeprecated(results.flags ?? {});
+        this.parsed = true;
+        return results;
+    }
+    toErrorJson(err) {
+        if (err instanceof Error) {
+            // `Error.prototype.message`/`.name` are non-enumerable, so they are dropped
+            // by `JSON.stringify` in `logJson`. Surface them explicitly while preserving
+            // any enumerable own properties (e.g. a `CLIError`'s `oclif` metadata).
+            return { error: { ...err, message: err.message, name: err.name } };
+        }
+        return { error: err };
+    }
+    toSuccessJson(result) {
+        return result;
+    }
+    warn(input) {
+        if (!this.jsonEnabled())
+            Errors.warn(input);
+        return input;
+    }
+    warnIfCommandDeprecated() {
+        const [id] = (0, util_1.normalizeArgv)(this.config);
+        if (this.ctor.deprecateAliases && [...this.ctor.aliases, ...this.ctor.hiddenAliases].includes(id)) {
+            const cmdName = (0, ids_1.toConfiguredId)(this.ctor.id, this.config);
+            const aliasName = (0, ids_1.toConfiguredId)(id, this.config);
+            this.warn((0, util_1.formatCommandDeprecationWarning)(aliasName, { to: cmdName }));
+        }
+        if (this.ctor.state === 'deprecated') {
+            const cmdName = (0, ids_1.toConfiguredId)(this.ctor.id, this.config);
+            this.warn((0, util_1.formatCommandDeprecationWarning)(cmdName, this.ctor.deprecationOptions));
+        }
+    }
+    warnIfFlagDeprecated(flags) {
+        const allFlags = (0, aggregate_flags_1.aggregateFlags)(this.ctor.flags, this.ctor.baseFlags, this.ctor.enableJsonFlag);
+        for (const flag of Object.keys(flags)) {
+            const flagDef = allFlags[flag];
+            const deprecated = flagDef?.deprecated;
+            if (deprecated) {
+                this.warn((0, util_1.formatFlagDeprecationWarning)(flag, deprecated));
+            }
+            const deprecateAliases = flagDef?.deprecateAliases;
+            if (deprecateAliases) {
+                const aliases = (0, util_2.uniq)([...(flagDef?.aliases ?? []), ...(flagDef?.charAliases ?? [])]).map((a) => a.length === 1 ? `-${a}` : `--${a}`);
+                if (aliases.length === 0)
+                    return;
+                const foundAliases = aliases.filter((alias) => this.argv.includes(alias));
+                for (const alias of foundAliases) {
+                    let preferredUsage = `--${flagDef?.name}`;
+                    if (flagDef?.char) {
+                        preferredUsage += ` | -${flagDef?.char}`;
+                    }
+                    this.warn((0, util_1.formatFlagDeprecationWarning)(alias, { to: preferredUsage }));
+                }
+            }
+        }
+    }
+    removeEnvVar(envVar) {
+        const keys = [];
+        try {
+            keys.push(...this.config.scopedEnvVarKeys(envVar));
+        }
+        catch {
+            keys.push(this.config.scopedEnvVarKey(envVar));
+        }
+        keys.map((key) => delete process.env[key]);
+    }
+}
+exports.Command = Command;

data/payload/node_modules/@oclif/core/lib/config/config.d.ts

@@ -0,0 +1,135 @@
+import { Command } from '../command';
+import { Hook, Hooks, OclifConfiguration, PJSON, S3Templates, Topic, UserPJSON } from '../interfaces';
+import { ArchTypes, Config as IConfig, LoadOptions, PlatformTypes, VersionDetails } from '../interfaces/config';
+import { Plugin as IPlugin, Options } from '../interfaces/plugin';
+import { Theme } from '../interfaces/theme';
+export declare class Config implements IConfig {
+    options: Options;
+    arch: ArchTypes;
+    bin: string;
+    binAliases?: string[] | undefined;
+    binPath?: string | undefined;
+    cacheDir: string;
+    channel: string;
+    configDir: string;
+    dataDir: string;
+    dirname: string;
+    flexibleTaxonomy: boolean;
+    home: string;
+    isSingleCommandCLI: boolean;
+    name: string;
+    npmRegistry?: string | undefined;
+    nsisCustomization?: string | undefined;
+    pjson: PJSON;
+    platform: PlatformTypes;
+    plugins: Map<string, IPlugin>;
+    root: string;
+    shell: string;
+    theme?: Theme | undefined;
+    topicSeparator: ' ' | ':';
+    updateConfig: NonNullable<OclifConfiguration['update']>;
+    userAgent: string;
+    userPJSON?: UserPJSON | undefined;
+    valid: boolean;
+    version: string;
+    protected warned: boolean;
+    windows: boolean;
+    private _base;
+    private _commandIDs;
+    private _commands;
+    private _topics;
+    private commandPermutations;
+    private pluginLoader;
+    private rootPlugin;
+    private topicPermutations;
+    constructor(options: Options);
+    static load(opts?: LoadOptions): Promise<Config>;
+    get commandIDs(): string[];
+    get commands(): Command.Loadable[];
+    protected get isProd(): boolean;
+    static get rootPlugin(): IPlugin | undefined;
+    get topics(): Topic[];
+    get versionDetails(): VersionDetails;
+    protected dir(category: 'cache' | 'config' | 'data'): string;
+    findCommand(id: string, opts: {
+        must: true;
+    }): Command.Loadable;
+    findCommand(id: string, opts?: {
+        must: boolean;
+    }): Command.Loadable | undefined;
+    /**
+     * Find all command ids that include the provided command id.
+     *
+     * For example, if the command ids are:
+     * - foo:bar:baz
+     * - one:two:three
+     *
+     * `bar` would return `foo:bar:baz`
+     *
+     * @param partialCmdId string
+     * @param argv string[] process.argv containing the flags and arguments provided by the user
+     * @returns string[]
+     */
+    findMatches(partialCmdId: string, argv: string[]): Command.Loadable[];
+    findTopic(id: string, opts: {
+        must: true;
+    }): Topic;
+    findTopic(id: string, opts?: {
+        must: boolean;
+    }): Topic | undefined;
+    /**
+     * Returns an array of all command ids. If flexible taxonomy is enabled then all permutations will be appended to the array.
+     * @returns string[]
+     */
+    getAllCommandIDs(): string[];
+    /**
+     * Returns an array of all commands. If flexible taxonomy is enabled then all permutations will be appended to the array.
+     * @returns Command.Loadable[]
+     */
+    getAllCommands(): Command.Loadable[];
+    getPluginsList(): IPlugin[];
+    load(): Promise<void>;
+    loadPluginsAndCommands(opts?: {
+        force: boolean;
+    }): Promise<void>;
+    loadTheme(): Promise<Theme | undefined>;
+    protected macosCacheDir(): string | undefined;
+    runCommand<T = unknown>(id: string, argv?: string[], cachedCommand?: Command.Loadable | null): Promise<T>;
+    runHook<T extends keyof Hooks, P extends Hooks = Hooks>(event: T, opts: P[T]['options'], timeout?: number, captureErrors?: boolean): Promise<Hook.Result<P[T]['return']>>;
+    s3Key(type: keyof S3Templates, ext?: '.tar.gz' | '.tar.xz' | IConfig.s3Key.Options, options?: IConfig.s3Key.Options): string;
+    s3Url(key: string): string;
+    scopedEnvVar(k: string): string | undefined;
+    /**
+     * this DOES NOT account for bin aliases, use scopedEnvVarKeys instead which will account for bin aliases
+     * @param k {string}, the unscoped key you want to get the value for
+     * @returns {string} returns the env var key
+     */
+    scopedEnvVarKey(k: string): string;
+    /**
+     * gets the scoped env var keys for a given key, including bin aliases
+     * @param k {string}, the env key e.g. 'debug'
+     * @returns {string[]} e.g. ['SF_DEBUG', 'SFDX_DEBUG']
+     */
+    scopedEnvVarKeys(k: string): string[];
+    scopedEnvVarTrue(k: string): boolean;
+    protected windowsHome(): string | undefined;
+    protected windowsHomedriveHome(): string | undefined;
+    protected windowsUserprofileHome(): string | undefined;
+    private buildS3Config;
+    private getCmdLookupId;
+    private getTopicLookupId;
+    /**
+     * Insert legacy plugins
+     *
+     * Replace invalid CLI plugins (cli-engine plugins, mostly Heroku) loaded via `this.loadPlugins`
+     * with oclif-compatible ones returned by @oclif/plugin-legacy init hook.
+     *
+     * @param plugins array of oclif-compatible plugins
+     */
+    private insertLegacyPlugins;
+    private isJitPluginCommand;
+    private loadCommands;
+    private loadTopics;
+    private maybeAdjustDebugSetting;
+    private warn;
+}