@depup/lerna 9.0.5-depup.0

package/dist/libs/child-process/src/forked-strong-log-transformer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Internal fork of the unmaintained strong-log-transformer package.
+ * https://github.com/strongloop/strong-log-transformer/blob/3315d59bc4c912d025e15a6ca22a600a85406f14/lib/logger.js
+ *
+ * Notable changes:
+ * - replaced the dependency on duplexer, which has been deprecated for a long time, with inline createDuplex()
+ * - modernized core node.js imports and removed the usage of deprecated node:util._extend()
+ */
+import stream from "node:stream";
+export default Logger;
+declare function Logger(options?: any): stream.Duplex;
+declare namespace Logger {
+    var DEFAULTS: {
+        format: string;
+        tag: string;
+        mergeMultiline: boolean;
+        timeStamp: boolean;
+    };
+}

package/dist/libs/child-process/src/index.d.ts

@@ -0,0 +1,46 @@
+import execa from "execa";
+type withPkg<T> = T & {
+    pkg?: unknown;
+};
+export type LernaChildProcess = withPkg<execa.ExecaChildProcess<string>>;
+export type LernaReturnValue = withPkg<execa.ExecaReturnValue<string>>;
+export type LernaOptions = withPkg<execa.Options>;
+/**
+ * Execute a command asynchronously, piping stdio by default.
+ * @param command
+ * @param args
+ * @param opts
+ * @returns
+ */
+export declare function exec(command: string, args: string[], opts?: LernaOptions): Promise<LernaReturnValue>;
+/**
+ * Execute a command synchronously.
+ * @param command
+ * @param args
+ * @param opts
+ */
+export declare function execSync(command: string, args: string[], opts?: import("execa").SyncOptions): string;
+/**
+ * Spawn a command asynchronously, _always_ inheriting stdio.
+ * @param command
+ * @param args
+ * @param opts
+ */
+export declare function spawn(command: string, args: string[], opts?: LernaOptions): Promise<LernaReturnValue>;
+/**
+ * Spawn a command asynchronously, streaming stdio with optional prefix.
+ * @param command
+ * @param args
+ * @param opts
+ * @param prefix
+ */
+export declare function spawnStreaming(command: string, args: string[], opts?: LernaOptions, prefix?: string): Promise<LernaReturnValue>;
+export declare function getChildProcessCount(): number;
+/**
+ * @param result
+ * @returns
+ */
+export declare function getExitCode(result: execa.ExecaError<string> & {
+    code?: string | number;
+}): number | undefined;
+export {};

package/dist/libs/child-process/src/set-exit-code.d.ts

@@ -0,0 +1 @@
+export declare function setExitCode(code: number): void;

package/dist/libs/commands/changed/src/command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from "yargs";
+/**
+ * @see https://github.com/yargs/yargs/blob/main/docs/advanced.md#providing-a-command-module
+ */
+declare const command: CommandModule;
+export = command;

package/dist/libs/commands/changed/src/index.d.ts

@@ -0,0 +1,15 @@
+import { Arguments, Command, CommandConfigOptions, listableFormatProjects } from "@lerna/core";
+export declare function factory(argv: Arguments<ChangedCommandOptions>): ChangedCommand;
+interface ChangedCommandOptions extends CommandConfigOptions {
+    conventionalCommits?: boolean;
+    conventionalGraduate?: boolean | string;
+    forceConventionalGraduate?: boolean;
+    forcePublish?: boolean | string;
+}
+export declare class ChangedCommand extends Command<ChangedCommandOptions> {
+    result?: ReturnType<typeof listableFormatProjects>;
+    get otherCommandConfigs(): string[];
+    initialize(): boolean;
+    execute(): void;
+}
+export {};

package/dist/libs/commands/clean/src/command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from "yargs";
+/**
+ * @see https://github.com/yargs/yargs/blob/main/docs/advanced.md#providing-a-command-module
+ */
+declare const command: CommandModule;
+export = command;

package/dist/libs/commands/diff/src/command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from "yargs";
+/**
+ * @see https://github.com/yargs/yargs/blob/main/docs/advanced.md#providing-a-command-module
+ */
+declare const command: CommandModule;
+export = command;

