@pnpm/installing.commands 1004.6.10

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# @pnpm/plugin-commands-installation
+
+> Commands for installation
+
+[![npm version](https://img.shields.io/npm/v/@pnpm/plugin-commands-installation.svg)](https://www.npmjs.com/package/@pnpm/plugin-commands-installation)
+
+## Installation
+
+```sh
+pnpm add @pnpm/plugin-commands-installation
+```
+
+## License
+
+MIT

package/lib/add.d.ts

@@ -0,0 +1,17 @@
+import type { InstallCommandOptions } from './install.js';
+export declare const shorthands: Record<string, string>;
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const commandNames: string[];
+export declare function help(): string;
+export type AddCommandOptions = InstallCommandOptions & {
+    allowBuild?: string[];
+    allowNew?: boolean;
+    ignoreWorkspaceRootCheck?: boolean;
+    save?: boolean;
+    update?: boolean;
+    useBetaCli?: boolean;
+    workspaceRoot?: boolean;
+    config?: boolean;
+};
+export declare function handler(opts: AddCommandOptions, params: string[]): Promise<void>;

package/lib/add.js

@@ -0,0 +1,285 @@
+import { FILTERING, OPTIONS, UNIVERSAL_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl } from '@pnpm/cli.utils';
+import { types as allTypes } from '@pnpm/config.reader';
+import { writeSettings } from '@pnpm/config.writer';
+import { PnpmError } from '@pnpm/error';
+import { handleGlobalAdd } from '@pnpm/global.commands';
+import { resolveConfigDeps } from '@pnpm/installing.env-installer';
+import { createStoreController } from '@pnpm/store.connection-manager';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import { getFetchFullMetadata } from './getFetchFullMetadata.js';
+import { installDeps } from './installDeps.js';
+export const shorthands = {
+    'save-catalog': '--save-catalog-name=default',
+    d: '--save-dev',
+    e: '--save-exact',
+    o: '--save-optional',
+    p: '--save-prod',
+};
+export function rcOptionsTypes() {
+    return pick([
+        'cache-dir',
+        'cpu',
+        'child-concurrency',
+        'dangerously-allow-all-builds',
+        'engine-strict',
+        'fetch-retries',
+        'fetch-retry-factor',
+        'fetch-retry-maxtimeout',
+        'fetch-retry-mintimeout',
+        'fetch-timeout',
+        'force',
+        'global-bin-dir',
+        'global-dir',
+        'global-pnpmfile',
+        'global',
+        'hoist',
+        'hoist-pattern',
+        'https-proxy',
+        'ignore-pnpmfile',
+        'ignore-scripts',
+        'ignore-workspace-root-check',
+        'libc',
+        'link-workspace-packages',
+        'lockfile-dir',
+        'lockfile-directory',
+        'lockfile-only',
+        'lockfile',
+        'modules-dir',
+        'network-concurrency',
+        'node-linker',
+        'noproxy',
+        'npm-path',
+        'os',
+        'package-import-method',
+        'pnpmfile',
+        'prefer-offline',
+        'production',
+        'proxy',
+        'public-hoist-pattern',
+        'registry',
+        'reporter',
+        'save-catalog-name',
+        'save-dev',
+        'save-exact',
+        'save-optional',
+        'save-peer',
+        'save-prefix',
+        'save-prod',
+        'save-workspace-protocol',
+        'shamefully-flatten',
+        'shamefully-hoist',
+        'shared-workspace-lockfile',
+        'side-effects-cache-readonly',
+        'side-effects-cache',
+        'store-dir',
+        'strict-peer-dependencies',
+        'trust-policy',
+        'trust-policy-exclude',
+        'trust-policy-ignore-after',
+        'unsafe-perm',
+        'offline',
+        'only',
+        'optional',
+        'verify-store-integrity',
+        'virtual-store-dir',
+    ], allTypes);
+}
+export function cliOptionsTypes() {
+    return {
+        ...rcOptionsTypes(),
+        'allow-build': [String, Array],
+        recursive: Boolean,
+        save: Boolean,
+        workspace: Boolean,
+        config: Boolean,
+    };
+}
+export const commandNames = ['add'];
+export function help() {
+    return renderHelp({
+        description: 'Installs a package and any packages that it depends on.',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Save package to your `dependencies`. The default behavior',
+                        name: '--save-prod',
+                        shortAlias: '-p',
+                    },
+                    {
+                        description: 'Save package to your `devDependencies`',
+                        name: '--save-dev',
+                        shortAlias: '-d',
+                    },
+                    {
+                        description: 'Save package to your `optionalDependencies`',
+                        name: '--save-optional',
+                        shortAlias: '-o',
+                    },
+                    {
+                        description: 'Save package to your `peerDependencies` and `devDependencies`',
+                        name: '--save-peer',
+                    },
+                    {
+                        description: 'Save package to the default catalog',
+                        name: '--save-catalog',
+                    },
+                    {
+                        description: 'Save package to the specified catalog',
+                        name: '--save-catalog-name=<name>',
+                    },
+                    {
+                        description: 'Install exact version',
+                        name: '--[no-]save-exact',
+                        shortAlias: '-e',
+                    },
+                    {
+                        description: 'Save packages from the workspace with a "workspace:" protocol. True by default',
+                        name: '--[no-]save-workspace-protocol',
+                    },
+                    {
+                        description: 'Install as a global package',
+                        name: '--global',
+                        shortAlias: '-g',
+                    },
+                    {
+                        description: 'Run installation recursively in every package found in subdirectories \
+or in every workspace package, when executed inside a workspace. \
+For options that may be used with `-r`, see "pnpm help recursive"',
+                        name: '--recursive',
+                        shortAlias: '-r',
+                    },
+                    {
+                        description: 'Only adds the new dependency if it is found in the workspace',
+                        name: '--workspace',
+                    },
+                    {
+                        description: 'Save the dependency to configurational dependencies',
+                        name: '--config',
+                    },
+                    OPTIONS.ignoreScripts,
+                    OPTIONS.offline,
+                    OPTIONS.preferOffline,
+                    OPTIONS.storeDir,
+                    OPTIONS.virtualStoreDir,
+                    OPTIONS.globalDir,
+                    ...UNIVERSAL_OPTIONS,
+                    {
+                        description: 'A list of package names that are allowed to run postinstall scripts during installation',
+                        name: '--allow-build',
+                    },
+                ],
+            },
+            FILTERING,
+        ],
+        url: docsUrl('add'),
+        usages: [
+            'pnpm add <name>',
+            'pnpm add <name>@<tag>',
+            'pnpm add <name>@<version>',
+            'pnpm add <name>@<version range>',
+            'pnpm add <git host>:<git user>/<repo name>',
+            'pnpm add <git repo url>',
+            'pnpm add <tarball file>',
+            'pnpm add <tarball url>',
+            'pnpm add <dir>',
+        ],
+    });
+}
+export async function handler(opts, params) {
+    if (opts.cliOptions['save'] === false) {
+        throw new PnpmError('OPTION_NOT_SUPPORTED', 'The "add" command currently does not support the no-save option');
+    }
+    if (!params || (params.length === 0)) {
+        throw new PnpmError('MISSING_PACKAGE_NAME', '`pnpm add` requires the package name');
+    }
+    if (opts.config) {
+        const store = await createStoreController(opts);
+        await resolveConfigDeps(params, {
+            ...opts,
+            store: store.ctrl,
+            storeDir: store.dir,
+            rootDir: opts.workspaceDir ?? opts.rootProjectManifestDir,
+        });
+        return;
+    }
+    if (!opts.recursive &&
+        opts.workspaceDir === opts.dir &&
+        !opts.ignoreWorkspaceRootCheck &&
+        !opts.workspaceRoot &&
+        opts.workspacePackagePatterns &&
+        opts.workspacePackagePatterns.length > 1) {
+        throw new PnpmError('ADDING_TO_ROOT', 'Running this command will add the dependency to the workspace root, ' +
+            'which might not be what you want - if you really meant it, ' +
+            'make it explicit by running this command again with the -w flag (or --workspace-root). ' +
+            'If you don\'t want to see this warning anymore, you may set the ignore-workspace-root-check setting to true.');
+    }
+    if (opts.global) {
+        if (!opts.bin) {
+            throw new PnpmError('NO_GLOBAL_BIN_DIR', 'Unable to find the global bin directory', {
+                hint: 'Run "pnpm setup" to create it automatically, or set the global-bin-dir setting, or the PNPM_HOME env variable. The global bin directory should be in the PATH.',
+            });
+        }
+        if (params.includes('pnpm') || params.includes('@pnpm/exe')) {
+            throw new PnpmError('GLOBAL_PNPM_INSTALL', 'Use the "pnpm self-update" command to install or update pnpm');
+        }
+        return handleGlobalAdd(opts, params);
+    }
+    const include = {
+        dependencies: opts.production !== false,
+        devDependencies: opts.dev !== false,
+        optionalDependencies: opts.optional !== false,
+    };
+    if (opts.allowBuild?.length) {
+        if (opts.argv.original.includes('--allow-build')) {
+            throw new PnpmError('ALLOW_BUILD_MISSING_PACKAGE', 'The --allow-build flag is missing a package name. Please specify the package name(s) that are allowed to run installation scripts.');
+        }
+        if (opts.allowBuilds) {
+            const disallowedBuilds = Object.entries(opts.allowBuilds)
+                .filter(([, value]) => value === false)
+                .map(([pkg]) => pkg);
+            const overlapDependencies = disallowedBuilds.filter((dep) => opts.allowBuild?.includes(dep));
+            if (overlapDependencies.length) {
+                throw new PnpmError('OVERRIDING_IGNORED_BUILT_DEPENDENCIES', `The following dependencies are ignored by the root project, but are allowed to be built by the current command: ${overlapDependencies.join(', ')}`, {
+                    hint: 'If you are sure you want to allow those dependencies to run installation scripts, remove them from the allowBuilds list (or change their value to true).',
+                });
+            }
+        }
+        const allowBuilds = {};
+        for (const pkg of opts.allowBuild) {
+            allowBuilds[pkg] = true;
+        }
+        if (opts.rootProjectManifestDir) {
+            opts.rootProjectManifest = opts.rootProjectManifest ?? {};
+            await writeSettings({
+                ...opts,
+                workspaceDir: opts.workspaceDir ?? opts.rootProjectManifestDir,
+                updatedSettings: {
+                    allowBuilds,
+                },
+            });
+        }
+        // Pass the allowed packages to allowBuilds so they can build during this install
+        const mergedAllowBuilds = { ...opts.allowBuilds };
+        for (const pkg of opts.allowBuild) {
+            mergedAllowBuilds[pkg] = true;
+        }
+        return installDeps({
+            ...opts,
+            allowBuilds: mergedAllowBuilds,
+            fetchFullMetadata: getFetchFullMetadata(opts),
+            include,
+            includeDirect: include,
+        }, params);
+    }
+    return installDeps({
+        ...opts,
+        fetchFullMetadata: getFetchFullMetadata(opts),
+        include,
+        includeDirect: include,
+    }, params);
+}
+//# sourceMappingURL=add.js.map

