@rushstack/rush-sdk 5.91.0 → 5.92.0

package/lib/api/RushConfigurationProject.d.ts

@@ -0,0 +1,217 @@
+import { IPackageJson } from '@rushstack/node-core-library';
+import { RushConfiguration } from '../api/RushConfiguration';
+import { VersionPolicy } from './VersionPolicy';
+import type { PackageJsonEditor } from './PackageJsonEditor';
+/**
+ * This represents the JSON data object for a project entry in the rush.json configuration file.
+ */
+export interface IRushConfigurationProjectJson {
+    packageName: string;
+    projectFolder: string;
+    reviewCategory?: string;
+    decoupledLocalDependencies: string[];
+    cyclicDependencyProjects?: string[];
+    versionPolicyName?: string;
+    shouldPublish?: boolean;
+    skipRushCheck?: boolean;
+    publishFolder?: string;
+    tags?: string[];
+}
+/**
+ * @internal
+ */
+export interface IRushConfigurationProjectOptions {
+    /**
+     * The raw JSON representation from rush.json
+     */
+    projectJson: IRushConfigurationProjectJson;
+    /**
+     * The enclosing configuration
+     */
+    rushConfiguration: RushConfiguration;
+    /**
+     * A unique string name for this project
+     */
+    tempProjectName: string;
+    /**
+     * If specified, validate project tags against this list.
+     */
+    allowedProjectTags: Set<string> | undefined;
+}
+/**
+ * This represents the configuration of a project that is built by Rush, based on
+ * the Rush.json configuration file.
+ * @public
+ */
+export declare class RushConfigurationProject {
+    private readonly _shouldPublish;
+    private _versionPolicy;
+    private _dependencyProjects;
+    private _consumingProjects;
+    private _packageJson;
+    /**
+     * The name of the NPM package.  An error is reported if this name is not
+     * identical to packageJson.name.
+     *
+     * Example: `@scope/MyProject`
+     */
+    readonly packageName: string;
+    /**
+     * The full path of the folder that contains the project to be built by Rush.
+     *
+     * Example: `C:\MyRepo\libraries\my-project`
+     */
+    readonly projectFolder: string;
+    /**
+     * The relative path of the folder that contains the project to be built by Rush.
+     *
+     * Example: `libraries/my-project`
+     */
+    readonly projectRelativeFolder: string;
+    /**
+     * The project-specific Rush configuration folder.
+     *
+     * Example: `C:\MyRepo\libraries\my-project\config\rush`
+     */
+    readonly projectRushConfigFolder: string;
+    /**
+     * The project-specific Rush temp folder. This folder is used to store Rush-specific temporary files.
+     *
+     * Example: `C:\MyRepo\libraries\my-project\.rush\temp`
+     */
+    readonly projectRushTempFolder: string;
+    /**
+     * The Rush configuration for the monorepo that the project belongs to.
+     */
+    readonly rushConfiguration: RushConfiguration;
+    /**
+     * The review category name, or undefined if no category was assigned.
+     * This name must be one of the valid choices listed in RushConfiguration.reviewCategories.
+     */
+    readonly reviewCategory: string | undefined;
+    /**
+     * A list of local projects that appear as devDependencies for this project, but cannot be
+     * locally linked because it would create a cyclic dependency; instead, the last published
+     * version will be installed in the Common folder.
+     *
+     * These are package names that would be found by RushConfiguration.getProjectByName().
+     */
+    readonly decoupledLocalDependencies: Set<string>;
+    /**
+     * The parsed NPM "package.json" file from projectFolder.
+     */
+    get packageJson(): IPackageJson;
+    /**
+     * A useful wrapper around the package.json file for making modifications
+     * @beta
+     */
+    readonly packageJsonEditor: PackageJsonEditor;
+    /**
+     * The unique name for the temporary project that will be generated in the Common folder.
+     * For example, if the project name is `@scope/MyProject`, the temporary project name
+     * might be `@rush-temp/MyProject-2`.
+     *
+     * Example: `@rush-temp/MyProject-2`
+     */
+    readonly tempProjectName: string;
+    /**
+     * The unscoped temporary project name
+     *
+     * Example: `my-project-2`
+     */
+    readonly unscopedTempProjectName: string;
+    /**
+     * If true, then this project will be ignored by the "rush check" command.
+     * The default value is false.
+     */
+    readonly skipRushCheck: boolean;
+    /**
+     * Name of the version policy used by this project.
+     * @beta
+     */
+    readonly versionPolicyName: string | undefined;
+    /**
+     * The full path of the folder that will get published by Rush.
+     *
+     * @remarks
+     * By default this is the same as the project folder, but a custom folder can be specified
+     * using the the "publishFolder" setting in rush.json.
+     *
+     * Example: `C:\MyRepo\libraries\my-project\temp\publish`
+     */
+    readonly publishFolder: string;
+    /**
+     * An optional set of custom tags that can be used to select this project.
+     *
+     * @remarks
+     * For example, adding `my-custom-tag` will allow this project to be selected by the
+     * command `rush list --only tag:my-custom-tag`.  The tag name must be one or more words separated
+     * by hyphens, where a word may contain lowercase letters, digits, and the period character.
+     *
+     * @beta
+     */
+    readonly tags: ReadonlySet<string>;
+    /** @internal */
+    constructor(options: IRushConfigurationProjectOptions);
+    /**
+     * A list of local projects that appear as devDependencies for this project, but cannot be
+     * locally linked because it would create a cyclic dependency; instead, the last published
+     * version will be installed in the Common folder.
+     *
+     * These are package names that would be found by RushConfiguration.getProjectByName().
+     *
+     * @deprecated Use `decoupledLocalDependencies` instead, as it better describes the purpose of the data.
+     */
+    get cyclicDependencyProjects(): Set<string>;
+    /**
+     * An array of projects within the Rush configuration which directly depend on this package.
+     * @deprecated Use `consumingProjectNames` instead, as it has Set semantics, which better reflect the nature
+     * of the data.
+     */
+    get downstreamDependencyProjects(): string[];
+    /**
+     * An array of projects within the Rush configuration which this project declares as dependencies.
+     * @deprecated Use `dependencyProjects` instead, as it has Set semantics, which better reflect the nature
+     * of the data.
+     */
+    get localDependencyProjects(): ReadonlyArray<RushConfigurationProject>;
+    /**
+     * The set of projects within the Rush configuration which this project declares as dependencies.
+     *
+     * @remarks
+     * Can be used recursively to walk the project dependency graph to find all projects that are directly or indirectly
+     * referenced from this project.
+     */
+    get dependencyProjects(): ReadonlySet<RushConfigurationProject>;
+    /**
+     * The set of projects within the Rush configuration which declare this project as a dependency.
+     * Excludes those that declare this project as a `cyclicDependencyProject`.
+     *
+     * @remarks
+     * This field is the counterpart to `dependencyProjects`, and can be used recursively to walk the project dependency
+     * graph to find all projects which will be impacted by changes to this project.
+     */
+    get consumingProjects(): ReadonlySet<RushConfigurationProject>;
+    /**
+     * A flag which indicates whether changes to this project should be published. This controls
+     * whether or not the project would show up when running `rush change`, and whether or not it
+     * should be published during `rush publish`.
+     */
+    get shouldPublish(): boolean;
+    /**
+     * Version policy of the project
+     * @beta
+     */
+    get versionPolicy(): VersionPolicy | undefined;
+    /**
+     * Indicate whether this project is the main project for the related version policy.
+     *
+     * False if the project is not for publishing.
+     * True if the project is individually versioned or if its lockstep version policy does not specify main project.
+     * False if the project is lockstepped and is not the main project for its version policy.
+     *
+     * @beta
+     */
+    get isMainProject(): boolean;
+}
+//# sourceMappingURL=RushConfigurationProject.d.ts.map

