@rushstack/rush-sdk 5.90.2 → 5.92.0

package/lib/logic/pnpm/PnpmOptionsConfiguration.d.ts

@@ -0,0 +1,242 @@
+import { IPackageManagerOptionsJsonBase, PackageManagerOptionsConfigurationBase } from '../base/BasePackageManagerOptionsConfiguration';
+/**
+ * This represents the available PNPM store options
+ * @public
+ */
+export declare type PnpmStoreOptions = 'local' | 'global';
+/**
+ * @beta
+ */
+export interface IPnpmPeerDependencyRules {
+    ignoreMissing?: string[];
+    allowAny?: string[];
+    allowedVersions?: Record<string, string>;
+}
+export interface IPnpmPeerDependenciesMeta {
+    [packageName: string]: {
+        optional?: boolean;
+    };
+}
+export interface IPnpmPackageExtension {
+    dependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    peerDependenciesMeta?: IPnpmPeerDependenciesMeta;
+}
+/**
+ * Part of IRushConfigurationJson.
+ * @internal
+ */
+export interface IPnpmOptionsJson extends IPackageManagerOptionsJsonBase {
+    /**
+     * {@inheritDoc PnpmOptionsConfiguration.pnpmStore}
+     */
+    pnpmStore?: PnpmStoreOptions;
+    /**
+     * {@inheritDoc PnpmOptionsConfiguration.strictPeerDependencies}
+     */
+    strictPeerDependencies?: boolean;
+    /**
+     * {@inheritDoc PnpmOptionsConfiguration.preventManualShrinkwrapChanges}
+     */
+    preventManualShrinkwrapChanges?: boolean;
+    /**
+     * {@inheritDoc PnpmOptionsConfiguration.useWorkspaces}
+     */
+    useWorkspaces?: boolean;
+    /**
+     * {@inheritDoc PnpmOptionsConfiguration.globalOverrides}
+     */
+    globalOverrides?: Record<string, string>;
+    /**
+     * {@inheritDoc PnpmOptionsConfiguration.globalPeerDependencyRules}
+     */
+    globalPeerDependencyRules?: IPnpmPeerDependencyRules;
+    /**
+     * {@inheritDoc PnpmOptionsConfiguration.globalPackageExtensions}
+     */
+    globalPackageExtensions?: Record<string, IPnpmPackageExtension>;
+    /**
+     * {@inheritDoc PnpmOptionsConfiguration.globalNeverBuiltDependencies}
+     */
+    globalNeverBuiltDependencies?: string[];
+    /**
+     * {@inheritDoc PnpmOptionsConfiguration.globalAllowedDeprecatedVersions}
+     */
+    globalAllowedDeprecatedVersions?: Record<string, string>;
+    /**
+     * {@inheritDoc PnpmOptionsConfiguration.globalPatchedDependencies}
+     */
+    globalPatchedDependencies?: Record<string, string>;
+    /**
+     * {@inheritDoc PnpmOptionsConfiguration.unsupportedPackageJsonSettings}
+     */
+    unsupportedPackageJsonSettings?: unknown;
+}
+/**
+ * Options that are only used when the PNPM package manager is selected.
+ * Use this class to load "common/config/rush/pnpm-config.json" file,
+ * or, load json from "pnpmOptions" field in "rush.json" for legacy support.
+ *
+ * @remarks
+ * It is valid to define these options in rush.json even if the PNPM package manager
+ * is not being used.
+ *
+ * @public
+ */
+export declare class PnpmOptionsConfiguration extends PackageManagerOptionsConfigurationBase {
+    private static _jsonSchema;
+    private readonly _json;
+    private _globalPatchedDependencies;
+    /**
+     * The method used to resolve the store used by PNPM.
+     *
+     * @remarks
+     * Available options:
+     *  - local: Use the standard Rush store path: common/temp/pnpm-store
+     *  - global: Use PNPM's global store path
+     */
+    readonly pnpmStore: PnpmStoreOptions;
+    /**
+     * The path for PNPM to use as the store directory.
+     *
+     * Will be overridden by environment variable RUSH_PNPM_STORE_PATH
+     */
+    readonly pnpmStorePath: string;
+    /**
+     * If true, then Rush will add the "--strict-peer-dependencies" option when invoking PNPM.
+     *
+     * @remarks
+     * This causes "rush install" to fail if there are unsatisfied peer dependencies, which is
+     * an invalid state that can cause build failures or incompatible dependency versions.
+     * (For historical reasons, JavaScript package managers generally do not treat this invalid state
+     * as an error.)
+     *
+     * The default value is false.  (For now.)
+     */
+    readonly strictPeerDependencies: boolean;
+    /**
+     * If true, then `rush install` will report an error if manual modifications
+     * were made to the PNPM shrinkwrap file without running `rush update` afterwards.
+     *
+     * @remarks
+     * This feature protects against accidental inconsistencies that may be introduced
+     * if the PNPM shrinkwrap file (`pnpm-lock.yaml`) is manually edited.  When this
+     * feature is enabled, `rush update` will write a hash of the shrinkwrap contents to repo-state.json,
+     * and then `rush update` and `rush install` will validate the hash.  Note that this does not prohibit
+     * manual modifications, but merely requires `rush update` be run
+     * afterwards, ensuring that PNPM can report or repair any potential inconsistencies.
+     *
+     * To temporarily disable this validation when invoking `rush install`, use the
+     * `--bypass-policy` command-line parameter.
+     *
+     * The default value is false.
+     */
+    readonly preventManualShrinkwrapChanges: boolean;
+    /**
+     * If true, then Rush will use the workspaces feature to install and link packages when invoking PNPM.
+     *
+     * @remarks
+     * The default value is true.  (For now.)
+     */
+    readonly useWorkspaces: boolean;
+    /**
+     * The "globalOverrides" setting provides a simple mechanism for overriding version selections
+     * for all dependencies of all projects in the monorepo workspace.  The settings are copied
+     * into the `pnpm.overrides` field of the `common/temp/package.json` file that is generated
+     * by Rush during installation.
+     *
+     * Order of precedence: `.pnpmfile.cjs` has the highest precedence, followed by
+     * `unsupportedPackageJsonSettings`, `globalPeerDependencyRules`, `globalPackageExtensions`,
+     * and `globalOverrides` has lowest precedence.
+     *
+     * PNPM documentation: https://pnpm.io/package_json#pnpmoverrides
+     */
+    readonly globalOverrides: Record<string, string> | undefined;
+    /**
+     * The `globalPeerDependencyRules` setting provides various settings for suppressing validation errors
+     * that are reported during installation with `strictPeerDependencies=true`.  The settings are copied
+     * into the `pnpm.peerDependencyRules` field of the `common/temp/package.json` file that is generated
+     * by Rush during installation.
+     *
+     * Order of precedence: `.pnpmfile.cjs` has the highest precedence, followed by
+     * `unsupportedPackageJsonSettings`, `globalPeerDependencyRules`, `globalPackageExtensions`,
+     * and `globalOverrides` has lowest precedence.
+     *
+     * https://pnpm.io/package_json#pnpmpeerdependencyrules
+     */
+    readonly globalPeerDependencyRules: IPnpmPeerDependencyRules | undefined;
+    /**
+     * The `globalPackageExtension` setting provides a way to patch arbitrary package.json fields
+     * for any PNPM dependency of the monorepo.  The settings are copied into the `pnpm.packageExtensions`
+     * field of the `common/temp/package.json` file that is generated by Rush during installation.
+     * The `globalPackageExtension` setting has similar capabilities as `.pnpmfile.cjs` but without
+     * the downsides of an executable script (nondeterminism, unreliable caching, performance concerns).
+     *
+     * Order of precedence: `.pnpmfile.cjs` has the highest precedence, followed by
+     * `unsupportedPackageJsonSettings`, `globalPeerDependencyRules`, `globalPackageExtensions`,
+     * and `globalOverrides` has lowest precedence.
+     *
+     * PNPM documentation: https://pnpm.io/package_json#pnpmpackageextensions
+     */
+    readonly globalPackageExtensions: Record<string, IPnpmPackageExtension> | undefined;
+    /**
+     * The `globalNeverBuiltDependencies` setting suppresses the `preinstall`, `install`, and `postinstall`
+     * lifecycle events for the specified NPM dependencies.  This is useful for scripts with poor practices
+     * such as downloading large binaries without retries or attempting to invoke OS tools such as
+     * a C++ compiler.  (PNPM's terminology refers to these lifecycle events as "building" a package;
+     * it has nothing to do with build system operations such as `rush build` or `rushx build`.)
+     * The settings are copied into the `pnpm.neverBuiltDependencies` field of the `common/temp/package.json`
+     * file that is generated by Rush during installation.
+     *
+     * PNPM documentation: https://pnpm.io/package_json#pnpmneverbuiltdependencies
+     */
+    readonly globalNeverBuiltDependencies: string[] | undefined;
+    /**
+     * The `globalAllowedDeprecatedVersions` setting suppresses installation warnings for package
+     * versions that the NPM registry reports as being deprecated.  This is useful if the
+     * deprecated package is an indirect dependency of an external package that has not released a fix.
+     * The settings are copied into the `pnpm.allowedDeprecatedVersions` field of the `common/temp/package.json`
+     * file that is generated by Rush during installation.
+     *
+     * PNPM documentation: https://pnpm.io/package_json#pnpmalloweddeprecatedversions
+     *
+     * If you are working to eliminate a deprecated version, it's better to specify `allowedDeprecatedVersions`
+     * in the package.json file for individual Rush projects.
+     */
+    readonly globalAllowedDeprecatedVersions: Record<string, string> | undefined;
+    /**
+     * (USE AT YOUR OWN RISK)  This is a free-form property bag that will be copied into
+     * the `common/temp/package.json` file that is generated by Rush during installation.
+     * This provides a way to experiment with new PNPM features.  These settings will override
+     * any other Rush configuration associated with a given JSON field except for `.pnpmfile.cjs`.
+     *
+     * USAGE OF THIS SETTING IS NOT SUPPORTED BY THE RUSH MAINTAINERS AND MAY CAUSE RUSH
+     * TO MALFUNCTION.  If you encounter a missing PNPM setting that you believe should
+     * be supported, please create a GitHub issue or PR.  Note that Rush does not aim to
+     * support every possible PNPM setting, but rather to promote a battle-tested installation
+     * strategy that is known to provide a good experience for large teams with lots of projects.
+     */
+    readonly unsupportedPackageJsonSettings: unknown | undefined;
+    readonly jsonFilename: string | undefined;
+    /**
+     * (GENERATED BY RUSH-PNPM PATCH-COMMIT) When modifying this property, make sure you know what you are doing.
+     *
+     * The `globalPatchedDependencies` is added/updated automatically when you run pnpm patch-commit
+     * command. It is a dictionary where the key should be the package name and exact version. The value
+     * should be a relative path to a patch file.
+     *
+     * PNPM documentation: https://pnpm.io/package_json#pnpmpatcheddependencies
+     */
+    get globalPatchedDependencies(): Record<string, string> | undefined;
+    private constructor();
+    /** @internal */
+    static loadFromJsonFileOrThrow(jsonFilename: string, commonTempFolder: string): PnpmOptionsConfiguration;
+    /** @internal */
+    static loadFromJsonObject(json: IPnpmOptionsJson, commonTempFolder: string): PnpmOptionsConfiguration;
+    /**
+     * Updates patchedDependencies field of the PNPM options in the common/config/rush/pnpm-config.json file.
+     */
+    updateGlobalPatchedDependencies(patchedDependencies: Record<string, string> | undefined): void;
+}
+//# sourceMappingURL=PnpmOptionsConfiguration.d.ts.map