package/lib/ci.d.ts

@@ -0,0 +1,6 @@
+export declare const rcOptionsTypes: () => Record<string, unknown>;
+export declare const cliOptionsTypes: () => Record<string, unknown>;
+export declare const shorthands: Record<string, string>;
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare function handler(_opts: unknown): Promise<never>;

package/lib/ci.js

@@ -0,0 +1,20 @@
+import { docsUrl } from '@pnpm/cli.utils';
+import { PnpmError } from '@pnpm/error';
+import { renderHelp } from 'render-help';
+export const rcOptionsTypes = () => ({});
+export const cliOptionsTypes = () => ({});
+export const shorthands = {};
+export const commandNames = ['ci', 'clean-install', 'ic', 'install-clean'];
+export function help() {
+    return renderHelp({
+        aliases: ['clean-install', 'ic', 'install-clean'],
+        description: 'Clean install a project',
+        descriptionLists: [],
+        url: docsUrl('ci'),
+        usages: ['pnpm ci'],
+    });
+}
+export async function handler(_opts) {
+    throw new PnpmError('CI_NOT_IMPLEMENTED', 'The ci command is not implemented yet');
+}
+//# sourceMappingURL=ci.js.map

package/lib/createProjectManifestWriter.d.ts

@@ -0,0 +1,2 @@
+import { type WriteProjectManifest } from '@pnpm/workspace.project-manifest-reader';
+export declare function createProjectManifestWriter(projectDir: string): Promise<WriteProjectManifest>;