package/lib/api/RushConfigurationProject.js

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

package/lib/api/RushGlobalFolder.d.ts

@@ -0,0 +1,32 @@
+/**
+ * This class provides global folders that are used for rush's internal install locations.
+ *
+ * @internal
+ */
+export declare class RushGlobalFolder {
+    /**
+     * The global folder where Rush stores temporary files.
+     *
+     * @remarks
+     *
+     * Most of the temporary files created by Rush are stored separately for each monorepo working folder,
+     * to avoid issues of concurrency and compatibility between tool versions.  However, a small set
+     * of files (e.g. installations of the `@microsoft/rush-lib` engine and the package manager) are stored
+     * in a global folder to speed up installations.  The default location is `~/.rush` on POSIX-like
+     * operating systems or `C:\Users\YourName` on Windows.
+     *
+     * You can use the {@link EnvironmentVariableNames.RUSH_GLOBAL_FOLDER} environment  variable to specify
+     * a different folder path.  This is useful for example if a Windows group policy forbids executing scripts
+     * installed in a user's home directory.
+     *
+     * POSIX is a registered trademark of the Institute of Electrical and Electronic Engineers, Inc.
+     */
+    readonly path: string;
+    /**
+     * The absolute path to Rush's storage in the home directory for the current user and node version.
+     * On Windows, it would be something like `C:\Users\YourName\.rush\node-v3.4.5`.
+     */
+    readonly nodeSpecificPath: string;
+    constructor();
+}
+//# sourceMappingURL=RushGlobalFolder.d.ts.map