package/dist/libs/commands/diff/src/index.d.ts

@@ -0,0 +1,12 @@
+import { Arguments, Command, CommandConfigOptions } from "@lerna/core";
+export declare function factory(argv: Arguments<DiffCommandOptions>): DiffCommand;
+interface DiffCommandOptions extends CommandConfigOptions {
+    pkgName?: string;
+    ignoreChanges?: string[];
+}
+export declare class DiffCommand extends Command<DiffCommandOptions> {
+    private args;
+    initialize(): void;
+    execute(): Promise<void | import("@lerna/child-process").LernaReturnValue>;
+}
+export {};

package/dist/libs/commands/diff/src/lib/get-last-commit.d.ts

@@ -0,0 +1,7 @@
+import { ExecOptions } from "@lerna/core";
+/**
+ *
+ * @param execOpts
+ * @returns
+ */
+export declare function getLastCommit(execOpts?: ExecOptions): string;

package/dist/libs/commands/diff/src/lib/has-commit.d.ts

@@ -0,0 +1,7 @@
+import { ExecOptions } from "@lerna/core";
+/**
+ *
+ * @param opts
+ * @returns
+ */
+export declare function hasCommit(opts?: ExecOptions): boolean;

package/dist/libs/commands/exec/src/command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from "yargs";
+/**
+ * @see https://github.com/yargs/yargs/blob/main/docs/advanced.md#providing-a-command-module
+ */
+declare const command: CommandModule;
+export = command;

package/dist/libs/commands/exec/src/index.d.ts

@@ -0,0 +1,35 @@
+import { Arguments, Command, CommandConfigOptions, Package, ProjectGraphProjectNodeWithPackage } from "@lerna/core";
+export declare function factory(argv: Arguments<ExecCommandConfigOptions>): ExecCommand;
+interface ExecCommandConfigOptions extends CommandConfigOptions {
+    cmd?: string;
+    args?: string[];
+    bail?: boolean;
+    prefix?: boolean;
+    parallel?: boolean;
+    profile?: boolean;
+    profileLocation?: string;
+    rejectCycles?: boolean;
+    "--"?: string[];
+}
+export declare class ExecCommand extends Command<ExecCommandConfigOptions> {
+    command?: string;
+    args?: string[];
+    bail?: boolean;
+    prefix?: boolean;
+    env?: NodeJS.ProcessEnv;
+    filteredProjects: ProjectGraphProjectNodeWithPackage[];
+    count?: number;
+    packagePlural?: string;
+    joinedCommand?: string;
+    get requiresGit(): boolean;
+    initialize(): Promise<void>;
+    execute(): Promise<void>;
+    private getOpts;
+    private getRunner;
+    private runCommandInPackagesTopological;
+    runCommandInPackagesParallel(): Promise<any[]>;
+    runCommandInPackagesLexical(): Promise<any[]>;
+    runCommandInPackageStreaming(pkg: Package): any;
+    runCommandInPackageCapturing(pkg: Package): any;
+}
+export {};

package/dist/libs/commands/import/src/command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from "yargs";
+/**
+ * @see https://github.com/yargs/yargs/blob/main/docs/advanced.md#providing-a-command-module
+ */
+declare const command: CommandModule;
+export = command;

package/dist/libs/commands/import/src/index.d.ts

@@ -0,0 +1,36 @@
+import { Arguments, Command, CommandConfigOptions } from "@lerna/core";
+export declare function factory(argv: Arguments<ImportCommandOptions>): ImportCommand;
+interface ImportCommandOptions extends CommandConfigOptions {
+    dir?: string;
+    dest?: string;
+    flatten?: boolean;
+    preserveCommit?: boolean;
+    yes?: boolean;
+}
+export declare class ImportCommand extends Command<ImportCommandOptions> {
+    private externalExecOpts;
+    private targetDirRelativeToGitRoot?;
+    private commits;
+    private origGitEmail?;
+    private origGitName?;
+    private preImportHead?;
+    gitParamsForTargetCommits(): string[];
+    initialize(): true | Promise<boolean>;
+    getPackageDirectories(): string[];
+    getTargetBase(): string;
+    getCurrentSHA(): string;
+    getWorkspaceRoot(): string;
+    execSync(cmd: string, args: string[]): string;
+    externalExecSync(cmd: string, args: string[]): string;
+    createPatchForCommit(sha: string): string;
+    getGitUserFromSha(sha: string): {
+        email: string;
+        name: string;
+    };
+    configureGitUser({ email, name }: {
+        email?: string;
+        name?: string;
+    }): void;
+    execute(): Promise<void>;
+}
+export {};