package/lib/createProjectManifestWriter.js

@@ -0,0 +1,17 @@
+import path from 'node:path';
+import util from 'node:util';
+import { readProjectManifest } from '@pnpm/workspace.project-manifest-reader';
+import { writeProjectManifest } from '@pnpm/workspace.project-manifest-writer';
+export async function createProjectManifestWriter(projectDir) {
+    try {
+        const { writeProjectManifest } = await readProjectManifest(projectDir);
+        return writeProjectManifest;
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ERR_PNPM_NO_IMPORTER_MANIFEST_FOUND') {
+            return writeProjectManifest.bind(null, path.join(projectDir, 'package.json'));
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=createProjectManifestWriter.js.map

package/lib/dedupe.d.ts

@@ -0,0 +1,9 @@
+import { type InstallCommandOptions } from './install.js';
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const commandNames: string[];
+export declare function help(): string;
+export interface DedupeCommandOptions extends InstallCommandOptions {
+    readonly check?: boolean;
+}
+export declare function handler(opts: DedupeCommandOptions): Promise<void>;

package/lib/dedupe.js

@@ -0,0 +1,59 @@
+import { OPTIONS, UNIVERSAL_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl } from '@pnpm/cli.utils';
+import { dedupeDiffCheck } from '@pnpm/installing.dedupe.check';
+import { omit } from 'ramda';
+import { renderHelp } from 'render-help';
+import { rcOptionsTypes as installCommandRcOptionsTypes } from './install.js';
+import { installDeps } from './installDeps.js';
+// In general, the "pnpm dedupe" command should use .npmrc options that "pnpm install" would also accept.
+export function rcOptionsTypes() {
+    // Some options on pnpm install (like --frozen-lockfile) don't make sense on pnpm dedupe.
+    return omit(['frozen-lockfile'], installCommandRcOptionsTypes());
+}
+export function cliOptionsTypes() {
+    return {
+        ...rcOptionsTypes(),
+        check: Boolean,
+    };
+}
+export const commandNames = ['dedupe'];
+export function help() {
+    return renderHelp({
+        description: 'Perform an install removing older dependencies in the lockfile if a newer version can be used.',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    ...UNIVERSAL_OPTIONS,
+                    {
+                        description: 'Check if running dedupe would result in changes without installing packages or editing the lockfile. Exits with a non-zero status code if changes are possible.',
+                        name: '--check',
+                    },
+                    OPTIONS.ignoreScripts,
+                    OPTIONS.offline,
+                    OPTIONS.preferOffline,
+                    OPTIONS.storeDir,
+                    OPTIONS.virtualStoreDir,
+                    OPTIONS.globalDir,
+                ],
+            },
+        ],
+        url: docsUrl('dedupe'),
+        usages: ['pnpm dedupe'],
+    });
+}
+export async function handler(opts) {
+    const include = {
+        dependencies: opts.production !== false,
+        devDependencies: opts.dev !== false,
+        optionalDependencies: opts.optional !== false,
+    };
+    return installDeps({
+        ...opts,
+        dedupe: true,
+        include,
+        includeDirect: include,
+        lockfileCheck: opts.check ? dedupeDiffCheck : undefined,
+    }, []);
+}
+//# sourceMappingURL=dedupe.js.map