package/lib/api/RushGlobalFolder.js

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

package/lib/api/RushInternals.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Used by rush-sdk to access internals of rush-lib.
+ * @internal
+ */
+export declare class RushInternals {
+    /**
+     * Used by rush-sdk to load an internal API specified by its module path.
+     *
+     * @param srcImportPath - The module path to load.  For example, to refer to `src/api/ChangeFile.ts`,
+     * the `srcImportPath` would be `"api/ChangeFile"`.
+     * @returns the module object as would be returned by `require()`
+     */
+    static loadModule(srcImportPath: string): unknown;
+}
+//# sourceMappingURL=RushInternals.d.ts.map

package/lib/api/RushInternals.js

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

package/lib/api/RushPluginsConfiguration.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @internal
+ */
+export interface IRushPluginConfigurationBase {
+    packageName: string;
+    pluginName: string;
+}
+export interface IRushPluginConfiguration extends IRushPluginConfigurationBase {
+    autoinstallerName: string;
+}
+interface IRushPluginsConfigurationJson {
+    plugins: IRushPluginConfiguration[];
+}
+export declare class RushPluginsConfiguration {
+    private static _jsonSchema;
+    private _jsonFilename;
+    readonly configuration: Readonly<IRushPluginsConfigurationJson>;
+    constructor(jsonFilename: string);
+}
+export {};
+//# sourceMappingURL=RushPluginsConfiguration.d.ts.map

package/lib/api/RushPluginsConfiguration.js

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

package/lib/api/RushProjectConfiguration.d.ts