package/dist/libs/commands/info/src/command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from "yargs";
+/**
+ * @see https://github.com/yargs/yargs/blob/main/docs/advanced.md#providing-a-command-module
+ */
+declare const command: CommandModule;
+export = command;

package/dist/libs/commands/info/src/index.d.ts

@@ -0,0 +1,6 @@
+import { Arguments, Command, CommandConfigOptions } from "@lerna/core";
+export declare function factory(argv: Arguments<CommandConfigOptions>): InfoCommand;
+export declare class InfoCommand extends Command {
+    initialize(): void;
+    execute(): void;
+}

package/dist/libs/commands/init/src/command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from "yargs";
+/**
+ * @see https://github.com/yargs/yargs/blob/main/docs/advanced.md#providing-a-command-module
+ */
+declare const command: CommandModule;
+export = command;

package/dist/libs/commands/init/src/index.d.ts

@@ -0,0 +1,37 @@
+import { Arguments, CommandConfigOptions, LernaLogger } from "@lerna/core";
+import { PackageManager } from "@nx/devkit";
+import { Tree } from "nx/src/generators/tree";
+interface InitCommandOptions extends CommandConfigOptions {
+    lernaVersion?: string;
+    packages?: string[];
+    exact?: boolean;
+    loglevel?: string;
+    independent?: boolean;
+    dryRun?: boolean;
+    skipInstall?: boolean;
+}
+export declare function factory(args: Arguments<InitCommandOptions>): InitCommand;
+export declare class InitCommand {
+    #private;
+    private args;
+    name: string;
+    logger: LernaLogger;
+    cwd: string;
+    packageManager: PackageManager;
+    runner: Promise<void>;
+    constructor(args: Arguments<InitCommandOptions>);
+    execute(): Promise<void>;
+    then(onResolved: () => void, onRejected: (err: string | Error) => void): Promise<void>;
+    catch(onRejected: (err: string | Error) => void): Promise<void>;
+    generate(tree: Tree): Promise<void | (() => Promise<void>)>;
+    private detectPackageManager;
+    /**
+     * Detects which package manager was used to invoke lerna init command
+     * based on the main Module process that invokes the command
+     * - npx returns 'npm'
+     * - pnpx returns 'pnpm'
+     * - yarn create returns 'yarn'
+     */
+    private detectInvokedPackageManager;
+}
+export {};

package/dist/libs/commands/list/src/command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from "yargs";
+/**
+ * @see https://github.com/yargs/yargs/blob/main/docs/advanced.md#providing-a-command-module
+ */
+declare const command: CommandModule;
+export = command;

package/dist/libs/commands/list/src/index.d.ts

@@ -0,0 +1,8 @@
+import { Arguments, Command, CommandConfigOptions } from "@lerna/core";
+export declare function factory(argv: Arguments<CommandConfigOptions>): ListCommand;
+export declare class ListCommand extends Command {
+    private result?;
+    get requiresGit(): boolean;
+    initialize(): Promise<void>;
+    execute(): void;
+}

package/dist/libs/commands/publish/src/command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from "yargs";
+/**
+ * @see https://github.com/yargs/yargs/blob/main/docs/advanced.md#providing-a-command-module
+ */
+declare const command: CommandModule;
+export = command;

package/dist/libs/commands/run/src/command.d.ts

@@ -0,0 +1,7 @@
+import type { CommandModule } from "yargs";
+import { RunCommandConfigOptions } from ".";
+/**
+ * @see https://github.com/yargs/yargs/blob/main/docs/advanced.md#providing-a-command-module
+ */
+declare const command: CommandModule<object, RunCommandConfigOptions>;
+export = command;