package/lib/fetch.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from '@pnpm/config.reader';
+import { type CreateStoreControllerOptions } from '@pnpm/store.connection-manager';
+import { cliOptionsTypes } from './install.js';
+export declare const rcOptionsTypes: () => Record<string, unknown>;
+export { cliOptionsTypes };
+export declare const shorthands: Record<string, string>;
+export declare const commandNames: string[];
+export declare function help(): string;
+type FetchCommandOptions = Pick<Config, 'production' | 'dev' | 'enableGlobalVirtualStore' | 'rootProjectManifest' | 'rootProjectManifestDir'> & CreateStoreControllerOptions;
+export declare function handler(opts: FetchCommandOptions): Promise<void>;

package/lib/fetch.js

@@ -0,0 +1,75 @@
+import { UNIVERSAL_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl } from '@pnpm/cli.utils';
+import { mutateModulesInSingleProject } from '@pnpm/installing.deps-installer';
+import { createStoreController } from '@pnpm/store.connection-manager';
+import { renderHelp } from 'render-help';
+import { cliOptionsTypes } from './install.js';
+export const rcOptionsTypes = cliOptionsTypes;
+export { cliOptionsTypes };
+export const shorthands = {
+    D: '--dev',
+    P: '--production',
+};
+export const commandNames = ['fetch'];
+export function help() {
+    return renderHelp({
+        description: 'Fetch packages from a lockfile into virtual store, package manifest is ignored. WARNING! This is an experimental command. Breaking changes may be introduced in non-major versions of the CLI',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Only development packages will be fetched',
+                        name: '--dev',
+                        shortAlias: '-D',
+                    },
+                    {
+                        description: 'Development packages will not be fetched',
+                        name: '--prod',
+                        shortAlias: '-P',
+                    },
+                    ...UNIVERSAL_OPTIONS,
+                ],
+            },
+        ],
+        url: docsUrl('fetch'),
+        usages: ['pnpm fetch [--dev | --prod]'],
+    });
+}
+export async function handler(opts) {
+    const store = await createStoreController(opts);
+    const include = {
+        dependencies: opts.production !== false,
+        devDependencies: opts.dev !== false,
+        // when including optional deps, production is also required when perform headless install
+        optionalDependencies: opts.production !== false,
+    };
+    await mutateModulesInSingleProject({
+        manifest: {},
+        mutation: 'install',
+        pruneDirectDependencies: true,
+        rootDir: process.cwd(),
+    }, {
+        ...opts,
+        ignorePackageManifest: true,
+        ignoreLocalPackages: true,
+        include,
+        modulesCacheMaxAge: 0,
+        pruneStore: true,
+        storeController: store.ctrl,
+        storeDir: store.dir,
+        // Hoisting is skipped anyway,
+        // so we store these empty patterns in node_modules/.modules.yaml
+        // to let the subsequent install know that hoisting should be performed.
+        hoistPattern: [],
+        publicHoistPattern: [],
+        // virtualStoreOnly skips post-import linking (symlinks, bins, hoisting)
+        // even if ignorePackageManifest handling changes in the future.
+        virtualStoreOnly: true,
+        // Ensure fetch can populate the virtual store even when the user has
+        // enable-modules-dir=false in their config — fetch always needs node_modules/.pnpm
+        // (unless GVS is active, in which case enableModulesDir doesn't matter).
+        enableModulesDir: true,
+    });
+}
+//# sourceMappingURL=fetch.js.map