package/lib/logic/pnpm/PnpmOptionsConfiguration.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/pnpm/PnpmOptionsConfiguration");

package/lib/logic/pnpm/PnpmProjectShrinkwrapFile.d.ts

@@ -0,0 +1,26 @@
+import { BaseProjectShrinkwrapFile } from '../base/BaseProjectShrinkwrapFile';
+import { PnpmShrinkwrapFile } from './PnpmShrinkwrapFile';
+/**
+ *
+ */
+export declare class PnpmProjectShrinkwrapFile extends BaseProjectShrinkwrapFile<PnpmShrinkwrapFile> {
+    /**
+     * Generate and write the project shrinkwrap file to <project>/.rush/temp/shrinkwrap-deps.json.
+     * @returns True if the project shrinkwrap was created or updated, false otherwise.
+     */
+    updateProjectShrinkwrapAsync(): Promise<void>;
+    hasChanges(otherShrinkwrap: PnpmProjectShrinkwrapFile): boolean;
+    /**
+     * Generate the project shrinkwrap file content
+     */
+    protected generateProjectShrinkwrapMap(): Map<string, string> | undefined;
+    protected generateWorkspaceProjectShrinkwrapMap(): Map<string, string> | undefined;
+    protected generateLegacyProjectShrinkwrapMap(): Map<string, string>;
+    private _addDependencyRecursive;
+    private _resolveAndAddPeerDependencies;
+    /**
+     * Save the current state of the object to project/.rush/temp/shrinkwrap-deps.json
+     */
+    protected saveAsync(projectShrinkwrapMap: Map<string, string>): Promise<void>;
+}
+//# sourceMappingURL=PnpmProjectShrinkwrapFile.d.ts.map