package/dist/libs/commands/run/src/index.d.ts

@@ -0,0 +1,39 @@
+import { Command, CommandConfigOptions, FilterOptions, ProjectGraphProjectNodeWithPackage, Arguments } from "@lerna/core";
+export declare function factory(argv: Arguments<RunCommandConfigOptions>): RunCommand;
+export interface RunCommandConfigOptions extends CommandConfigOptions, FilterOptions {
+    script: string | string[];
+    profile?: boolean;
+    profileLocation?: string;
+    bail?: boolean;
+    prefix?: boolean;
+    loadEnvFiles?: boolean;
+    parallel?: boolean;
+    rejectCycles?: boolean;
+    skipNxCache?: boolean;
+    "--"?: string[];
+}
+export declare class RunCommand extends Command<RunCommandConfigOptions> {
+    script: string | string[];
+    args?: string[];
+    npmClient?: string;
+    bail?: boolean;
+    prefix?: boolean;
+    projectsWithScript: ProjectGraphProjectNodeWithPackage[];
+    count?: number;
+    packagePlural?: string;
+    joinedCommand?: string;
+    get requiresGit(): boolean;
+    initialize(): Promise<boolean>;
+    execute(): Promise<void>;
+    private getOpts;
+    private getRunner;
+    private runScriptInPackagesTopological;
+    private runScriptInPackagesParallel;
+    private runScriptInPackagesLexical;
+    private runScriptInPackageStreaming;
+    private runScriptInPackageCapturing;
+    private runScriptsUsingNx;
+    private addQuotesAroundScriptNameIfItHasAColon;
+    private prepNxOptions;
+    private configureNxOutput;
+}

package/dist/libs/commands/version/src/command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from "yargs";
+/**
+ * @see https://github.com/yargs/yargs/blob/main/docs/advanced.md#providing-a-command-module
+ */
+declare const command: CommandModule;
+export = command;

package/dist/libs/core/src/index.d.ts

@@ -0,0 +1,46 @@
+export { addDependencies } from "./lib/add-dependencies";
+export { addDependents } from "./lib/add-dependents";
+export { checkWorkingTree, throwIfUncommitted } from "./lib/check-working-tree";
+export * from "./lib/cli";
+export { ProjectCollectorOptions, ProjectUpdateCollectorOptions, collectProjectUpdates, collectProjects, } from "./lib/collect-updates";
+export { Command, ExecOptions, LernaLogger, PreInitializedProjectData, Arguments } from "./lib/command";
+export { detectProjects } from "./lib/command/detect-projects";
+export { isGitInitialized } from "./lib/command/is-git-initialized";
+export { applyBuildMetadata, recommendVersion, updateChangelog } from "./lib/conventional-commits";
+export * from "./lib/corepack";
+export { describeRef, describeRefSync } from "./lib/describe-ref";
+export { FilterOptions, filterOptions } from "./lib/filter-options";
+export { filterProjects } from "./lib/filter-projects";
+export { getPackageManifestPath } from "./lib/get-package-manifest-path";
+export * from "./lib/get-packages-for-option";
+export { gitCheckout } from "./lib/git-checkout";
+export { hasNpmVersion } from "./lib/has-npm-version";
+export { formatJSON, listableFormatProjects } from "./lib/listable-format-projects";
+export { ListableOptions, listableOptions } from "./lib/listable-options";
+export { logPacked } from "./lib/log-packed";
+export { Conf } from "./lib/npm-conf/conf";
+export { npmInstall, npmInstallDependencies } from "./lib/npm-install";
+export { npmPublish } from "./lib/npm-publish";
+export { npmRunScript, npmRunScriptStreaming } from "./lib/npm-run-script";
+export { getOneTimePassword } from "./lib/otplease";
+export { output } from "./lib/output";
+export { Packed, packDirectory } from "./lib/pack-directory";
+export { AssetDefinition, ExtendedNpaResult, Package, RawManifest } from "./lib/package";
+export { prereleaseIdFromVersion } from "./lib/prerelease-id-from-version";
+export { Profiler, generateProfileOutputPath } from "./lib/profiler";
+export { CommandConfigOptions, LernaConfig, Project, getPackages } from "./lib/project";
+export { ProjectGraphProjectNodeWithPackage, ProjectGraphWithPackages, ProjectGraphWorkspacePackageDependency, getPackage, isExternalNpmDependency, } from "./lib/project-graph-with-packages";
+export { promptConfirmation, promptSelectOne, promptTextInput } from "./lib/prompt";
+export { pulseTillDone } from "./lib/pulse-till-done";
+export { rimrafDir } from "./lib/rimraf-dir";
+export { createRunner, runLifecycle } from "./lib/run-lifecycle";
+export { runProjectsTopologically } from "./lib/run-projects-topologically";
+export { createGitHubClient, createGitLabClient, parseGitRepo } from "./lib/scm-clients";
+export { default as tempWrite } from "./lib/temp-write";
+export { timer } from "./lib/timer";
+export { toposortProjects } from "./lib/toposort-projects";
+export { ValidationError } from "./lib/validation-error";
+export { default as log, Logger } from "./lib/npmlog";
+export { npmConf, npmDistTag };
+declare const npmConf: any;
+declare const npmDistTag: any;