@@ -0,0 +1,117 @@
+import { ITerminal } from '@rushstack/node-core-library';
+import { RushConfigurationProject } from './RushConfigurationProject';
+import type { IPhase } from './CommandLineConfiguration';
+/**
+ * Describes the file structure for the "<project root>/config/rush-project.json" config file.
+ */
+export interface IRushProjectJson {
+    /**
+     * The incremental analyzer can skip Rush commands for projects whose input files have
+     * not changed since the last build. Normally, every Git-tracked file under the project
+     * folder is assumed to be an input. Set incrementalBuildIgnoredGlobs to ignore specific
+     * files, specified as globs relative to the project folder. The list of file globs will
+     * be interpreted the same way your .gitignore file is.
+     */
+    incrementalBuildIgnoredGlobs?: string[];
+    /**
+     * Disable caching for this project. The project will never be restored from cache.
+     * This may be useful if this project affects state outside of its folder.
+     *
+     * This option is only used when the build cache is enabled for the repo. You can set
+     * disableBuildCacheForProject=true to disable caching for a specific project. This is a useful workaround
+     * if that project's build scripts violate the assumptions of the cache, for example by writing
+     * files outside the project folder. Where possible, a better solution is to improve the build scripts
+     * to be compatible with caching.
+     */
+    disableBuildCacheForProject?: boolean;
+    operationSettings?: IOperationSettings[];
+}
+export interface IOperationSettings {
+    /**
+     * The name of the operation. This should be a key in the `package.json`'s `scripts` object.
+     */
+    operationName: string;
+    /**
+     * Specify the folders where this operation writes its output files. If enabled, the Rush build
+     * cache will restore these folders from the cache. The strings are folder names under the project
+     * root folder.
+     *
+     * These folders should not be tracked by Git. They must not contain symlinks.
+     */
+    outputFolderNames?: string[];
+    /**
+     * Disable caching for this operation. The operation will never be restored from cache.
+     * This may be useful if this operation affects state outside of its folder.
+     *
+     * This option is only used when the build cache is enabled for the repo. You can set
+     * disableBuildCacheForOperation=true to disable caching for a specific project operation.
+     * This is a useful workaround if that project's build scripts violate the assumptions of the cache,
+     * for example by writing files outside the project folder. Where possible, a better solution is to improve
+     * the build scripts to be compatible with caching.
+     */
+    disableBuildCacheForOperation?: boolean;
+    /**
+     * An optional list of environment variables that can affect this operation. The values of
+     * these environment variables will become part of the hash when reading and writing the build cache.
+     *
+     * Note: generally speaking, all environment variables available to Rush are also available to any
+     * operations performed -- Rush assumes that environment variables do not affect build outputs unless
+     * you list them here.
+     */
+    dependsOnEnvVars?: string[];
+    /**
+     * An optional list of glob (minimatch) patterns pointing to files that can affect this operation.
+     * The hash values of the contents of these files will become part of the final hash when reading
+     * and writing the build cache.
+     *
+     * Note: if a particular file will be matched by patterns provided by both `incrementalBuildIgnoredGlobs` and
+     * `dependsOnAdditionalFiles` options - `dependsOnAdditionalFiles` will win and the file will be included
+     * calculating final hash value when reading and writing the build cache
+     */
+    dependsOnAdditionalFiles?: string[];
+}
+/**
+ * Use this class to load the "config/rush-project.json" config file.
+ *
+ * This file provides project-specific configuration options.
+ * @public
+ */
+export declare class RushProjectConfiguration {
+    private static readonly _configCache;
+    readonly project: RushConfigurationProject;
+    /**
+     * {@inheritdoc IRushProjectJson.incrementalBuildIgnoredGlobs}
+     */
+    readonly incrementalBuildIgnoredGlobs: ReadonlyArray<string>;
+    /**
+     * {@inheritdoc IRushProjectJson.disableBuildCacheForProject}
+     */
+    readonly disableBuildCacheForProject: boolean;
+    readonly operationSettingsByOperationName: ReadonlyMap<string, Readonly<IOperationSettings>>;
+    private readonly _validationCache;
+    private constructor();
+    /**
+     * Validates that the requested phases are compatible.
+     * Deferral of this logic to its own method means that Rush no longer eagerly validates
+     * all defined commands in command-line.json. As such, while validation will be run for a given
+     * command upon invoking that command, defining overlapping phases in "rush custom-command"
+     * that are not used by "rush build" will not cause "rush build" to exit with an error.
+     */
+    validatePhaseConfiguration(phases: Iterable<IPhase>, terminal: ITerminal): void;
+    /**
+     * Loads the rush-project.json data for the specified project.
+     */
+    static tryLoadForProjectAsync(project: RushConfigurationProject, terminal: ITerminal): Promise<RushProjectConfiguration | undefined>;
+    /**
+     * Load only the `incrementalBuildIgnoredGlobs` property from the rush-project.json file, skipping
+     * validation of other parts of the config file.
+     *
+     * @remarks
+     * This function exists to allow the ProjectChangeAnalyzer to load just the ignore globs without
+     * having to validate the rest of the `rush-project.json` file against the repo's command-line configuration.
+     */
+    static tryLoadIgnoreGlobsForProjectAsync(project: RushConfigurationProject, terminal: ITerminal): Promise<ReadonlyArray<string> | undefined>;
+    private static _tryLoadJsonForProjectAsync;
+    private static _getRushProjectConfiguration;
+}
+//# sourceMappingURL=RushProjectConfiguration.d.ts.map

package/lib/api/RushProjectConfiguration.js

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

