@depup/lerna 9.0.5-depup.0

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

@@ -0,0 +1,128 @@
+import npa from "npm-package-arg";
+import { Packed } from "./pack-directory";
+declare const PKG: unique symbol;
+declare const _location: unique symbol;
+declare const _resolved: unique symbol;
+declare const _rootPath: unique symbol;
+declare const _scripts: unique symbol;
+declare const _contents: unique symbol;
+export type AssetDefinition = string | {
+    from: string;
+    to: string;
+};
+export interface RawManifestLernaConfig {
+    command?: {
+        publish?: {
+            directory?: string;
+            assets?: AssetDefinition[];
+        };
+    };
+}
+export interface RawManifest {
+    name: string;
+    version: string;
+    description?: string;
+    private?: boolean;
+    bin?: Record<string, string> | string;
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    publishConfig?: Record<"directory" | "registry" | "tag", string>;
+    workspaces?: string[];
+    nx?: Record<string, unknown>;
+    gitHead?: string;
+    lerna?: RawManifestLernaConfig;
+}
+export type ExtendedNpaResult = npa.Result & {
+    workspaceSpec?: string;
+    workspaceAlias?: "*" | "^" | "~";
+};
+/**
+ * Lerna's internal representation of a local package, with
+ * many values resolved directly from the original JSON.
+ */
+export declare class Package {
+    name: string;
+    [PKG]: RawManifest;
+    [_location]: string;
+    [_resolved]: npa.Result;
+    [_rootPath]: string;
+    [_scripts]: Record<string, string>;
+    [_contents]: string | undefined;
+    licensePath?: string;
+    packed?: Packed;
+    /**
+     * Create a Package instance from parameters, possibly reusing existing instance.
+     * @param ref A path to a package.json file, Package instance, or JSON object
+     * @param [dir] If `ref` is a JSON object, this is the location of the manifest
+     */
+    static lazy(ref: string | Package | RawManifest, dir?: string): Package;
+    constructor(pkg: RawManifest, location: string, rootPath?: string);
+    get location(): string;
+    get private(): boolean;
+    set private(isPrivate: boolean);
+    get resolved(): npa.Result;
+    get rootPath(): string;
+    get scripts(): Record<string, string>;
+    get lernaConfig(): RawManifestLernaConfig | undefined;
+    set lernaConfig(config: RawManifestLernaConfig | undefined);
+    get bin(): Record<string, string>;
+    get binLocation(): string;
+    get manifestLocation(): string;
+    get nodeModulesLocation(): string;
+    get __isLernaPackage(): boolean;
+    get version(): string;
+    set version(version: string);
+    get contents(): string;
+    set contents(subDirectory: string);
+    get dependencies(): Record<string, string> | undefined;
+    get devDependencies(): Record<string, string> | undefined;
+    get optionalDependencies(): Record<string, string> | undefined;
+    get peerDependencies(): Record<string, string> | undefined;
+    /**
+     * Map-like retrieval of arbitrary values
+     */
+    get(key: keyof RawManifest): string | boolean | string[] | Record<string, string> | RawManifestLernaConfig | Record<"directory" | "registry" | "tag", string> | Record<string, unknown> | undefined;
+    /**
+     * Map-like storage of arbitrary values
+     */
+    set(key: keyof RawManifest, val: RawManifest[keyof RawManifest]): Package;
+    /**
+     * Provide shallow copy for munging elsewhere
+     */
+    toJSON(): any;
+    /**
+     * Refresh internal state from disk (e.g., changed by external lifecycles)
+     */
+    refresh(): Promise<this>;
+    /**
+     * Write manifest changes to disk
+     * @returns {Promise} resolves when write finished
+     */
+    serialize(): Promise<this>;
+    /**
+     * Sync dist manifest version
+     */
+    syncDistVersion(doSync: boolean): Promise<this>;
+    getLocalDependency(depName: string): {
+        collection: "dependencies" | "devDependencies" | "optionalDependencies" | "peerDependencies";
+        spec: string;
+    } | null;
+    /**
+     * Mutate local dependency spec according to type
+     * @param resolved npa metadata
+     * @param depVersion semver
+     * @param savePrefix npm_config_save_prefix
+     * @param options
+     */
+    updateLocalDependency(resolved: ExtendedNpaResult, depVersion: string, savePrefix: string, options?: {
+        eraseWorkspacePrefix: boolean;
+    }): void;
+    /**
+     * Remove the private property, effectively making the package public.
+     */
+    removePrivate(): void;
+}
+export {};