package/lib/logic/pnpm/PnpmProjectShrinkwrapFile.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/pnpm/PnpmProjectShrinkwrapFile");

package/lib/logic/pnpm/PnpmShrinkwrapFile.d.ts

@@ -0,0 +1,207 @@
+import { BaseShrinkwrapFile } from '../base/BaseShrinkwrapFile';
+import { DependencySpecifier } from '../DependencySpecifier';
+import { RushConfiguration } from '../../api/RushConfiguration';
+import { IShrinkwrapFilePolicyValidatorOptions } from '../policy/ShrinkwrapFilePolicy';
+import { IExperimentsJson } from '../../api/ExperimentsConfiguration';
+import { RushConfigurationProject } from '../../api/RushConfigurationProject';
+import { PnpmProjectShrinkwrapFile } from './PnpmProjectShrinkwrapFile';
+import { PackageManagerOptionsConfigurationBase } from '../base/BasePackageManagerOptionsConfiguration';
+export interface IPeerDependenciesMetaYaml {
+    optional?: boolean;
+}
+export interface IPnpmShrinkwrapDependencyYaml {
+    /** Information about the resolved package */
+    resolution?: {
+        /** The hash of the tarball, to ensure archive integrity */
+        integrity: string;
+        /** The name of the tarball, if this was from a TGX file */
+        tarball?: string;
+    };
+    /** The list of dependencies and the resolved version */
+    dependencies?: {
+        [dependency: string]: string;
+    };
+    /** The list of optional dependencies and the resolved version */
+    optionalDependencies?: {
+        [dependency: string]: string;
+    };
+    /** The list of peer dependencies and the resolved version */
+    peerDependencies?: {
+        [dependency: string]: string;
+    };
+    /**
+     * Used to indicate optional peer dependencies, as described in this RFC:
+     * https://github.com/yarnpkg/rfcs/blob/master/accepted/0000-optional-peer-dependencies.md
+     */
+    peerDependenciesMeta?: {
+        [dependency: string]: IPeerDependenciesMetaYaml;
+    };
+}
+export interface IPnpmShrinkwrapImporterYaml {
+    /** The list of resolved version numbers for direct dependencies */
+    dependencies?: {
+        [dependency: string]: string;
+    };
+    /** The list of resolved version numbers for dev dependencies */
+    devDependencies?: {
+        [dependency: string]: string;
+    };
+    /** The list of resolved version numbers for optional dependencies */
+    optionalDependencies?: {
+        [dependency: string]: string;
+    };
+    /** The list of specifiers used to resolve dependency versions */
+    specifiers: {
+        [dependency: string]: string;
+    };
+}
+/**
+ * This interface represents the raw pnpm-lock.YAML file
+ * Example:
+ *  {
+ *    "dependencies": {
+ *      "@rush-temp/project1": "file:./projects/project1.tgz"
+ *    },
+ *    "packages": {
+ *      "file:projects/library1.tgz": {
+ *        "dependencies: {
+ *          "markdown": "0.5.0"
+ *        },
+ *        "name": "@rush-temp/library1",
+ *        "resolution": {
+ *          "tarball": "file:projects/library1.tgz"
+ *        },
+ *        "version": "0.0.0"
+ *      },
+ *      "markdown/0.5.0": {
+ *        "resolution": {
+ *          "integrity": "sha1-KCBbVlqK51kt4gdGPWY33BgnIrI="
+ *        }
+ *      }
+ *    },
+ *    "registry": "http://localhost:4873/",
+ *    "shrinkwrapVersion": 3,
+ *    "specifiers": {
+ *      "@rush-temp/project1": "file:./projects/project1.tgz"
+ *    }
+ *  }
+ */
+export interface IPnpmShrinkwrapYaml {
+    /** The list of resolved version numbers for direct dependencies */
+    dependencies: {
+        [dependency: string]: string;
+    };
+    /** The list of importers for local workspace projects */
+    importers: {
+        [relativePath: string]: IPnpmShrinkwrapImporterYaml;
+    };
+    /** The description of the solved graph */
+    packages: {
+        [dependencyVersion: string]: IPnpmShrinkwrapDependencyYaml;
+    };
+    /** URL of the registry which was used */
+    registry: string;
+    /** The list of specifiers used to resolve direct dependency versions */
+    specifiers: {
+        [dependency: string]: string;
+    };
+}
+/**
+ * Given an encoded "dependency key" from the PNPM shrinkwrap file, this parses it into an equivalent
+ * DependencySpecifier.
+ *
+ * @returns a SemVer string, or undefined if the version specifier cannot be parsed
+ */
+export declare function parsePnpmDependencyKey(dependencyName: string, dependencyKey: string): DependencySpecifier | undefined;
+export declare class PnpmShrinkwrapFile extends BaseShrinkwrapFile {
+    readonly isWorkspaceCompatible: boolean;
+    readonly registry: string;
+    readonly dependencies: ReadonlyMap<string, string>;
+    readonly importers: ReadonlyMap<string, IPnpmShrinkwrapImporterYaml>;
+    readonly specifiers: ReadonlyMap<string, string>;
+    readonly packages: ReadonlyMap<string, IPnpmShrinkwrapDependencyYaml>;
+    private readonly _shrinkwrapJson;
+    private readonly _integrities;
+    private _pnpmfileConfiguration;
+    private constructor();
+    static loadFromFile(shrinkwrapYamlFilename: string): PnpmShrinkwrapFile | undefined;
+    static loadFromString(shrinkwrapContent: string): PnpmShrinkwrapFile;
+    getShrinkwrapHash(experimentsConfig?: IExperimentsJson): string;
+    /** @override */
+    validate(packageManagerOptionsConfig: PackageManagerOptionsConfigurationBase, policyOptions: IShrinkwrapFilePolicyValidatorOptions, experimentsConfig?: IExperimentsJson): void;
+    /** @override */
+    getTempProjectNames(): ReadonlyArray<string>;
+    /**
+     * Gets the path to the tarball file if the package is a tarball.
+     * Returns undefined if the package entry doesn't exist or the package isn't a tarball.
+     * Example of return value: file:projects/build-tools.tgz
+     */
+    getTarballPath(packageName: string): string | undefined;
+    getTopLevelDependencyKey(dependencyName: string): string | undefined;
+    /**
+     * Gets the version number from the list of top-level dependencies in the "dependencies" section
+     * of the shrinkwrap file. Sample return values:
+     *   '2.1.113'
+     *   '1.9.0-dev.27'
+     *   'file:projects/empty-webpart-project.tgz'
+     *   undefined
+     *
+     * @override
+     */
+    getTopLevelDependencyVersion(dependencyName: string): DependencySpecifier | undefined;
+    /**
+     * The PNPM shrinkwrap file has top-level dependencies on the temp projects like this:
+     *
+     * ```
+     * dependencies:
+     *   '@rush-temp/my-app': 'file:projects/my-app.tgz_25c559a5921686293a001a397be4dce0'
+     * packages:
+     *   /@types/node/10.14.15:
+     *     dev: false
+     *   'file:projects/my-app.tgz_25c559a5921686293a001a397be4dce0':
+     *     dev: false
+     *     name: '@rush-temp/my-app'
+     *     version: 0.0.0
+     * ```
+     *
+     * We refer to 'file:projects/my-app.tgz_25c559a5921686293a001a397be4dce0' as the temp project dependency key
+     * of the temp project '@rush-temp/my-app'.
+     */
+    getTempProjectDependencyKey(tempProjectName: string): string | undefined;
+    getShrinkwrapEntryFromTempProjectDependencyKey(tempProjectDependencyKey: string): IPnpmShrinkwrapDependencyYaml | undefined;
+    getShrinkwrapEntry(name: string, version: string): IPnpmShrinkwrapDependencyYaml | undefined;
+    /**
+     * Serializes the PNPM Shrinkwrap file
+     *
+     * @override
+     */
+    protected serialize(): string;
+    /**
+     * Gets the resolved version number of a dependency for a specific temp project.
+     * For PNPM, we can reuse the version that another project is using.
+     * Note that this function modifies the shrinkwrap data if tryReusingPackageVersionsFromShrinkwrap is set to true.
+     *
+     * @override
+     */
+    protected tryEnsureDependencyVersion(dependencySpecifier: DependencySpecifier, tempProjectName: string): DependencySpecifier | undefined;
+    /** @override */
+    findOrphanedProjects(rushConfiguration: RushConfiguration): ReadonlyArray<string>;
+    /** @override */
+    getProjectShrinkwrap(project: RushConfigurationProject): PnpmProjectShrinkwrapFile;
+    getImporterKeys(): Iterable<string>;
+    getImporterKeyByPath(workspaceRoot: string, projectFolder: string): string;
+    getImporter(importerKey: string): IPnpmShrinkwrapImporterYaml | undefined;
+    getIntegrityForImporter(importerKey: string): Map<string, string> | undefined;
+    /** @override */
+    isWorkspaceProjectModifiedAsync(project: RushConfigurationProject, variant?: string): Promise<boolean>;
+    private _getIntegrityForPackage;
+    private _addIntegrities;
+    /**
+     * Gets the package description for a tempProject from the shrinkwrap file.
+     */
+    private _getPackageDescription;
+    private _getPackageId;
+    private _parsePnpmDependencyKey;
+    private _serializeInternal;
+}
+//# sourceMappingURL=PnpmShrinkwrapFile.d.ts.map