package/lib/getFetchFullMetadata.d.ts

@@ -0,0 +1,8 @@
+import type { InstallCommandOptions } from './install.js';
+export type GetFetchFullMetadataOptions = Pick<InstallCommandOptions, 'supportedArchitectures'>;
+/**
+ * This function is a workaround for the fact that npm registry's abbreviated metadata currently does not contain `libc`.
+ *
+ * See <https://github.com/pnpm/pnpm/issues/7362#issuecomment-1971964689>.
+ */
+export declare const getFetchFullMetadata: (opts: GetFetchFullMetadataOptions) => true | undefined;

package/lib/getFetchFullMetadata.js

@@ -0,0 +1,7 @@
+/**
+ * This function is a workaround for the fact that npm registry's abbreviated metadata currently does not contain `libc`.
+ *
+ * See <https://github.com/pnpm/pnpm/issues/7362#issuecomment-1971964689>.
+ */
+export const getFetchFullMetadata = (opts) => opts.supportedArchitectures?.libc && true;
+//# sourceMappingURL=getFetchFullMetadata.js.map

package/lib/getPinnedVersion.d.ts

@@ -0,0 +1,4 @@
+export declare function getPinnedVersion(opts: {
+    saveExact?: boolean;
+    savePrefix?: string;
+}): 'major' | 'minor' | 'patch';

package/lib/getPinnedVersion.js

@@ -0,0 +1,6 @@
+export function getPinnedVersion(opts) {
+    if (opts.saveExact === true || opts.savePrefix === '')
+        return 'patch';
+    return opts.savePrefix === '~' ? 'minor' : 'major';
+}
+//# sourceMappingURL=getPinnedVersion.js.map

package/lib/getSaveType.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from '@pnpm/config.reader';
+import type { DependenciesField } from '@pnpm/types';
+export declare function getSaveType(opts: Pick<Config, 'saveDev' | 'saveOptional' | 'saveProd' | 'savePeer'>): DependenciesField | undefined;

package/lib/getSaveType.js

@@ -0,0 +1,10 @@
+export function getSaveType(opts) {
+    if (opts.saveDev === true || opts.savePeer)
+        return 'devDependencies';
+    if (opts.saveOptional)
+        return 'optionalDependencies';
+    if (opts.saveProd)
+        return 'dependencies';
+    return undefined;
+}
+//# sourceMappingURL=getSaveType.js.map

package/lib/import/index.d.ts

@@ -0,0 +1,9 @@
+import type { Config } from '@pnpm/config.reader';
+import { type InstallOptions } from '@pnpm/installing.deps-installer';
+import { type CreateStoreControllerOptions } from '@pnpm/store.connection-manager';
+export declare const rcOptionsTypes: typeof cliOptionsTypes;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare function help(): string;
+export declare const commandNames: string[];
+export type ImportCommandOptions = Pick<Config, 'allProjects' | 'allProjectsGraph' | 'selectedProjectsGraph' | 'workspaceDir' | 'ignoreWorkspaceCycles' | 'disallowWorkspaceCycles' | 'sharedWorkspaceLockfile' | 'workspacePackagePatterns' | 'rootProjectManifest' | 'rootProjectManifestDir'> & CreateStoreControllerOptions & Omit<InstallOptions, 'storeController' | 'lockfileOnly' | 'preferredVersions'>;
+export declare function handler(opts: ImportCommandOptions, params: string[]): Promise<void>;