package/dist/libs/core/src/lib/prerelease-id-from-version.d.ts

@@ -0,0 +1 @@
+export declare function prereleaseIdFromVersion(version: string): string | undefined;

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

@@ -0,0 +1,20 @@
+import npmlog, { Logger } from "./npmlog";
+export declare function generateProfileOutputPath(outputDirectory?: string): string;
+interface ProfilerConfig {
+    concurrency: number;
+    log?: typeof npmlog;
+    outputDirectory?: string;
+}
+/**
+ * A profiler to trace execution times across multiple concurrent calls.
+ */
+export declare class Profiler {
+    events: any[];
+    logger: Logger;
+    outputPath: string;
+    threads: number[];
+    constructor({ concurrency, log, outputDirectory }: ProfilerConfig);
+    run(fn: () => any, name: any): Promise<any>;
+    output(): Promise<void>;
+}
+export {};

package/dist/libs/core/src/lib/project/apply-extends.d.ts

@@ -0,0 +1,4 @@
+export declare function applyExtends(config: {
+    [x: string]: unknown;
+    extends?: any;
+}, cwd: string, seen?: Set<unknown>): any;

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

@@ -0,0 +1,82 @@
+import { Package } from "../package";
+interface CommandConfigs {
+    [command: string]: CommandConfigOptions;
+}
+export interface CommandConfigOptions {
+    _?: (string | number)[];
+    concurrency?: number;
+    sort?: boolean;
+    maxBuffer?: number;
+    stream?: boolean;
+    loglevel?: string;
+    verbose?: boolean;
+    progress?: boolean;
+    npmClient?: string;
+    useNx?: boolean;
+    independent?: boolean;
+    ci?: boolean;
+    since?: string;
+}
+export interface LernaConfig {
+    $schema: string;
+    version: string;
+    packages?: string[];
+    useNx?: boolean;
+    npmClient?: string;
+    command?: CommandConfigs;
+}
+/**
+ * A representation of the entire project managed by Lerna.
+ *
+ * Wherever the lerna.json file is located, that is the project root.
+ * All package globs are rooted from this location.
+ */
+export declare class Project {
+    #private;
+    config: LernaConfig;
+    configNotFound: boolean;
+    rootConfigLocation: string;
+    rootPath: string;
+    packageConfigs: string[];
+    manifest: Package;
+    /**
+     * @deprecated Only used in legacy core utilities
+     * TODO: remove in v8
+     */
+    static getPackages(cwd: string): Promise<Package[]>;
+    /**
+     * @deprecated Only used in legacy core utilities
+     * TODO: remove in v8
+     */
+    static getPackagesSync(cwd: string): Package[];
+    constructor(cwd?: string, options?: {
+        skipLernaConfigValidations: boolean;
+    });
+    get version(): string;
+    set version(val: string);
+    get packageParentDirs(): string[];
+    get licensePath(): string | undefined;
+    get fileFinder(): (fileName: string, fileMapper: any, customGlobOpts: any) => Promise<any>;
+    /**
+     * A promise resolving to a list of Package instances
+     */
+    getPackages(): Promise<Package[]>;
+    /**
+     * A list of Package instances
+     */
+    getPackagesSync(): Package[];
+    getPackageLicensePaths(): Promise<string[]>;
+    isIndependent(): boolean;
+    serializeConfig(): string;
+}
+/**
+ * @deprecated Only used in legacy core utilities
+ * TODO: remove in v8
+ */
+export declare const getPackages: typeof Project.getPackages;
+/**
+ * @deprecated Only used in legacy core utilities
+ * TODO: remove in v8
+ */
+export declare const getPackagesSync: typeof Project.getPackagesSync;
+export {};