package/lib/logic/pnpm/PnpmShrinkwrapFile.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/pnpm/PnpmShrinkwrapFile");

package/lib/logic/pnpm/PnpmYamlCommon.d.ts

@@ -0,0 +1,8 @@
+export interface IYamlDumpOptions {
+    lineWidth: number;
+    noCompatMode: boolean;
+    noRefs: boolean;
+    sortKeys: boolean;
+}
+export declare const PNPM_SHRINKWRAP_YAML_FORMAT: IYamlDumpOptions;
+//# sourceMappingURL=PnpmYamlCommon.d.ts.map

package/lib/logic/pnpm/PnpmYamlCommon.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/pnpm/PnpmYamlCommon");

package/lib/logic/pnpm/PnpmfileConfiguration.d.ts

@@ -0,0 +1,28 @@
+import { IPackageJson } from '@rushstack/node-core-library';
+import { RushConfiguration } from '../../api/RushConfiguration';
+/**
+ * Options used when generating the pnpmfile shim settings file.
+ */
+export interface IPnpmfileShimOptions {
+    /**
+     * The variant that the client pnpmfile will be sourced from.
+     */
+    variant?: string;
+}
+/**
+ * Loads PNPM's pnpmfile.js configuration, and invokes it to preprocess package.json files,
+ * optionally utilizing a pnpmfile shim to inject preferred versions.
+ */
+export declare class PnpmfileConfiguration {
+    private _context;
+    private constructor();
+    static initializeAsync(rushConfiguration: RushConfiguration, pnpmfileShimOptions?: IPnpmfileShimOptions): Promise<PnpmfileConfiguration>;
+    static writeCommonTempPnpmfileShimAsync(rushConfiguration: RushConfiguration, options?: IPnpmfileShimOptions): Promise<void>;
+    private static _getPnpmfileShimSettingsAsync;
+    /**
+     * Transform a package.json file using the pnpmfile.js hook.
+     * @returns the transformed object, or the original input if pnpmfile.js was not found.
+     */
+    transform(packageJson: IPackageJson): IPackageJson;
+}
+//# sourceMappingURL=PnpmfileConfiguration.d.ts.map