package/lib/api/RushUserConfiguration.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Rush per-user configuration data.
+ *
+ * @beta
+ */
+export declare class RushUserConfiguration {
+    private static _schema;
+    /**
+     * If provided, store build cache in the specified folder. Must be an absolute path.
+     */
+    readonly buildCacheFolder: string | undefined;
+    private constructor();
+    static initializeAsync(): Promise<RushUserConfiguration>;
+    static getRushUserFolderPath(): string;
+}
+//# sourceMappingURL=RushUserConfiguration.d.ts.map

package/lib/api/RushUserConfiguration.js

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

package/lib/api/SaveCallbackPackageJsonEditor.d.ts

@@ -0,0 +1,14 @@
+import { IPackageJson } from '@rushstack/node-core-library';
+import { PackageJsonEditor } from './PackageJsonEditor';
+export interface IFromObjectOptions {
+    object: IPackageJson;
+    filename: string;
+    onSaved?: (newObject: IPackageJson) => void;
+}
+export declare class SaveCallbackPackageJsonEditor extends PackageJsonEditor {
+    private readonly _onSaved;
+    private constructor();
+    static fromObjectWithCallback(options: IFromObjectOptions): SaveCallbackPackageJsonEditor;
+    saveIfModified(): boolean;
+}
+//# sourceMappingURL=SaveCallbackPackageJsonEditor.d.ts.map

package/lib/api/SaveCallbackPackageJsonEditor.js

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

package/lib/api/Variants.d.ts

@@ -0,0 +1,11 @@
+import { ICommandLineStringDefinition } from '@rushstack/ts-command-line';
+/**
+ * Namespace for utilities relating to the Variants feature.
+ */
+export declare class Variants {
+    /**
+     * Provides the parameter configuration for '--variant'.
+     */
+    static readonly VARIANT_PARAMETER: ICommandLineStringDefinition;
+}
+//# sourceMappingURL=Variants.d.ts.map

package/lib/api/Variants.js

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

package/lib/api/VersionPolicy.d.ts