package/dist/libs/core/src/lib/project/make-file-finder.d.ts

@@ -0,0 +1,2 @@
+export declare function makeFileFinder(rootPath: string, packageConfigs: any[]): (fileName: string, fileMapper: any, customGlobOpts: any) => Promise<any>;
+export declare function makeSyncFileFinder(rootPath: string, packageConfigs: any[]): <T>(fileName: string, fileMapper: (filePath: string) => T) => T[];

package/dist/libs/core/src/lib/project/shallow-extend.d.ts

@@ -0,0 +1 @@
+export declare function shallowExtend(json: any, defaults?: {}): any;

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

@@ -0,0 +1,23 @@
+import { ProjectGraph, ProjectGraphDependency, ProjectGraphProjectNode } from "@nx/devkit";
+import { ExtendedNpaResult, Package } from "./package";
+export interface ProjectGraphProjectNodeWithPackage extends ProjectGraphProjectNode {
+    package: Package | null;
+}
+export interface ProjectGraphWorkspacePackageDependency extends ProjectGraphDependency {
+    targetVersionMatchesDependencyRequirement: boolean;
+    targetResolvedNpaResult: ExtendedNpaResult;
+    dependencyCollection: "dependencies" | "devDependencies" | "optionalDependencies" | "peerDependencies";
+}
+export interface ProjectGraphWithPackages extends ProjectGraph {
+    nodes: Record<string, ProjectGraphProjectNodeWithPackage>;
+    localPackageDependencies: Record<string, ProjectGraphWorkspacePackageDependency[]>;
+}
+export declare const isExternalNpmDependency: (dep: string) => boolean;
+/**
+ * Get the package for a given project graph node with a package.
+ * This should be preferred over directly accessing `node.package`,
+ * since this function will throw an error if the package is not found.
+ * @param project the project graph node to get the package for
+ * @returns the package for the given project
+ */
+export declare function getPackage(project: ProjectGraphProjectNodeWithPackage): Package;

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

@@ -0,0 +1,19 @@
+/**
+ * Prompt for confirmation
+ */
+export declare function promptConfirmation(message: string): Promise<boolean>;
+/**
+ * Prompt for selection
+ */
+export declare function promptSelectOne(message: string, { choices, filter, validate, }?: {
+    choices?: any;
+    filter?: (input: string) => string;
+    validate?: (input: string) => string | boolean;
+}): Promise<string>;
+/**
+ * Prompt for input
+ */
+export declare function promptTextInput(message: string, { filter, validate, }?: {
+    filter?: (input: string) => string;
+    validate?: (input: string) => string | boolean;
+}): Promise<string>;

package/dist/libs/core/src/lib/pulse-till-done.d.ts

@@ -0,0 +1,2 @@
+export declare function pulseTillDone(promise: any): any;
+export declare function pulseTillDone(prefix: string, promise: any): any;

package/dist/libs/core/src/lib/rimraf-dir.d.ts

@@ -0,0 +1 @@
+export declare function rimrafDir(dirPath: string): Promise<void>;

package/dist/libs/core/src/lib/run-lifecycle.d.ts

@@ -0,0 +1,21 @@
+import log from "./npmlog";
+import { Package } from "./package";
+interface LifecycleConfig {
+    log?: typeof log;
+    ignorePrepublish?: boolean;
+    ignoreScripts?: boolean;
+    nodeOptions?: string;
+    scriptShell?: string;
+    scriptsPrependNodePath?: boolean;
+    unsafePerm?: boolean;
+    stdio?: string;
+}
+/**
+ * Run a lifecycle script for a package.
+ * @param {import("@lerna/package").Package} pkg
+ * @param {string} stage
+ * @param {LifecycleConfig} options
+ */
+export declare function runLifecycle(pkg: Package, stage: string, options: LifecycleConfig): Promise<any>;
+export declare function createRunner(commandOptions: any): (pkg: Package, stage: string) => Promise<any>;
+export {};