package/lib/logic/pnpm/PnpmfileConfiguration.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/pnpm/PnpmfileConfiguration");

package/lib/logic/pnpm/PnpmfileShim.d.ts

@@ -0,0 +1,3 @@
+import type { IPnpmfileHooks } from './IPnpmfile';
+export declare const hooks: IPnpmfileHooks;
+//# sourceMappingURL=PnpmfileShim.d.ts.map

package/lib/logic/pnpm/PnpmfileShim.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/pnpm/PnpmfileShim");

package/lib/logic/policy/GitEmailPolicy.d.ts

@@ -0,0 +1,6 @@
+import { RushConfiguration } from '../../api/RushConfiguration';
+export declare class GitEmailPolicy {
+    static validate(rushConfiguration: RushConfiguration): void;
+    static getEmailExampleLines(rushConfiguration: RushConfiguration): string[];
+}
+//# sourceMappingURL=GitEmailPolicy.d.ts.map

package/lib/logic/policy/GitEmailPolicy.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/policy/GitEmailPolicy");

package/lib/logic/policy/PolicyValidator.d.ts

@@ -0,0 +1,10 @@
+import { RushConfiguration } from '../../api/RushConfiguration';
+export interface IPolicyValidatorOptions {
+    bypassPolicy?: boolean;
+    allowShrinkwrapUpdates?: boolean;
+    shrinkwrapVariant?: string;
+}
+export declare class PolicyValidator {
+    static validatePolicy(rushConfiguration: RushConfiguration, options: IPolicyValidatorOptions): void;
+}
+//# sourceMappingURL=PolicyValidator.d.ts.map

