nx 19.2.0-canary.20240604-0594deb → 19.2.0-canary.20240605-5a06daa

package/src/command-line/release/command-object.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.yargsReleaseCommand = void 0;
 const yargs_1 = require("yargs");
+const nx_json_1 = require("../../config/nx-json");
 const logger_1 = require("../../utils/logger");
 const shared_options_1 = require("../yargs-utils/shared-options");
-const nx_json_1 = require("../../config/nx-json");
 exports.yargsReleaseCommand = {
     command: 'release',
     describe: 'Orchestrate versioning and publishing of applications and libraries',
@@ -13,6 +13,7 @@ exports.yargsReleaseCommand = {
         .command(versionCommand)
         .command(changelogCommand)
         .command(publishCommand)
+        .command(planCommand)
         .demandCommand()
         // Error on typos/mistyped CLI args, there is no reason to support arbitrary unknown args for these commands
         .strictOptions()
@@ -37,10 +38,6 @@ exports.yargsReleaseCommand = {
         .option('verbose', {
         type: 'boolean',
         describe: 'Prints additional information about the commands (e.g., stack traces)',
-    })
-        .option('first-release', {
-        type: 'boolean',
-        description: 'Indicates that this is the first release for the selected release group. If the current version cannot be determined as usual, the version on disk will be used as a fallback. This is useful when using git or the registry to determine the current version of packages, since those sources are only available after the first release. Also indicates that changelog generation should not assume a previous git tag exists and that publishing should not check for the existence of the package before running.',
     })
         .check((argv) => {
         if (argv.groups && argv.projects) {
@@ -64,7 +61,7 @@ exports.yargsReleaseCommand = {
 const releaseCommand = {
     command: '$0 [specifier]',
     describe: 'Create a version and release for the workspace, generate a changelog, and optionally publish the packages',
-    builder: (yargs) => yargs
+    builder: (yargs) => withFirstReleaseOptions(yargs)
         .positional('specifier', {
         type: 'string',
         describe: 'Exact version or semver keyword to apply to the selected release group.',
@@ -90,17 +87,14 @@ const releaseCommand = {
         if (args.dryRun) {
             logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
         }
-        if (typeof result === 'number') {
-            process.exit(result);
-        }
-        process.exit(0);
+        process.exit(result);
     },
 };
 const versionCommand = {
     command: 'version [specifier]',
     aliases: ['v'],
     describe: 'Create a version and release for one or more applications and libraries',
-    builder: (yargs) => withGitCommitAndGitTagOptions(yargs
+    builder: (yargs) => withFirstReleaseOptions(withGitCommitAndGitTagOptions(yargs
         .positional('specifier', {
         type: 'string',
         describe: 'Exact version or semver keyword to apply to the selected release group.',
@@ -113,24 +107,21 @@ const versionCommand = {
         .option('stage-changes', {
         type: 'boolean',
         describe: 'Whether or not to stage the changes made by this command. Useful when combining this command with changelog generation.',
-    })),
+    }))),
     handler: async (args) => {
         const release = await Promise.resolve().then(() => require('./version'));
         const result = await release.releaseVersionCLIHandler(args);
         if (args.dryRun) {
             logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
         }
-        if (typeof result === 'number') {
-            process.exit(result);
-        }
-        process.exit(0);
+        process.exit(result);
     },
 };
 const changelogCommand = {
     command: 'changelog [version]',
     aliases: ['c'],
     describe: 'Generate a changelog for one or more projects, and optionally push to Github',
-    builder: (yargs) => withGitCommitAndGitTagOptions(yargs
+    builder: (yargs) => withFirstReleaseOptions(withGitCommitAndGitTagOptions(yargs
         // Disable default meaning of yargs version for this command
         .version(false)
         .positional('version', {
@@ -162,24 +153,21 @@ const changelogCommand = {
             throw new Error('An explicit target version must be specified when using the changelog command directly');
         }
         return true;
-    })),
+    }))),
     handler: async (args) => {
         const release = await Promise.resolve().then(() => require('./changelog'));
         const result = await release.releaseChangelogCLIHandler(args);
         if (args.dryRun) {
             logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
         }
-        if (typeof result === 'number') {
-            process.exit(result);
-        }
-        process.exit(0);
+        process.exit(result);
     },
 };
 const publishCommand = {
     command: 'publish',
     aliases: ['p'],
     describe: 'Publish a versioned project to a registry',
-    builder: (yargs) => (0, shared_options_1.withRunManyOptions)((0, shared_options_1.withOutputStyleOption)(yargs))
+    builder: (yargs) => withFirstReleaseOptions((0, shared_options_1.withRunManyOptions)((0, shared_options_1.withOutputStyleOption)(yargs))
         .option('registry', {
         type: 'string',
         description: 'The registry to publish to',
@@ -191,7 +179,7 @@ const publishCommand = {
         .option('otp', {
         type: 'number',
         description: 'A one-time password for publishing to a registry that requires 2FA',
-    }),
+    })),
     handler: async (args) => {
         const status = await (await Promise.resolve().then(() => require('./publish'))).releasePublishCLIHandler(coerceParallelOption((0, shared_options_1.withOverrides)(args, 2)));
         if (args.dryRun) {
@@ -200,6 +188,40 @@ const publishCommand = {
         process.exit(status);
     },
 };
+const planCommand = {
+    command: 'plan [bump]',
+    aliases: ['pl'],
+    // Create a plan to pick a new version and generate a changelog entry.
+    // Hidden for now until the feature is more stable
+    describe: false,
+    builder: (yargs) => yargs
+        .positional('bump', {
+        type: 'string',
+        describe: 'Semver keyword to use for the selected release group.',
+        choices: [
+            'major',
+            'premajor',
+            'minor',
+            'preminor',
+            'patch',
+            'prepatch',
+            'prerelease',
+        ],
+    })
+        .option('message', {
+        type: 'string',
+        alias: 'm',
+        describe: 'Custom message to use for the changelog entry',
+    }),
+    handler: async (args) => {
+        const release = await Promise.resolve().then(() => require('./plan'));
+        const result = await release.releasePlanCLIHandler(args);
+        if (args.dryRun) {
+            logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+        }
+        process.exit(result);
+    },
+};
 function coerceParallelOption(args) {
     if (args['parallel'] === 'false' || args['parallel'] === false) {
         return {
@@ -254,3 +276,9 @@ function withGitCommitAndGitTagOptions(yargs) {
         type: 'boolean',
     });
 }
+function withFirstReleaseOptions(yargs) {
+    return yargs.option('first-release', {
+        type: 'boolean',
+        description: 'Indicates that this is the first release for the selected release group. If the current version cannot be determined as usual, the version on disk will be used as a fallback. This is useful when using git or the registry to determine the current version of packages, since those sources are only available after the first release. Also indicates that changelog generation should not assume a previous git tag exists and that publishing should not check for the existence of the package before running.',
+    });
+}

package/src/command-line/release/config/config.js

@@ -73,12 +73,14 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
     const defaultFixedReleaseTagPattern = 'v{version}';
     const defaultIndependentReleaseTagPattern = '{projectName}@{version}';
     const workspaceProjectsRelationship = userConfig.projectsRelationship || 'fixed';
-    const defaultGeneratorOptions = userConfig.version?.conventionalCommits
-        ? {
-            currentVersionResolver: 'git-tag',
-            specifierSource: 'conventional-commits',
-        }
-        : {};
+    const defaultGeneratorOptions = {};
+    if (userConfig.version?.conventionalCommits) {
+        defaultGeneratorOptions.currentVersionResolver = 'git-tag';
+        defaultGeneratorOptions.specifierSource = 'conventional-commits';
+    }
+    if (userConfig.versionPlans) {
+        defaultGeneratorOptions.specifierSource = 'version-plans';
+    }
     const userGroups = Object.values(userConfig.groups ?? {});
     const disableWorkspaceChangelog = userGroups.length > 1 ||
         (userGroups.length === 1 &&
@@ -134,6 +136,7 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
                 ? defaultIndependentReleaseTagPattern
                 : defaultFixedReleaseTagPattern),
         conventionalCommits: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG,
+        versionPlans: false,
     };
     const groupProjectsRelationship = userConfig.projectsRelationship || WORKSPACE_DEFAULTS.projectsRelationship;
     const GROUP_DEFAULTS = {
@@ -159,6 +162,7 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
         groupProjectsRelationship === 'independent'
             ? defaultIndependentReleaseTagPattern
             : WORKSPACE_DEFAULTS.releaseTagPattern,
+        versionPlans: false,
     };
     /**
      * We first process root level config and apply defaults, so that we know how to handle the group level
@@ -187,6 +191,7 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
             git: userConfig.git,
         },
     ], normalizeTrueToEmptyObject(userConfig.changelog));
+    const rootVersionPlansConfig = userConfig.versionPlans ?? WORKSPACE_DEFAULTS.versionPlans;
     const rootConventionalCommitsConfig = deepMergeDefaults([WORKSPACE_DEFAULTS.conventionalCommits], fillUnspecifiedConventionalCommitsProperties(normalizeConventionalCommitsConfig(userConfig.conventionalCommits)));
     // these options are not supported at the group level, only the root/command level
     const rootVersionWithoutGlobalOptions = { ...rootVersionConfig };
@@ -205,6 +210,16 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
             .currentVersionResolver;
         delete rootVersionWithoutGlobalOptions.generatorOptions.specifierSource;
     }
+    // Apply versionPlans shorthand to the final group defaults if explicitly configured in the original user config
+    if (userConfig.versionPlans) {
+        rootVersionWithoutGlobalOptions.generatorOptions = {
+            ...rootVersionWithoutGlobalOptions.generatorOptions,
+            specifierSource: 'version-plans',
+        };
+    }
+    if (userConfig.versionPlans === false) {
+        delete rootVersionWithoutGlobalOptions.generatorOptions.specifierSource;
+    }
     const groups = userConfig.groups && Object.keys(userConfig.groups).length
         ? ensureProjectsConfigIsArray(userConfig.groups)
         : /**
@@ -228,6 +243,7 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
                     releaseTagPattern: userConfig.releaseTagPattern || GROUP_DEFAULTS.releaseTagPattern,
                     // Directly inherit the root level config for projectChangelogs, if set
                     changelog: rootChangelogConfig.projectChangelogs || false,
+                    versionPlans: rootVersionPlansConfig || GROUP_DEFAULTS.versionPlans,
                 },
             };
     /**
@@ -298,6 +314,7 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
                 (projectsRelationship === 'independent'
                     ? defaultIndependentReleaseTagPattern
                     : userConfig.releaseTagPattern || defaultFixedReleaseTagPattern),
+            versionPlans: releaseGroup.versionPlans ?? rootVersionPlansConfig,
         };
         const finalReleaseGroup = deepMergeDefaults([groupDefaults], {
             ...releaseGroup,
@@ -317,6 +334,20 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
             delete finalReleaseGroup.version.generatorOptions.currentVersionResolver;
             delete finalReleaseGroup.version.generatorOptions.specifierSource;
         }
+        // Apply versionPlans shorthand to the final group if explicitly configured in the original group
+        if (releaseGroup.versionPlans) {
+            finalReleaseGroup.version = {
+                ...finalReleaseGroup.version,
+                generatorOptions: {
+                    ...finalReleaseGroup.version?.generatorOptions,
+                    specifierSource: 'version-plans',
+                },
+            };
+        }
+        if (releaseGroup.versionPlans === false &&
+            releaseGroupName !== exports.IMPLICIT_DEFAULT_RELEASE_GROUP) {
+            delete finalReleaseGroup.version.generatorOptions.specifierSource;
+        }
         releaseGroups[releaseGroupName] = finalReleaseGroup;
     }
     ensureChangelogRenderersAreResolvable(releaseGroups, rootChangelogConfig);
@@ -330,6 +361,7 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
             changelog: rootChangelogConfig,
             groups: releaseGroups,
             conventionalCommits: rootConventionalCommitsConfig,
+            versionPlans: rootVersionPlansConfig,
         },
     };
 }

package/src/command-line/release/config/filter-release-groups.d.ts

@@ -1,7 +1,9 @@
 import { ProjectGraph } from '../../../config/project-graph';
 import { NxReleaseConfig } from './config';
-export type ReleaseGroupWithName = NxReleaseConfig['groups'][string] & {
+import { GroupVersionPlan, ProjectsVersionPlan } from './version-plans';
+export type ReleaseGroupWithName = Omit<NxReleaseConfig['groups'][string], 'versionPlans'> & {
     name: string;
+    versionPlans: (ProjectsVersionPlan | GroupVersionPlan)[] | false;
 };
 export declare function filterReleaseGroups(projectGraph: ProjectGraph, nxReleaseConfig: NxReleaseConfig, projectsFilter?: string[], groupsFilter?: string[]): {
     error: null | {

package/src/command-line/release/config/filter-release-groups.js

@@ -9,6 +9,7 @@ function filterReleaseGroups(projectGraph, nxReleaseConfig, projectsFilter, grou
         return {
             ...group,
             name,
+            versionPlans: group.versionPlans ? [] : false,
         };
     });
     const filteredProjectToReleaseGroup = new Map();

package/src/command-line/release/config/version-plans.d.ts

@@ -0,0 +1,24 @@
+import { ReleaseType } from 'semver';
+import { ReleaseGroupWithName } from './filter-release-groups';
+export interface VersionPlanFile {
+    absolutePath: string;
+    relativePath: string;
+    fileName: string;
+    createdOnMs: number;
+}
+export interface RawVersionPlan extends VersionPlanFile {
+    content: Record<string, string>;
+    message: string;
+}
+export interface VersionPlan extends VersionPlanFile {
+    message: string;
+}
+export interface GroupVersionPlan extends VersionPlan {
+    groupVersionBump: ReleaseType;
+}
+export interface ProjectsVersionPlan extends VersionPlan {
+    projectVersionBumps: Record<string, ReleaseType>;
+}
+export declare function readRawVersionPlans(): Promise<RawVersionPlan[]>;
+export declare function setVersionPlansOnGroups(rawVersionPlans: RawVersionPlan[], releaseGroups: ReleaseGroupWithName[], allProjectNamesInWorkspace: string[]): ReleaseGroupWithName[];
+export declare function getVersionPlansAbsolutePath(): string;

package/src/command-line/release/config/version-plans.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVersionPlansAbsolutePath = exports.setVersionPlansOnGroups = exports.readRawVersionPlans = void 0;
+const fs_1 = require("fs");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const semver_1 = require("semver");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const config_1 = require("./config");
+const fm = require('front-matter');
+const versionPlansDirectory = (0, path_1.join)('.nx', 'version-plans');
+async function readRawVersionPlans() {
+    const versionPlansPath = getVersionPlansAbsolutePath();
+    const versionPlansPathExists = await (0, fs_extra_1.pathExists)(versionPlansPath);
+    if (!versionPlansPathExists) {
+        return [];
+    }
+    const versionPlans = [];
+    const versionPlanFiles = (0, fs_1.readdirSync)(versionPlansPath);
+    for (const versionPlanFile of versionPlanFiles) {
+        const filePath = (0, path_1.join)(versionPlansPath, versionPlanFile);
+        const versionPlanContent = (0, fs_1.readFileSync)(filePath).toString();
+        const versionPlanStats = await (0, fs_extra_1.stat)(filePath);
+        const parsedContent = fm(versionPlanContent);
+        versionPlans.push({
+            absolutePath: filePath,
+            relativePath: (0, path_1.join)(versionPlansDirectory, versionPlanFile),
+            fileName: versionPlanFile,
+            content: parsedContent.attributes,
+            message: getSingleLineMessage(parsedContent.body),
+            createdOnMs: versionPlanStats.birthtimeMs,
+        });
+    }
+    return versionPlans;
+}
+exports.readRawVersionPlans = readRawVersionPlans;
+function setVersionPlansOnGroups(rawVersionPlans, releaseGroups, allProjectNamesInWorkspace) {
+    const groupsByName = releaseGroups.reduce((acc, group) => acc.set(group.name, group), new Map());
+    const isDefaultGroup = isDefault(releaseGroups);
+    for (const rawVersionPlan of rawVersionPlans) {
+        for (const [key, value] of Object.entries(rawVersionPlan.content)) {
+            if (groupsByName.has(key)) {
+                const group = groupsByName.get(key);
+                if (!group.versionPlans) {
+                    if (isDefaultGroup) {
+                        throw new Error(`Found a version bump in '${rawVersionPlan.fileName}' but version plans are not enabled.`);
+                    }
+                    else {
+                        throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' but the group does not have version plans enabled.`);
+                    }
+                }
+                if (group.projectsRelationship === 'independent') {
+                    if (isDefaultGroup) {
+                        throw new Error(`Found a version bump in '${rawVersionPlan.fileName}' but projects are configured to be independently versioned. Individual projects should be bumped instead.`);
+                    }
+                    else {
+                        throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' but the group's projects are independently versioned. Individual projects of '${key}' should be bumped instead.`);
+                    }
+                }
+                if (!isReleaseType(value)) {
+                    if (isDefaultGroup) {
+                        throw new Error(`Found a version bump in '${rawVersionPlan.fileName}' with an invalid release type. Please specify one of ${semver_1.RELEASE_TYPES.join(', ')}.`);
+                    }
+                    else {
+                        throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' with an invalid release type. Please specify one of ${semver_1.RELEASE_TYPES.join(', ')}.`);
+                    }
+                }
+                const existingPlan = (group.versionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
+                if (existingPlan) {
+                    if (existingPlan.groupVersionBump !== value) {
+                        if (isDefaultGroup) {
+                            throw new Error(`Found a version bump in '${rawVersionPlan.fileName}' that conflicts with another version bump. When in fixed versioning mode, all version bumps must match.`);
+                        }
+                        else {
+                            throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' that conflicts with another version bump for this group. When the group is in fixed versioning mode, all groups' version bumps within the same version plan must match.`);
+                        }
+                    }
+                }
+                else {
+                    group.versionPlans.push({
+                        absolutePath: rawVersionPlan.absolutePath,
+                        relativePath: rawVersionPlan.relativePath,
+                        fileName: rawVersionPlan.fileName,
+                        createdOnMs: rawVersionPlan.createdOnMs,
+                        message: rawVersionPlan.message,
+                        groupVersionBump: value,
+                    });
+                }
+            }
+            else {
+                const groupForProject = releaseGroups.find((group) => group.projects.includes(key));
+                if (!groupForProject) {
+                    if (!allProjectNamesInWorkspace.includes(key)) {
+                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but the project does not exist in the workspace.`);
+                    }
+                    if (isDefaultGroup) {
+                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but the project is not configured for release. Ensure it is included by the 'release.projects' globs in nx.json.`);
+                    }
+                    else {
+                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but the project is not in any configured release groups.`);
+                    }
+                }
+                if (!groupForProject.versionPlans) {
+                    if (isDefaultGroup) {
+                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but version plans are not enabled.`);
+                    }
+                    else {
+                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but the project's group '${groupForProject.name}' does not have version plans enabled.`);
+                    }
+                }
+                if (!isReleaseType(value)) {
+                    throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' with an invalid release type. Please specify one of ${semver_1.RELEASE_TYPES.join(', ')}.`);
+                }
+                if (groupForProject.projectsRelationship === 'independent') {
+                    const existingPlan = (groupForProject.versionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
+                    if (existingPlan) {
+                        existingPlan.projectVersionBumps[key] = value;
+                    }
+                    else {
+                        groupForProject.versionPlans.push({
+                            absolutePath: rawVersionPlan.absolutePath,
+                            relativePath: rawVersionPlan.relativePath,
+                            fileName: rawVersionPlan.fileName,
+                            createdOnMs: rawVersionPlan.createdOnMs,
+                            message: rawVersionPlan.message,
+                            projectVersionBumps: {
+                                [key]: value,
+                            },
+                        });
+                    }
+                }
+                else {
+                    const existingPlan = (groupForProject.versionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
+                    // This can occur if the same fixed release group has multiple entries for different projects within
+                    // the same version plan file. This will be the case when users are using the default release group.
+                    if (existingPlan) {
+                        if (existingPlan.groupVersionBump !== value) {
+                            if (isDefaultGroup) {
+                                throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' that conflicts with another version bump. When in fixed versioning mode, all version bumps must match.`);
+                            }
+                            else {
+                                throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' that conflicts with another project's version bump in the same release group '${groupForProject.name}'. When the group is in fixed versioning mode, all projects' version bumps within the same group must match.`);
+                            }
+                        }
+                    }
+                    else {
+                        groupForProject.versionPlans.push({
+                            absolutePath: rawVersionPlan.absolutePath,
+                            relativePath: rawVersionPlan.relativePath,
+                            fileName: rawVersionPlan.fileName,
+                            createdOnMs: rawVersionPlan.createdOnMs,
+                            message: rawVersionPlan.message,
+                            // This is a fixed group, so the version bump is for the group, even if a project within it was specified
+                            groupVersionBump: value,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // Order the plans from newest to oldest
+    releaseGroups.forEach((group) => {
+        if (group.versionPlans) {
+            group.versionPlans.sort((a, b) => b.createdOnMs - a.createdOnMs);
+        }
+    });
+    return releaseGroups;
+}
+exports.setVersionPlansOnGroups = setVersionPlansOnGroups;
+function isDefault(releaseGroups) {
+    return (releaseGroups.length === 1 &&
+        releaseGroups.some((group) => group.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP));
+}
+function getVersionPlansAbsolutePath() {
+    return (0, path_1.join)(workspace_root_1.workspaceRoot, versionPlansDirectory);
+}
+exports.getVersionPlansAbsolutePath = getVersionPlansAbsolutePath;
+function isReleaseType(value) {
+    return semver_1.RELEASE_TYPES.includes(value);
+}
+// changelog messages may only be a single line long, so ignore anything else
+function getSingleLineMessage(message) {
+    return message.trim().split('\n')[0];
+}

package/src/command-line/release/plan.d.ts

@@ -0,0 +1,3 @@
+import { PlanOptions } from './command-object';
+export declare const releasePlanCLIHandler: (args: PlanOptions) => Promise<number>;
+export declare function releasePlan(args: PlanOptions): Promise<string | number>;