package/dist/libs/core/src/lib/run-projects-topologically.d.ts

@@ -0,0 +1,10 @@
+import { ProjectGraphProjectNodeWithPackage, ProjectGraphWithPackages } from "./project-graph-with-packages";
+interface TopologicalConfig {
+    concurrency?: number;
+    rejectCycles?: boolean;
+}
+/**
+ * Run callback in maximally-saturated topological order.
+ */
+export declare function runProjectsTopologically<T>(projects: ProjectGraphProjectNodeWithPackage[], projectGraph: ProjectGraphWithPackages, runner: (node: ProjectGraphProjectNodeWithPackage) => Promise<T>, { concurrency, rejectCycles }?: TopologicalConfig): Promise<T[]>;
+export {};

package/dist/libs/core/src/lib/scm-clients/github/create-github-client.d.ts

@@ -0,0 +1,4 @@
+import { Octokit } from "@octokit/rest";
+import parseGitUrl from "git-url-parse";
+export declare function createGitHubClient(): Octokit;
+export declare function parseGitRepo(remote?: string, opts?: any): parseGitUrl.GitUrl;

package/dist/libs/core/src/lib/scm-clients/gitlab/create-gitlab-client.d.ts

@@ -0,0 +1,11 @@
+export declare function createGitLabClient(): {
+    repos: {
+        createRelease: ({ owner, repo, name, tag_name: tagName, body }: {
+            owner: any;
+            repo: any;
+            name: any;
+            tag_name: any;
+            body: any;
+        }) => Promise<void>;
+    };
+};

package/dist/libs/core/src/lib/scm-clients/gitlab/gitlab-client.d.ts

@@ -0,0 +1,13 @@
+export declare class GitLabClient {
+    token: string;
+    baseUrl: string;
+    constructor(token: string, baseUrl?: string);
+    createRelease({ owner, repo, name, tag_name: tagName, body }: {
+        owner: any;
+        repo: any;
+        name: any;
+        tag_name: any;
+        body: any;
+    }): Promise<void>;
+    releasesUrl(namespace: string, project: string): string;
+}

package/dist/libs/core/src/lib/scm-clients/index.d.ts

@@ -0,0 +1,2 @@
+export { createGitHubClient, parseGitRepo } from "./github/create-github-client";
+export { createGitLabClient } from "./gitlab/create-gitlab-client";

package/dist/libs/core/src/lib/temp-write.d.ts

@@ -0,0 +1,5 @@
+declare function tempWrite(fileContent: any, filePath?: string): Promise<string>;
+declare namespace tempWrite {
+    var sync: (fileContent: any, filePath?: string) => string;
+}
+export default tempWrite;

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

@@ -0,0 +1 @@
+export declare function timer(): () => number;

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

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

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

@@ -0,0 +1,4 @@
+export declare class ValidationError extends Error {
+    prefix: string;
+    constructor(prefix: string, message: string, ...rest: unknown[]);
+}

package/dist/libs/core/src/lib/write-log-file.d.ts

@@ -0,0 +1 @@
+export declare function writeLogFile(cwd: string): void;

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

@@ -0,0 +1,10 @@
+export { collectPackages, collectUpdates } from "./lib/collect-updates";
+export { Command } from "./lib/command";
+export { createSymlink } from "./lib/create-symlink";
+export { getFilteredPackages } from "./lib/get-filtered-packages";
+export { listableFormat } from "./lib/listable-format";
+export { PackageGraph } from "./lib/package-graph";
+export { PackageGraphNode } from "./lib/package-graph/package-graph-node";
+export { runTopologically } from "./lib/run-topologically";
+export { symlinkBinary } from "./lib/symlink-binary";
+export { symlinkDependencies } from "./lib/symlink-dependencies";

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