package/lib/logic/policy/PolicyValidator.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/policy/PolicyValidator");

package/lib/logic/policy/ShrinkwrapFilePolicy.d.ts

@@ -0,0 +1,13 @@
+import { RushConfiguration } from '../../api/RushConfiguration';
+import { IPolicyValidatorOptions } from './PolicyValidator';
+import { RepoStateFile } from '../RepoStateFile';
+export interface IShrinkwrapFilePolicyValidatorOptions extends IPolicyValidatorOptions {
+    repoState: RepoStateFile;
+}
+/**
+ *  A policy that validates shrinkwrap files used by package managers.
+ */
+export declare class ShrinkwrapFilePolicy {
+    static validate(rushConfiguration: RushConfiguration, options: IPolicyValidatorOptions): void;
+}
+//# sourceMappingURL=ShrinkwrapFilePolicy.d.ts.map

package/lib/logic/policy/ShrinkwrapFilePolicy.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/policy/ShrinkwrapFilePolicy");

package/lib/logic/selectors/GitChangedProjectSelectorParser.d.ts

@@ -0,0 +1,23 @@
+import type { RushConfiguration } from '../../api/RushConfiguration';
+import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
+import { IEvaluateSelectorOptions, ISelectorParser } from './ISelectorParser';
+export interface IGitSelectorParserOptions {
+    /**
+     * If set to `true`, consider a project's external dependency installation layout as defined in the
+     * package manager lockfile when determining if it has changed.
+     */
+    includeExternalDependencies: boolean;
+    /**
+     * If set to `true` apply the `incrementalBuildIgnoredGlobs` property in a project's `rush-project.json`
+     * and exclude matched files from change detection.
+     */
+    enableFiltering: boolean;
+}
+export declare class GitChangedProjectSelectorParser implements ISelectorParser<RushConfigurationProject> {
+    private readonly _rushConfiguration;
+    private readonly _options;
+    constructor(rushConfiguration: RushConfiguration, options: IGitSelectorParserOptions);
+    evaluateSelectorAsync({ unscopedSelector, terminal }: IEvaluateSelectorOptions): Promise<Iterable<RushConfigurationProject>>;
+    getCompletions(): Iterable<string>;
+}
+//# sourceMappingURL=GitChangedProjectSelectorParser.d.ts.map

