@rushstack/rush-sdk 5.96.0 → 5.97.1-pr3949

package/dist/rush-lib.d.ts

@@ -210,6 +210,55 @@ export declare class ChangeManager {
  */
 export declare type CloudBuildCacheProviderFactory = (buildCacheJson: IBuildCacheJson) => ICloudBuildCacheProvider;
 
+/**
+ * Use this class to load and save the "common/config/rush/cobuild.json" config file.
+ * This file provides configuration options for the Rush Cobuild feature.
+ * @beta
+ */
+export declare class CobuildConfiguration {
+    private static _jsonSchema;
+    /**
+     * Indicates whether the cobuild feature is enabled.
+     * Typically it is enabled in the cobuild.json config file.
+     *
+     * Note: The orchestrator (or local users) should always have to opt into running with cobuilds by
+     * providing a cobuild context id. Even if cobuilds are "enabled" as a feature, they don't
+     * actually turn on for that particular build unless the cobuild context id is provided as an
+     * non-empty string.
+     */
+    readonly cobuildEnabled: boolean;
+    /**
+     * Cobuild context id
+     *
+     * @remarks
+     * The cobuild feature won't be enabled until the context id is provided as an non-empty string.
+     */
+    readonly cobuildContextId: string | undefined;
+    /**
+     * If true, Rush will automatically handle the leaf project with build cache "disabled" by writing
+     * to the cache in a special "log files only mode". This is useful when you want to use Cobuilds
+     * to improve the performance in CI validations and the leaf projects have not enabled cache.
+     */
+    readonly cobuildLeafProjectLogOnlyAllowed: boolean;
+    readonly cobuildLockProvider: ICobuildLockProvider;
+    private constructor();
+    /**
+     * Attempts to load the cobuild.json data from the standard file path `common/config/rush/cobuild.json`.
+     * If the file has not been created yet, then undefined is returned.
+     */
+    static tryLoadAsync(terminal: ITerminal, rushConfiguration: RushConfiguration, rushSession: RushSession): Promise<CobuildConfiguration | undefined>;
+    static getCobuildConfigFilePath(rushConfiguration: RushConfiguration): string;
+    private static _loadAsync;
+    get contextId(): string | undefined;
+    connectLockProviderAsync(): Promise<void>;
+    disconnectLockProviderAsync(): Promise<void>;
+}
+
+/**
+ * @beta
+ */
+export declare type CobuildLockProviderFactory = (cobuildJson: ICobuildJson) => ICobuildLockProvider;
+
 /**
  * Use this class to load and save the "common/config/rush/common-versions.json" config file.
  * This config file stores dependency version information that affects all projects in the repo.
@@ -339,6 +388,9 @@ export declare class EnvironmentConfiguration {
     private static _buildCacheCredential;
     private static _buildCacheEnabled;
     private static _buildCacheWriteAllowed;
+    private static _cobuildEnabled;
+    private static _cobuildContextId;
+    private static _cobuildLeafProjectLogOnlyAllowed;
     private static _gitBinaryPath;
     private static _tarBinaryPath;
     /**
@@ -394,6 +446,21 @@ export declare class EnvironmentConfiguration {
      * See {@link EnvironmentVariableNames.RUSH_BUILD_CACHE_WRITE_ALLOWED}
      */
     static get buildCacheWriteAllowed(): boolean | undefined;
+    /**
+     * If set, enables or disables the cobuild feature.
+     * See {@link EnvironmentVariableNames.RUSH_COBUILD_ENABLED}
+     */
+    static get cobuildEnabled(): boolean | undefined;
+    /**
+     * Provides a determined cobuild context id if configured
+     * See {@link EnvironmentVariableNames.RUSH_COBUILD_CONTEXT_ID}
+     */
+    static get cobuildContextId(): string | undefined;
+    /**
+     * If set, enables or disables the cobuild leaf project log only feature.
+     * See {@link EnvironmentVariableNames.RUSH_COBUILD_LEAF_PROJECT_LOG_ONLY_ALLOWED}
+     */
+    static get cobuildLeafProjectLogOnlyAllowed(): boolean | undefined;
     /**
      * Allows the git binary path to be explicitly provided.
      * See {@link EnvironmentVariableNames.RUSH_GIT_BINARY_PATH}
@@ -440,7 +507,7 @@ export declare class EnvironmentConfiguration {
  * Names of environment variables used by Rush.
  * @beta
  */
-export declare enum EnvironmentVariableNames {
+export declare const EnvironmentVariableNames: {
     /**
      * This variable overrides the temporary folder used by Rush.
      * The default value is "common/temp" under the repository root.
@@ -448,43 +515,43 @@ export declare enum EnvironmentVariableNames {
      * @remarks This environment variable is not compatible with workspace installs. If attempting
      * to move the PNPM store path, see the `RUSH_PNPM_STORE_PATH` environment variable.
      */
-    RUSH_TEMP_FOLDER = "RUSH_TEMP_FOLDER",
+    readonly RUSH_TEMP_FOLDER: "RUSH_TEMP_FOLDER";
     /**
      * This variable overrides the version of Rush that will be installed by
      * the version selector.  The default value is determined by the "rushVersion"
      * field from rush.json.
      */
-    RUSH_PREVIEW_VERSION = "RUSH_PREVIEW_VERSION",
+    readonly RUSH_PREVIEW_VERSION: "RUSH_PREVIEW_VERSION";
     /**
      * If this variable is set to "1", Rush will not fail the build when running a version
      * of Node that does not match the criteria specified in the "nodeSupportedVersionRange"
      * field from rush.json.
      */
-    RUSH_ALLOW_UNSUPPORTED_NODEJS = "RUSH_ALLOW_UNSUPPORTED_NODEJS",
+    readonly RUSH_ALLOW_UNSUPPORTED_NODEJS: "RUSH_ALLOW_UNSUPPORTED_NODEJS";
     /**
      * Setting this environment variable overrides the value of `allowWarningsInSuccessfulBuild`
      * in the `command-line.json` configuration file. Specify `1` to allow warnings in a successful build,
      * or `0` to disallow them. (See the comments in the command-line.json file for more information).
      */
-    RUSH_ALLOW_WARNINGS_IN_SUCCESSFUL_BUILD = "RUSH_ALLOW_WARNINGS_IN_SUCCESSFUL_BUILD",
+    readonly RUSH_ALLOW_WARNINGS_IN_SUCCESSFUL_BUILD: "RUSH_ALLOW_WARNINGS_IN_SUCCESSFUL_BUILD";
     /**
      * This variable selects a specific installation variant for Rush to use when installing
      * and linking package dependencies.
      * For more information, see the command-line help for the `--variant` parameter
      * and this article:  https://rushjs.io/pages/advanced/installation_variants/
      */
-    RUSH_VARIANT = "RUSH_VARIANT",
+    readonly RUSH_VARIANT: "RUSH_VARIANT";
     /**
      * Specifies the maximum number of concurrent processes to launch during a build.
      * For more information, see the command-line help for the `--parallelism` parameter for "rush build".
      */
-    RUSH_PARALLELISM = "RUSH_PARALLELISM",
+    readonly RUSH_PARALLELISM: "RUSH_PARALLELISM";
     /**
      * If this variable is set to "1", Rush will create symlinks with absolute paths instead
      * of relative paths. This can be necessary when a repository is moved during a build or
      * if parts of a repository are moved into a sandbox.
      */
-    RUSH_ABSOLUTE_SYMLINKS = "RUSH_ABSOLUTE_SYMLINKS",
+    readonly RUSH_ABSOLUTE_SYMLINKS: "RUSH_ABSOLUTE_SYMLINKS";
     /**
      * When using PNPM as the package manager, this variable can be used to configure the path that
      * PNPM will use as the store directory.
@@ -492,18 +559,18 @@ export declare enum EnvironmentVariableNames {
      * If a relative path is used, then the store path will be resolved relative to the process's
      * current working directory.  An absolute path is recommended.
      */
-    RUSH_PNPM_STORE_PATH = "RUSH_PNPM_STORE_PATH",
+    readonly RUSH_PNPM_STORE_PATH: "RUSH_PNPM_STORE_PATH";
     /**
      * When using PNPM as the package manager, this variable can be used to control whether or not PNPM
      * validates the integrity of the PNPM store during installation. The value of this environment variable must be
      * `1` (for true) or `0` (for false). If not specified, defaults to the value in .npmrc.
      */
-    RUSH_PNPM_VERIFY_STORE_INTEGRITY = "RUSH_PNPM_VERIFY_STORE_INTEGRITY",
+    readonly RUSH_PNPM_VERIFY_STORE_INTEGRITY: "RUSH_PNPM_VERIFY_STORE_INTEGRITY";
     /**
      * This environment variable can be used to specify the `--target-folder` parameter
      * for the "rush deploy" command.
      */
-    RUSH_DEPLOY_TARGET_FOLDER = "RUSH_DEPLOY_TARGET_FOLDER",
+    readonly RUSH_DEPLOY_TARGET_FOLDER: "RUSH_DEPLOY_TARGET_FOLDER";
     /**
      * Overrides the location of the `~/.rush` global folder where Rush stores temporary files.
      *
@@ -520,7 +587,7 @@ export declare enum EnvironmentVariableNames {
      *
      * POSIX is a registered trademark of the Institute of Electrical and Electronic Engineers, Inc.
      */
-    RUSH_GLOBAL_FOLDER = "RUSH_GLOBAL_FOLDER",
+    readonly RUSH_GLOBAL_FOLDER: "RUSH_GLOBAL_FOLDER";
     /**
      * Provides a credential for a remote build cache, if configured.  This credential overrides any cached credentials.
      *
@@ -534,7 +601,7 @@ export declare enum EnvironmentVariableNames {
      *
      * For information on SAS tokens, see here: https://docs.microsoft.com/en-us/azure/storage/common/storage-sas-overview
      */
-    RUSH_BUILD_CACHE_CREDENTIAL = "RUSH_BUILD_CACHE_CREDENTIAL",
+    readonly RUSH_BUILD_CACHE_CREDENTIAL: "RUSH_BUILD_CACHE_CREDENTIAL";
     /**
      * Setting this environment variable overrides the value of `buildCacheEnabled` in the `build-cache.json`
      * configuration file.
@@ -544,26 +611,49 @@ export declare enum EnvironmentVariableNames {
      *
      * If there is no build cache configured, then this environment variable is ignored.
      */
-    RUSH_BUILD_CACHE_ENABLED = "RUSH_BUILD_CACHE_ENABLED",
+    readonly RUSH_BUILD_CACHE_ENABLED: "RUSH_BUILD_CACHE_ENABLED";
     /**
      * Overrides the value of `isCacheWriteAllowed` in the `build-cache.json` configuration file. The value of this
      * environment variable must be `1` (for true) or `0` (for false). If there is no build cache configured, then
      * this environment variable is ignored.
      */
-    RUSH_BUILD_CACHE_WRITE_ALLOWED = "RUSH_BUILD_CACHE_WRITE_ALLOWED",
+    readonly RUSH_BUILD_CACHE_WRITE_ALLOWED: "RUSH_BUILD_CACHE_WRITE_ALLOWED";
+    /**
+     * Setting this environment variable overrides the value of `cobuildEnabled` in the `cobuild.json`
+     * configuration file.
+     *
+     * @remarks
+     * Specify `1` to enable the cobuild or `0` to disable it.
+     *
+     * If there is no cobuild configured, then this environment variable is ignored.
+     */
+    readonly RUSH_COBUILD_ENABLED: "RUSH_COBUILD_ENABLED";
+    /**
+     * Setting this environment variable opt into running with cobuilds.
+     *
+     * @remarks
+     * If there is no cobuild configured, then this environment variable is ignored.
+     */
+    readonly RUSH_COBUILD_CONTEXT_ID: "RUSH_COBUILD_CONTEXT_ID";
+    /**
+     * If this variable is set to "1", When getting distributed builds, Rush will automatically handle the leaf project
+     * with build cache "disabled" by writing to the cache in a special "log files only mode". This is useful when you
+     * want to use Cobuilds to improve the performance in CI validations and the leaf projects have not enabled cache.
+     */
+    readonly RUSH_COBUILD_LEAF_PROJECT_LOG_ONLY_ALLOWED: "RUSH_COBUILD_LEAF_PROJECT_LOG_ONLY_ALLOWED";
     /**
      * Explicitly specifies the path for the Git binary that is invoked by certain Rush operations.
      */
-    RUSH_GIT_BINARY_PATH = "RUSH_GIT_BINARY_PATH",
+    readonly RUSH_GIT_BINARY_PATH: "RUSH_GIT_BINARY_PATH";
     /**
      * Explicitly specifies the path for the `tar` binary that is invoked by certain Rush operations.
      */
-    RUSH_TAR_BINARY_PATH = "RUSH_TAR_BINARY_PATH",
+    readonly RUSH_TAR_BINARY_PATH: "RUSH_TAR_BINARY_PATH";
     /**
      * Internal variable that explicitly specifies the path for the version of `@microsoft/rush-lib` being executed.
      * Will be set upon loading Rush.
      */
-    RUSH_LIB_PATH = "_RUSH_LIB_PATH",
+    readonly RUSH_LIB_PATH: "_RUSH_LIB_PATH";
     /**
      * When Rush executes shell scripts, it sometimes changes the working directory to be a project folder or
      * the repository root folder.  The original working directory (where the Rush command was invoked) is assigned
@@ -573,8 +663,8 @@ export declare enum EnvironmentVariableNames {
      * The `RUSH_INVOKED_FOLDER` variable is the same idea as the `INIT_CWD` variable that package managers
      * assign when they execute lifecycle scripts.
      */
-    RUSH_INVOKED_FOLDER = "RUSH_INVOKED_FOLDER"
-}
+    readonly RUSH_INVOKED_FOLDER: "RUSH_INVOKED_FOLDER";
+};
 
 /**
  * Events happen during Rush runs.
@@ -714,6 +804,61 @@ export declare interface ICloudBuildCacheProvider {
     deleteCachedCredentialsAsync(terminal: ITerminal): Promise<void>;
 }
 
+/**
+ * @beta
+ */
+export declare interface ICobuildCompletedState {
+    status: OperationStatus.Success | OperationStatus.SuccessWithWarning | OperationStatus.Failure;
+    /**
+     * Completed state points to the cache id that was used to store the build cache.
+     * Note: Cache failed builds in a separate cache id
+     */
+    cacheId: string;
+}
+
+/**
+ * @beta
+ */
+export declare interface ICobuildContext {
+    /**
+     * The contextId is provided by the monorepo maintainer, it reads from environment variable {@link EnvironmentVariableNames.RUSH_COBUILD_CONTEXT_ID}.
+     * It ensure only the builds from the same given contextId cooperated. If user was more permissive,
+     * and wanted all PR and CI builds building anything with the same contextId to cooperate, then just
+     * set it to a static value.
+     */
+    contextId: string;
+    /**
+     * The id of cache. It should be keep same as the normal cacheId from ProjectBuildCache.
+     * Otherwise, there is a discrepancy in the success case then turning on cobuilds will
+     * fail to populate the normal build cache.
+     */
+    cacheId: string;
+    /**
+     * {@inheritdoc RushConstants.cobuildLockVersion}
+     */
+    version: number;
+}
+
+/**
+ * @beta
+ */
+export declare interface ICobuildJson {
+    cobuildEnabled: boolean;
+    cobuildLockProvider: string;
+}
+
+/**
+ * @beta
+ */
+export declare interface ICobuildLockProvider {
+    connectAsync(): Promise<void>;
+    disconnectAsync(): Promise<void>;
+    acquireLockAsync(context: ICobuildContext): Promise<boolean>;
+    renewLockAsync(context: ICobuildContext): Promise<void>;
+    setCompletedStateAsync(context: ICobuildContext, state: ICobuildCompletedState): Promise<void>;
+    getCompletedStateAsync(context: ICobuildContext): Promise<ICobuildCompletedState | undefined>;
+}
+
 /**
  * A collection of environment variables
  * @public
@@ -751,6 +896,10 @@ export declare interface ICreateOperationsContext {
      * The configuration for the build cache, if the feature is enabled.
      */
     readonly buildCacheConfiguration: BuildCacheConfiguration | undefined;
+    /**
+     * The configuration for the cobuild, if cobuild feature and build cache feature are both enabled.
+     */
+    readonly cobuildConfiguration: CobuildConfiguration | undefined;
     /**
      * The set of custom parameters for the executing command.
      * Maps from the `longName` field in command-line.json to the parser configuration in ts-command-line.
@@ -1157,10 +1306,6 @@ export declare interface IOperationRunner {
      * Name of the operation, for logging.
      */
     readonly name: string;
-    /**
-     * This flag determines if the operation is allowed to be skipped if up to date.
-     */
-    isSkipAllowed: boolean;
     /**
      * Indicates that this runner's duration has meaning.
      */
@@ -1174,10 +1319,6 @@ export declare interface IOperationRunner {
      * exit code
      */
     warningsAreAllowed: boolean;
-    /**
-     * Indicates if the output of this operation may be written to the cache
-     */
-    isCacheWriteAllowed: boolean;
     /**
      * Method to be executed for the operation.
      */
@@ -1215,7 +1356,34 @@ export declare interface IOperationRunnerContext {
     /**
      * Object used to track elapsed time.
      */
-    stopwatch: IStopwatchResult;
+    stopwatch: Stopwatch;
+    /**
+     * The current execution status of an operation. Operations start in the 'ready' state,
+     * but can be 'blocked' if an upstream operation failed. It is 'executing' when
+     * the operation is executing. Once execution is complete, it is either 'success' or
+     * 'failure'.
+     */
+    status: OperationStatus;
+    /**
+     * Error which occurred while executing this operation, this is stored in case we need
+     * it later (for example to re-print errors at end of execution).
+     */
+    error?: Error;
+    /**
+     * The set of operations that depend on this operation.
+     */
+    readonly consumers: Set<IOperationRunnerContext>;
+    /**
+     * The operation runner that is executing this operation.
+     */
+    readonly runner: IOperationRunner;
+    /**
+     * Normally the incremental build logic will rebuild changed projects as well as
+     * any projects that directly or indirectly depend on a changed project.
+     * If true, then the incremental build logic will only rebuild changed projects and
+     * ignore dependent projects.
+     */
+    readonly changedProjectsOnly: boolean;
 }
 
 /**
@@ -2091,10 +2259,18 @@ export declare enum OperationStatus {
      * The Operation is on the queue, ready to execute (but may be waiting for dependencies)
      */
     Ready = "READY",
+    /**
+     * The Operation is Queued
+     */
+    Queued = "QUEUED",
     /**
      * The Operation is currently executing
      */
     Executing = "EXECUTING",
+    /**
+     * The Operation is currently executing by a remote process
+     */
+    RemoteExecuting = "REMOTE EXECUTING",
     /**
      * The Operation completed successfully and did not write to standard output
      */
@@ -2264,6 +2440,14 @@ export declare class PhasedCommandHooks {
      * Hook is series for stable output.
      */
     readonly afterExecuteOperations: AsyncSeriesHook<[IExecutionResult, ICreateOperationsContext]>;
+    /**
+     * Hook invoked before executing a operation.
+     */
+    readonly beforeExecuteOperation: AsyncSeriesHook<[IOperationRunnerContext]>;
+    /**
+     * Hook invoked after executing a operation.
+     */
+    readonly afterExecuteOperation: AsyncSeriesHook<[IOperationRunnerContext]>;
     /**
      * Hook invoked after a run has finished and the command is watching for changes.
      * May be used to display additional relevant data to the user.
@@ -3401,6 +3585,15 @@ export declare class RushConstants {
      * Changing this ensures that cache entries generated by an old version will no longer register as a cache hit.
      */
     static readonly buildCacheVersion: number;
+    /**
+     * Cobuild configuration file.
+     */
+    static readonly cobuildFilename: string;
+    /**
+     * Cobuild version number, incremented when the logic to create cobuild lock changes.
+     * Changing this ensures that lock generated by an old version will no longer access as a cobuild lock.
+     */
+    static readonly cobuildLockVersion: number;
     /**
      * Per-project configuration filename.
      */
@@ -3566,12 +3759,15 @@ declare class RushPluginsConfiguration {
 export declare class RushSession {
     private readonly _options;
     private readonly _cloudBuildCacheProviderFactories;
+    private readonly _cobuildLockProviderFactories;
     readonly hooks: RushLifecycleHooks;
     constructor(options: IRushSessionOptions);
     getLogger(name: string): ILogger;
     get terminalProvider(): ITerminalProvider;
     registerCloudBuildCacheProviderFactory(cacheProviderName: string, factory: CloudBuildCacheProviderFactory): void;
     getCloudBuildCacheProviderFactory(cacheProviderName: string): CloudBuildCacheProviderFactory | undefined;
+    registerCobuildLockProviderFactory(cobuildLockProviderName: string, factory: CobuildLockProviderFactory): void;
+    getCobuildLockProviderFactory(cobuildLockProviderName: string): CobuildLockProviderFactory | undefined;
 }
 
 /**
@@ -3590,6 +3786,60 @@ export declare class RushUserConfiguration {
     static getRushUserFolderPath(): string;
 }
 
+/**
+ * Represents a typical timer/stopwatch which keeps track
+ * of elapsed time in between two events.
+ */
+declare class Stopwatch implements IStopwatchResult {
+    private _startTime;
+    private _endTime;
+    private _state;
+    private _getTime;
+    constructor(getTime?: () => number);
+    /**
+     * Static helper function which creates a stopwatch which is immediately started
+     */
+    static start(): Stopwatch;
+    get state(): StopwatchState;
+    /**
+     * Starts the stopwatch. Note that if end() has been called,
+     * reset() should be called before calling start() again.
+     */
+    start(): Stopwatch;
+    /**
+     * Stops executing the stopwatch and saves the current timestamp
+     */
+    stop(): Stopwatch;
+    /**
+     * Resets all values of the stopwatch back to the original
+     */
+    reset(): Stopwatch;
+    /**
+     * Displays how long the stopwatch has been executing in a human readable format.
+     */
+    toString(): string;
+    /**
+     * Get the duration in seconds.
+     */
+    get duration(): number;
+    /**
+     * Return the start time of the most recent stopwatch run.
+     */
+    get startTime(): number | undefined;
+    /**
+     * Return the end time of the most recent stopwatch run.
+     */
+    get endTime(): number | undefined;
+}
+
+/**
+ * Used with the Stopwatch class.
+ */
+declare enum StopwatchState {
+    Stopped = 1,
+    Started = 2
+}
+
 declare enum VersionFormatForCommit {
     wildcard = "wildcard",
     original = "original"

package/lib/api/CobuildConfiguration.d.ts

@@ -0,0 +1,63 @@
+import { ITerminal } from '@rushstack/node-core-library';
+import { RushSession } from '../pluginFramework/RushSession';
+import type { ICobuildLockProvider } from '../logic/cobuild/ICobuildLockProvider';
+import type { RushConfiguration } from './RushConfiguration';
+/**
+ * @beta
+ */
+export interface ICobuildJson {
+    cobuildEnabled: boolean;
+    cobuildLockProvider: string;
+}
+/**
+ * @beta
+ */
+export interface ICobuildConfigurationOptions {
+    cobuildJson: ICobuildJson;
+    rushConfiguration: RushConfiguration;
+    rushSession: RushSession;
+}
+/**
+ * Use this class to load and save the "common/config/rush/cobuild.json" config file.
+ * This file provides configuration options for the Rush Cobuild feature.
+ * @beta
+ */
+export declare class CobuildConfiguration {
+    private static _jsonSchema;
+    /**
+     * Indicates whether the cobuild feature is enabled.
+     * Typically it is enabled in the cobuild.json config file.
+     *
+     * Note: The orchestrator (or local users) should always have to opt into running with cobuilds by
+     * providing a cobuild context id. Even if cobuilds are "enabled" as a feature, they don't
+     * actually turn on for that particular build unless the cobuild context id is provided as an
+     * non-empty string.
+     */
+    readonly cobuildEnabled: boolean;
+    /**
+     * Cobuild context id
+     *
+     * @remarks
+     * The cobuild feature won't be enabled until the context id is provided as an non-empty string.
+     */
+    readonly cobuildContextId: string | undefined;
+    /**
+     * If true, Rush will automatically handle the leaf project with build cache "disabled" by writing
+     * to the cache in a special "log files only mode". This is useful when you want to use Cobuilds
+     * to improve the performance in CI validations and the leaf projects have not enabled cache.
+     */
+    readonly cobuildLeafProjectLogOnlyAllowed: boolean;
+    readonly cobuildLockProvider: ICobuildLockProvider;
+    private constructor();
+    /**
+     * Attempts to load the cobuild.json data from the standard file path `common/config/rush/cobuild.json`.
+     * If the file has not been created yet, then undefined is returned.
+     */
+    static tryLoadAsync(terminal: ITerminal, rushConfiguration: RushConfiguration, rushSession: RushSession): Promise<CobuildConfiguration | undefined>;
+    static getCobuildConfigFilePath(rushConfiguration: RushConfiguration): string;
+    private static _loadAsync;
+    get contextId(): string | undefined;
+    connectLockProviderAsync(): Promise<void>;
+    disconnectLockProviderAsync(): Promise<void>;
+}
+//# sourceMappingURL=CobuildConfiguration.d.ts.map

package/lib/api/CobuildConfiguration.js

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