@@ -0,0 +1,5 @@
+import { PackageGraphNode } from "../package-graph/package-graph-node";
+/**
+ * Build a set of nodes that are dependents of the input set.
+ */
+export declare function collectDependents(nodes: Set<PackageGraphNode>): Set<PackageGraphNode>;

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

@@ -0,0 +1,10 @@
+import { PackageGraphNode } from "../package-graph/package-graph-node";
+export interface PackageCollectorOptions {
+    isCandidate?: (node?: PackageGraphNode, name?: string) => boolean;
+    onInclude?: (name: string) => void;
+    excludeDependents?: boolean;
+}
+/**
+ * Build a list of graph nodes, possibly including dependents, using predicate if available.
+ */
+export declare function collectPackages(packages: Map<string, PackageGraphNode>, { isCandidate, onInclude, excludeDependents }?: PackageCollectorOptions): PackageGraphNode[];

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

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

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

@@ -0,0 +1,19 @@
+import { Package } from "@lerna/core";
+import { PackageGraph } from "../package-graph";
+import { collectPackages } from "./collect-packages";
+export { collectPackages };
+export interface UpdateCollectorOptions {
+    bump?: string;
+    canary?: boolean;
+    ignoreChanges?: string[];
+    includeMergedTags?: boolean;
+    forcePublish?: boolean | string | string[];
+    since?: string;
+    conventionalCommits?: boolean;
+    conventionalGraduate?: string | boolean;
+    excludeDependents?: boolean;
+}
+/**
+ * Create a list of graph nodes representing packages changed since the previous release, tagged or otherwise.
+ */
+export declare function collectUpdates(filteredPackages: Package[], packageGraph: PackageGraph, execOpts: any, commandOptions: UpdateCollectorOptions): import("../..").PackageGraphNode[];

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

@@ -0,0 +1,7 @@
+import { PackageGraphNode } from "../package-graph/package-graph-node";
+/**
+ * @param {string} committish
+ * @param {import("@lerna/child-process").ExecOpts} execOpts
+ * @param {string[]} ignorePatterns
+ */
+export declare function makeDiffPredicate(committish: string, execOpts: any, ignorePatterns?: string[]): (node: PackageGraphNode) => boolean;

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

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

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

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

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

@@ -0,0 +1,40 @@
+import { CommandConfigOptions, Logger, Project } from "@lerna/core";
+import { PackageGraph } from "../package-graph";
+export declare class Command<T extends CommandConfigOptions = CommandConfigOptions> {
+    readonly _argv: any;
+    name: string;
+    composed: boolean;
+    options: T;
+    runner: Promise<unknown>;
+    concurrency?: number;
+    toposort: boolean;
+    execOpts?: {
+        cwd: string;
+        maxBuffer?: number;
+    };
+    packageGraph?: PackageGraph;
+    logger: Logger;
+    private _project?;
+    get project(): Project;
+    set project(project: Project);
+    constructor(_argv: any, { skipValidations }?: {
+        skipValidations: boolean;
+    });
+    then(onResolved: () => void, onRejected: (err: string | Error) => void): Promise<void>;
+    catch(onRejected: (err: string | Error) => void): Promise<unknown>;
+    get requiresGit(): boolean;
+    get otherCommandConfigs(): never[];
+    configureEnvironment(): void;
+    configureOptions(): void;
+    argv(argv: any, arg1: any, config: any, envDefaults: any): any;
+    envDefaults(argv: any, arg1: any, config: any, envDefaults: any): any;
+    configureProperties(): void;
+    configureLogging(): void;
+    enableProgressBar(): void;
+    gitInitialized(): boolean;
+    runValidations(): void;
+    runPreparations(): Promise<void>;
+    runCommand(): Promise<void>;
+    initialize(): void;
+    execute(): void;
+}

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

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

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

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