package/dist/libs/core/src/lib/add-dependencies.d.ts

@@ -0,0 +1,2 @@
+import { ProjectGraphProjectNodeWithPackage, ProjectGraphWithPackages } from "./project-graph-with-packages";
+export declare function addDependencies(projects: ProjectGraphProjectNodeWithPackage[], projectGraph: ProjectGraphWithPackages): ProjectGraphProjectNodeWithPackage[];

package/dist/libs/core/src/lib/add-dependents.d.ts

@@ -0,0 +1,2 @@
+import { ProjectGraphProjectNodeWithPackage, ProjectGraphWithPackages } from "./project-graph-with-packages";
+export declare function addDependents(projects: ProjectGraphProjectNodeWithPackage[], projectGraph: ProjectGraphWithPackages): ProjectGraphProjectNodeWithPackage[];

package/dist/libs/core/src/lib/check-working-tree.d.ts

@@ -0,0 +1,12 @@
+export declare function checkWorkingTree({ cwd }?: {
+    cwd?: string | URL;
+}): Promise<void>;
+export declare function throwIfReleased({ refCount }: {
+    refCount: any;
+}): void;
+export declare function mkThrowIfUncommitted(options?: {}): (opts: {
+    isDirty?: boolean;
+}) => Promise<never> | undefined;
+export declare const throwIfUncommitted: (opts: {
+    isDirty?: boolean;
+}) => Promise<never> | undefined;

package/dist/libs/core/src/lib/cli.d.ts

@@ -0,0 +1,14 @@
+import yargs from "yargs";
+/**
+ * A factory that returns a yargs() instance configured with everything except commands.
+ * Chain .parse() from this method to invoke.
+ */
+export declare function lernaCLI(argv?: string | readonly string[], cwd?: string): yargs.Argv<yargs.Omit<yargs.Omit<{}, string | number> & yargs.InferredOptionTypes<{
+    [key: string]: yargs.Options;
+}>, "ci"> & {
+    ci: boolean | undefined;
+} & {
+    help: unknown;
+} & {
+    version: unknown;
+}>;

package/dist/libs/core/src/lib/collect-uncommitted.d.ts

@@ -0,0 +1,12 @@
+import npmlog from "./npmlog";
+interface UncommittedConfig {
+    cwd: string;
+    log?: typeof npmlog;
+}
+export declare function collectUncommitted({ cwd, log }: UncommittedConfig): Promise<string[]>;
+/**
+ * Report uncommitted files. (sync)
+ * @returns A list of uncommitted files
+ */
+export declare function collectUncommittedSync({ cwd, log }: UncommittedConfig): string[];
+export {};

package/dist/libs/core/src/lib/collect-updates/collect-project-updates.d.ts