package/lib/logic/selectors/GitChangedProjectSelectorParser.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/selectors/GitChangedProjectSelectorParser");

package/lib/logic/selectors/ISelectorParser.d.ts

@@ -0,0 +1,11 @@
+import type { ITerminal } from '@rushstack/node-core-library';
+export interface IEvaluateSelectorOptions {
+    unscopedSelector: string;
+    terminal: ITerminal;
+    parameterName: string;
+}
+export interface ISelectorParser<T> {
+    evaluateSelectorAsync(options: IEvaluateSelectorOptions): Promise<Iterable<T>>;
+    getCompletions(): Iterable<string>;
+}
+//# sourceMappingURL=ISelectorParser.d.ts.map

package/lib/logic/selectors/ISelectorParser.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/selectors/ISelectorParser");

package/lib/logic/selectors/NamedProjectSelectorParser.d.ts

@@ -0,0 +1,10 @@
+import type { RushConfiguration } from '../../api/RushConfiguration';
+import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
+import type { IEvaluateSelectorOptions, ISelectorParser } from './ISelectorParser';
+export declare class NamedProjectSelectorParser implements ISelectorParser<RushConfigurationProject> {
+    private readonly _rushConfiguration;
+    constructor(rushConfiguration: RushConfiguration);
+    evaluateSelectorAsync({ unscopedSelector, terminal, parameterName }: IEvaluateSelectorOptions): Promise<Iterable<RushConfigurationProject>>;
+    getCompletions(): Iterable<string>;
+}
+//# sourceMappingURL=NamedProjectSelectorParser.d.ts.map

package/lib/logic/selectors/NamedProjectSelectorParser.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/selectors/NamedProjectSelectorParser");

package/lib/logic/selectors/TagProjectSelectorParser.d.ts

@@ -0,0 +1,10 @@
+import type { RushConfiguration } from '../../api/RushConfiguration';
+import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
+import type { IEvaluateSelectorOptions, ISelectorParser } from './ISelectorParser';
+export declare class TagProjectSelectorParser implements ISelectorParser<RushConfigurationProject> {
+    private readonly _rushConfiguration;
+    constructor(rushConfiguration: RushConfiguration);
+    evaluateSelectorAsync({ unscopedSelector, terminal, parameterName }: IEvaluateSelectorOptions): Promise<Iterable<RushConfigurationProject>>;
+    getCompletions(): Iterable<string>;
+}
+//# sourceMappingURL=TagProjectSelectorParser.d.ts.map

package/lib/logic/selectors/TagProjectSelectorParser.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/selectors/TagProjectSelectorParser");