package/dist/libs/legacy-core/src/lib/create-symlink.d.ts

@@ -0,0 +1,4 @@
+import { SymlinkType } from "fs-extra";
+type CreateSymlinkType = SymlinkType | "exec";
+export declare function createSymlink(src: string, dest: string, type: CreateSymlinkType): Promise<void>;
+export {};

package/dist/libs/legacy-core/src/lib/filter-packages.d.ts

@@ -0,0 +1,13 @@
+import { Package } from "@lerna/core";
+/**
+ * Filters a list of packages, returning all packages that match the `include` glob[s]
+ * and do not match the `exclude` glob[s].
+ *
+ * @param packagesToFilter The packages to filter
+ * @param [include] A list of globs to match the package name against
+ * @param [exclude] A list of globs to filter the package name against
+ * @param [showPrivate] When false, filter out private packages
+ * @param [continueIfNoMatch] When true, do not throw if no package is matched
+ * @throws when a given glob would produce an empty list of packages and `continueIfNoMatch` is not set.
+ */
+export declare function filterPackages(packagesToFilter: Package[], include?: string[], exclude?: string[], showPrivate?: boolean, continueIfNoMatch?: boolean): Package[];

package/dist/libs/legacy-core/src/lib/get-filtered-packages.d.ts

@@ -0,0 +1,7 @@
+import { FilterOptions, Package } from "@lerna/core";
+import { ExecOptions } from "child_process";
+import { PackageGraph } from "./package-graph";
+/**
+ * Retrieve a list of Package instances filtered by various options.
+ */
+export declare function getFilteredPackages(packageGraph: PackageGraph, execOpts: ExecOptions, opts: Partial<FilterOptions>): Promise<Package[]>;

package/dist/libs/legacy-core/src/lib/listable-format.d.ts

@@ -0,0 +1,8 @@
+import { ListableOptions, Package } from "@lerna/core";
+/**
+ * Format a list of packages according to specified options.
+ */
+export declare function listableFormat(pkgList: Package[], options: ListableOptions): {
+    text: string;
+    count: number;
+};

package/dist/libs/legacy-core/src/lib/package-graph/cyclic-package-graph-node.d.ts

@@ -0,0 +1,37 @@
+import { PackageGraphNode } from "./package-graph-node";
+/**
+ * Represents a cyclic collection of nodes in a PackageGraph.
+ * It is meant to be used as a black box, where the only exposed
+ * information are the connections to the other nodes of the graph.
+ * It can contain either `PackageGraphNode`s or other `CyclicPackageGraphNode`s.
+ */
+export declare class CyclicPackageGraphNode extends Map<string, PackageGraphNode | CyclicPackageGraphNode> {
+    name: string;
+    localDependencies: Map<string, PackageGraphNode | CyclicPackageGraphNode>;
+    localDependents: Map<string, PackageGraphNode | CyclicPackageGraphNode>;
+    constructor();
+    get isCycle(): boolean;
+    /**
+     * @returns A representation of a cycle, like like `A -> B -> C -> A`.
+     */
+    toString(): string;
+    /**
+     * Flattens a CyclicPackageGraphNode (which can have multiple level of cycles).
+     */
+    flatten(): PackageGraphNode[];
+    /**
+     * Checks if a given node is contained in this cycle (or in a nested one)
+     *
+     * @param name The name of the package to search in this cycle
+     */
+    contains(name: string): boolean;
+    /**
+     * Adds a graph node, or a nested cycle, to this group.
+     */
+    insert(node: PackageGraphNode | CyclicPackageGraphNode): void;
+    /**
+     * Remove pointers to candidate node from internal collections.
+     * @param candidateNode instance to unlink
+     */
+    unlink(candidateNode: PackageGraphNode | CyclicPackageGraphNode): void;
+}