@@ -0,0 +1,203 @@
+import { IPackageJson } from '@rushstack/node-core-library';
+import { IVersionPolicyJson, ILockStepVersionJson, IIndividualVersionJson } from './VersionPolicyConfiguration';
+import { RushConfiguration } from './RushConfiguration';
+/**
+ * Type of version bumps
+ * @public
+ */
+export declare enum BumpType {
+    'none' = 0,
+    'prerelease' = 1,
+    'patch' = 2,
+    'preminor' = 3,
+    'minor' = 4,
+    'major' = 5
+}
+/**
+ * Version policy base type names
+ * @public
+ */
+export declare enum VersionPolicyDefinitionName {
+    'lockStepVersion' = 0,
+    'individualVersion' = 1
+}
+/**
+ * This is the base class for version policy which controls how versions get bumped.
+ * @public
+ */
+export declare abstract class VersionPolicy {
+    private _versionFormatForCommit;
+    private _versionFormatForPublish;
+    /**
+     * Version policy name
+     */
+    readonly policyName: string;
+    /**
+     * Version policy definition name
+     */
+    readonly definitionName: VersionPolicyDefinitionName;
+    /**
+     * Determines if a version policy wants to opt out of changelog files.
+     */
+    readonly exemptFromRushChange: boolean;
+    /**
+     * Determines if a version policy wants to opt in to including email.
+     */
+    readonly includeEmailInChangeFile: boolean;
+    /**
+     * @internal
+     */
+    constructor(versionPolicyJson: IVersionPolicyJson);
+    /**
+     * Loads from version policy json
+     *
+     * @param versionPolicyJson - version policy Json
+     *
+     * @internal
+     */
+    static load(versionPolicyJson: IVersionPolicyJson): VersionPolicy | undefined;
+    /**
+     * Whether it is a lockstepped version policy
+     */
+    get isLockstepped(): boolean;
+    /**
+     * Returns an updated package json that satisfies the policy.
+     *
+     * @param project - package json
+     * @param force - force update even when the project version is higher than the policy version.
+     */
+    abstract ensure(project: IPackageJson, force?: boolean): IPackageJson | undefined;
+    /**
+     * Bumps version based on the policy
+     *
+     * @param bumpType - (optional) override bump type
+     * @param identifier - (optional) override prerelease Id
+     */
+    abstract bump(bumpType?: BumpType, identifier?: string): void;
+    /**
+     * Serialized json for the policy
+     *
+     * @internal
+     */
+    abstract get _json(): IVersionPolicyJson;
+    /**
+     * Validates the specified version and throws if the version does not satisfy the policy.
+     *
+     * @param versionString - version string
+     * @param packageName - package name
+     */
+    abstract validate(versionString: string, packageName: string): void;
+    /**
+     * Tells the version policy to modify any dependencies in the target package
+     * to values used for publishing.
+     */
+    setDependenciesBeforePublish(packageName: string, configuration: RushConfiguration): void;
+    /**
+     * Tells the version policy to modify any dependencies in the target package
+     * to values used for checked-in source.
+     */
+    setDependenciesBeforeCommit(packageName: string, configuration: RushConfiguration): void;
+}
+/**
+ * This policy indicates all related projects should use the same version.
+ * @public
+ */
+export declare class LockStepVersionPolicy extends VersionPolicy {
+    private _version;
+    /**
+     * The type of bump for next bump.
+     */
+    readonly nextBump: BumpType | undefined;
+    /**
+     * The main project for the version policy.
+     *
+     * If the value is provided, change logs will only be generated in that project.
+     * If the value is not provided, change logs will be hosted in each project associated with the policy.
+     */
+    readonly mainProject: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(versionPolicyJson: ILockStepVersionJson);
+    /**
+     * The value of the lockstep version
+     */
+    get version(): string;
+    /**
+     * Serialized json for this policy
+     *
+     * @internal
+     */
+    get _json(): ILockStepVersionJson;
+    /**
+     * Returns an updated package json that satisfies the version policy.
+     *
+     * @param project - input package json
+     * @param force - force update even when the project version is higher than the policy version.
+     */
+    ensure(project: IPackageJson, force?: boolean): IPackageJson | undefined;
+    /**
+     * Bumps the version of the lockstep policy
+     *
+     * @param bumpType - Overwrite bump type in version-policy.json with the provided value.
+     * @param identifier - Prerelease identifier if bump type is prerelease.
+     */
+    bump(bumpType?: BumpType, identifier?: string): void;
+    /**
+     * Updates the version of the policy directly with a new value
+     * @param newVersionString - New version
+     */
+    update(newVersionString: string): boolean;
+    /**
+     * Validates the specified version and throws if the version does not satisfy lockstep version.
+     *
+     * @param versionString - version string
+     * @param packageName - package name
+     */
+    validate(versionString: string, packageName: string): void;
+    private _updatePackageVersion;
+    private _getReleaseType;
+}
+/**
+ * This policy indicates all related projects get version bump driven by their own changes.
+ * @public
+ */
+export declare class IndividualVersionPolicy extends VersionPolicy {
+    /**
+     * The major version that has been locked
+     */
+    readonly lockedMajor: number | undefined;
+    /**
+     * @internal
+     */
+    constructor(versionPolicyJson: IIndividualVersionJson);
+    /**
+     * Serialized json for this policy
+     *
+     * @internal
+     */
+    get _json(): IIndividualVersionJson;
+    /**
+     * Returns an updated package json that satisfies the version policy.
+     *
+     * @param project - input package json
+     * @param force - force update even when the project version is higher than the policy version.
+     */
+    ensure(project: IPackageJson, force?: boolean): IPackageJson | undefined;
+    /**
+     * Bumps version.
+     * Individual version policy lets change files drive version bump. This method currently does not do anything.
+     *
+     * @param bumpType - bump type
+     * @param identifier - prerelease id
+     */
+    bump(bumpType?: BumpType, identifier?: string): void;
+    /**
+     * Validates the specified version and throws if the version does not satisfy the policy.
+     *
+     * @param versionString - version string
+     * @param packageName - package name
+     */
+    validate(versionString: string, packageName: string): void;
+}
+//# sourceMappingURL=VersionPolicy.d.ts.map