@@ -0,0 +1,29 @@
+import { ExecOptions } from "child_process";
+import { ProjectGraphProjectNodeWithPackage, ProjectGraphWithPackages } from "../project-graph-with-packages";
+export interface ProjectUpdateCollectorOptions {
+    bump?: string;
+    canary?: boolean;
+    ignoreChanges?: string[];
+    includeMergedTags?: boolean;
+    forcePublish?: boolean | string | string[];
+    since?: string;
+    conventionalCommits?: boolean;
+    conventionalGraduate?: string | boolean;
+    forceConventionalGraduate?: boolean;
+    excludeDependents?: boolean;
+    tagVersionSeparator?: string;
+}
+/**
+ * Create a list of graph nodes representing projects changed since the previous release, tagged or otherwise.
+ */
+export declare function collectProjectUpdates(filteredProjects: ProjectGraphProjectNodeWithPackage[], projectGraph: ProjectGraphWithPackages, execOpts: ExecOptions, commandOptions: ProjectUpdateCollectorOptions): ProjectGraphProjectNodeWithPackage[];
+export interface ProjectCollectorOptions {
+    isCandidate?: (node: ProjectGraphProjectNodeWithPackage, packageName: string) => boolean;
+    onInclude?: (packageName: string) => void;
+    excludeDependents?: boolean;
+}
+export declare function collectProjects(projects: ProjectGraphProjectNodeWithPackage[], projectGraph: ProjectGraphWithPackages, { isCandidate, onInclude, excludeDependents }?: ProjectCollectorOptions): ProjectGraphProjectNodeWithPackage[];
+/**
+ * Build a set of nodes that are dependents of the input set.
+ */
+export declare function collectDependents(nodes: Record<string, ProjectGraphProjectNodeWithPackage>, projectGraph: ProjectGraphWithPackages): Set<ProjectGraphProjectNodeWithPackage>;

package/dist/libs/core/src/lib/collect-updates/has-tags.d.ts

@@ -0,0 +1,6 @@
+import { ExecOptions } from "child_process";
+/**
+ * Determine if any git tags are reachable.
+ * @param {import("@lerna/child-process").ExecOpts} opts
+ */
+export declare function hasTags(opts?: ExecOptions): boolean;

package/dist/libs/core/src/lib/collect-updates/index.d.ts

@@ -0,0 +1 @@
+export { collectProjects, collectProjectUpdates, ProjectCollectorOptions, ProjectUpdateCollectorOptions, } from "./collect-project-updates";

package/dist/libs/core/src/lib/collect-updates/make-diff-predicate.d.ts

@@ -0,0 +1,3 @@
+import { ExecOptions } from "child_process";
+import { ProjectGraphProjectNodeWithPackage } from "../project-graph-with-packages";
+export declare function makeDiffPredicate(committish: string, execOpts: ExecOptions, ignorePatterns?: string[]): (node: ProjectGraphProjectNodeWithPackage) => boolean;

package/dist/libs/core/src/lib/command/clean-stack.d.ts

@@ -0,0 +1 @@
+export declare function cleanStack(err: string | Error, className: string): string;

package/dist/libs/core/src/lib/command/create-project-graph-with-packages.d.ts

@@ -0,0 +1,5 @@
+import { ProjectFileMap, ProjectGraph } from "@nx/devkit";
+import { ExtendedNpaResult } from "../package";
+import { ProjectGraphWithPackages } from "../project-graph-with-packages";
+export declare function createProjectGraphWithPackages(projectGraph: ProjectGraph, projectFileMap: ProjectFileMap, packageConfigs: string[]): Promise<ProjectGraphWithPackages>;
+export declare const resolvePackage: (name: string, version: string, spec: string, location?: string) => ExtendedNpaResult;

package/dist/libs/core/src/lib/command/default-options.d.ts

@@ -0,0 +1,2 @@
+import { CommandConfigOptions } from "../project";
+export declare function defaultOptions<T extends CommandConfigOptions>(...sources: any[]): T;

package/dist/libs/core/src/lib/command/detect-projects.d.ts

@@ -0,0 +1,6 @@
+import { ProjectFileMap } from "@nx/devkit";
+import { ProjectGraphWithPackages } from "../project-graph-with-packages";
+export declare function detectProjects(packageConfigs: string[]): Promise<{
+    projectGraph: ProjectGraphWithPackages;
+    projectFileMap: ProjectFileMap;
+}>;

package/dist/libs/core/src/lib/command/index.d.ts

@@ -0,0 +1,80 @@
+import { ProjectFileMap } from "@nx/devkit";
+import { ExecOptions as NodeExecOptions } from "child_process";
+import yargs from "yargs";
+import { Logger } from "../npmlog";
+import { CommandConfigOptions, Project } from "../project";
+import { ProjectGraphWithPackages } from "../project-graph-with-packages";
+/**
+ * Execa compatible options type
+ *
+ * Current used execa version options type uses```cwd: string``` and not
+ * ``` cwd?: string | URL ```
+ *
+ * Can be removed when latest execa version is used!!!
+ * */
+export type ExecOptions = Omit<NodeExecOptions, "cwd"> & {
+    cwd?: string;
+};
+/**
+ * Specific logger with log-level success enabled in order to use function without index signature
+ */
+export interface LernaLogger extends Logger {
+    /**
+     * Log with level success
+     * @param prefix
+     * @param message
+     * @param args
+     */
+    success(prefix: string, message: string, ...args: any[]): void;
+}
+export interface PreInitializedProjectData {
+    projectFileMap: ProjectFileMap;
+    projectGraph: ProjectGraphWithPackages;
+}
+export type Arguments<T extends CommandConfigOptions = CommandConfigOptions> = {
+    cwd?: string;
+    composed?: string;
+    lernaVersion?: string;
+    onResolved?: (value: unknown) => unknown;
+    onRejected?: (reason: unknown) => unknown;
+} & yargs.ArgumentsCamelCase<T>;
+export declare class Command<T extends CommandConfigOptions = CommandConfigOptions> {
+    readonly _argv: Arguments<T>;
+    name: string;
+    composed: boolean;
+    options: T;
+    runner: Promise<unknown>;
+    concurrency: number;
+    toposort: boolean;
+    execOpts: ExecOptions;
+    logger: LernaLogger;
+    envDefaults: any;
+    argv: Arguments<T>;
+    projectGraph: ProjectGraphWithPackages;
+    projectFileMap: ProjectFileMap;
+    private _project?;
+    get project(): Project;
+    set project(project: Project);
+    constructor(_argv: Arguments<T>, { skipValidations, preInitializedProjectData, }?: {
+        skipValidations: boolean;
+        preInitializedProjectData?: PreInitializedProjectData;
+    });
+    static createLogger(name: string, loglevel?: string): LernaLogger;
+    then(onResolved: () => void, onRejected: (err: string | Error) => void): Promise<void>;
+    catch(onRejected: (err: string | Error) => void): Promise<unknown>;
+    get requiresGit(): boolean;
+    get otherCommandConfigs(): string[];
+    detectProjects(): Promise<void>;
+    configureEnvironment(): void;
+    configureOptions(): void;
+    configureProperties(): void;
+    enableProgressBar(): void;
+    runValidations(): void;
+    runPreparations(): void;
+    runCommand(): Promise<unknown>;
+    initialize(): void | boolean | Promise<void | boolean>;
+    /**
+     * The execute() method can return a value in some cases (e.g. on the version command)
+     */
+    execute(): void | Promise<unknown>;
+}

package/dist/libs/core/src/lib/command/is-git-initialized.d.ts

@@ -0,0 +1 @@
+export declare function isGitInitialized(cwd: string): boolean;

package/dist/libs/core/src/lib/command/log-package-error.d.ts

@@ -0,0 +1 @@
+export declare function logPackageError(err: any, stream?: boolean): void;

package/dist/libs/core/src/lib/command/warn-if-hanging.d.ts

@@ -0,0 +1 @@
+export declare function warnIfHanging(): void;

package/dist/libs/core/src/lib/conventional-commits/apply-build-metadata.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Append build metadata to version.
+ */
+export declare function applyBuildMetadata(version: string, buildMetadata: string): string;