@contentstack/cli-cm-bulk-publish 1.6.0 → 1.7.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contentstack/cli-cm-bulk-publish",
   "description": "Contentstack CLI plugin for bulk publish actions",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "author": "Contentstack",
   "bugs": "https://github.com/contentstack/cli/issues",
   "dependencies": {
@@ -14,15 +14,15 @@
     "lodash": "^4.17.21",
     "mkdirp": "^1.0.4",
     "nock": "^13.5.5",
-    "winston": "^3.15.0"
+    "winston": "^3.16.0"
   },
   "devDependencies": {
-    "@oclif/test": "^2.5.6",
+    "@oclif/test": "^4.1.0",
     "chai": "^4.5.0",
     "eslint": "^8.57.1",
     "eslint-config-oclif": "^4.0.0",
     "globby": "^10.0.2",
-    "mocha": "^10.7.3",
+    "mocha": "^10.8.2",
     "nyc": "^15.1.0",
     "oclif": "^3.17.2",
     "tslib": "^1.14.1"
@@ -99,4 +99,4 @@
     "version": "oclif readme && git add README.md",
     "clean": "rm -rf ./node_modules tsconfig.build.tsbuildinfo"
   }
-}
+}

package/src/commands/cm/assets/publish.js

@@ -157,79 +157,77 @@ But, if retryFailed flag is set, then only a logfile is required
 AssetsPublishCommand.flags = {
   alias: flags.string({
     char: 'a',
-    description: 'Alias(name) for the management token',
+    description: 'Alias (name) for the management token. You must use either the --alias flag or the --stack-api-key flag.',
   }),
   'stack-api-key': flags.string({
     char: 'k',
-    description: 'Stack api key to be used',
+    description: 'API key of the source stack. You must use either the --stack-api-key flag or the --alias flag.',
     required: false,
   }),
   'retry-failed': flags.string({
-    description: 'Retry publishing failed assets from the logfile (optional, will override all other flags)',
+    description: 'Use this option to retry publishing the failed assets from the logfile. Specify the name of the logfile that lists failed publish calls. If this option is used, it will override all other flags.',
   }),
   environments: flags.string({
     char: 'e',
-    description: 'Environments where assets will be published',
+    description: 'The name of the environment on which entries will be published. In case of multiple environments, specify their names separated by spaces.',
     multiple: true,
   }),
   'folder-uid': flags.string({
-    description: '[default: cs_root] Folder-uid from where the assets will be published',
+    description: '(optional) The UID of the Assets’ folder from which the assets need to be published. The default value is cs_root.',
     exclusive: ['source-env'],
   }),
   'bulk-publish': flags.string({
-    description:
-      "By default this flag is set as true. It indicates that contentstack's bulkpublish API will be used to publish the assets",
+    description: 'Set this flag to use Contentstack’s Bulk Publish APIs. It is true, by default.',
     default: 'true',
   }),
   config: flags.string({
     char: 'c',
-    description: 'Path to the config file',
+    description: '(optional) The path of the optional configuration JSON file containing all the options for a single run. Refer to the configure command to create a configuration file.',
   }),
   yes: flags.boolean({
     char: 'y',
-    description: 'Agree to process the command with the current configuration',
+    description: 'Set it to true to process the command with the current configuration.',
   }),
   locales: flags.string({
     char: 'l',
-    description: 'Locales to where assets will be published',
+    description: 'Locales in which assets will be published, e.g., en-us. In the case of multiple locales, specify the codes separated by spaces.',
     multiple: true,
     parse: printFlagDeprecation(['-l'], ['--locales']),
   }),
   branch: flags.string({
     char: 'B',
     default: 'main',
-    description: 'Specify the branch to fetch the content (by default the main branch is selected)',
+    description: 'The name of the branch where you want to perform the bulk publish operation. If you don’t mention the branch name, then by default the assets from the main branch will be published.',
     parse: printFlagDeprecation(['-B'], ['--branch']),
   }),
-
+  
   // To be deprecated
   retryFailed: flags.string({
     char: 'r',
-    description: 'Retry publishing failed assets from the logfile (optional, will override all other flags)',
+    description: 'Retry publishing failed assets from the logfile (optional, will override all other flags).',
     hidden: true,
     parse: printFlagDeprecation(['-r', '--retryFailed'], ['--retry-failed']),
   }),
   folderUid: flags.string({
     char: 'u',
-    description: '[default: cs_root] Folder-uid from where the assets will be published',
+    description: '(default: cs_root) Folder-uid from where the assets will be published.',
     hidden: true,
     parse: printFlagDeprecation(['-u', '--folderUid'], ['--folder-uid']),
     exclusive: ['source-env'],
   }),
   bulkPublish: flags.string({
     char: 'b',
-    description:
-      "By default this flag is set as true. It indicates that contentstack's bulkpublish API will be used to publish the entries",
+    description: "By default this flag is set as true. It indicates that Contentstack's bulk publish API will be used to publish the entries.",
     default: 'true',
     hidden: true,
     parse: printFlagDeprecation(['-b', '--bulkPublish'], ['--bulk-publish']),
   }),
   'api-version': flags.string({
-    description : "API Version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
+    description: "API version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
   }),
-  'delivery-token': flags.string({ description: 'Delivery token for source environment' }),
+  'delivery-token': flags.string({ description: 'The delivery token of the source environment.' }),
   'source-env': flags.string({ description: 'Source environment' }),
-  'content-types': flags.string({ description: 'Content types', hidden: true, multiple: true }), // this is a work around, as this command is to be run with entries:publish command and should not break flags check.
+  'content-types': flags.string({ description: 'Content types', hidden: true, multiple: true }),
 };
 
 AssetsPublishCommand.examples = [

package/src/commands/cm/assets/unpublish.js

@@ -134,45 +134,44 @@ But, if retry-failed flag is set, then only a logfile is required`;
 UnpublishCommand.flags = {
   alias: flags.string({
     char: 'a',
-    description: 'Alias(name) for the management token',
+    description: 'Alias (name) of the management token. You must use either the --alias flag or the --stack-api-key flag.',
   }),
   'stack-api-key': flags.string({
     char: 'k',
-    description: 'Stack api key to be used',
+    description: 'API key of the source stack. You must use either the --stack-api-key flag or the --alias flag.',
     required: false,
   }),
   environment: flags.string({
     char: 'e',
-    description: 'Source Environment',
+    description: 'The name of the environment from where entries/assets need to be unpublished.',
   }),
   config: flags.string({
     char: 'c',
-    description: 'Path to the config file',
+    description: '(optional) Path of an optional configuration JSON file containing all the options for a single run. Refer to the configure command to create a configuration file.',
   }),
   yes: flags.boolean({
     char: 'y',
-    description: 'Agree to process the command with the current configuration',
+    description: 'Set it to true to process the command with the current configuration.',
   }),
   locale: flags.string({
-    description: 'Locale filter',
+    description: 'Locale from which entries/assets will be unpublished, e.g., en-us.',
   }),
   branch: flags.string({
     default: 'main',
-    description: 'Specify the branch to fetch the content (by default the main branch is selected)',
+    description: 'The name of the branch where you want to perform the bulk unpublish operation. If you don’t mention the branch name, then by default the content from the main branch will be unpublished.',
   }),
   'retry-failed': flags.string({
-    description: 'Retry unpublishing failed assets from the logfile',
+    description: '(optional) Use this option to retry unpublishing the failed entries from the logfile. Specify the name of the logfile that lists failed unpublish calls. If this option is used, it will override all other flags.',
   }),
   'bulk-unpublish': flags.string({
-    description:
-      "By default this flag is set as true. It indicates that contentstack's bulkpublish API will be used to unpublish the assets",
+    description: 'Set this flag to use Contentstack’s Bulk Publish APIs. It is true, by default.',
     default: 'true',
   }),
   'api-version': flags.string({
-    description : "API Version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
+    description: 'API version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].',
   }),
   'delivery-token': flags.string({
-    description: 'Delivery Token for source environment',
+    description: 'The delivery token of the source environment.',
   }),
 };
 

package/src/commands/cm/bulk-publish/cross-publish.js

@@ -46,7 +46,7 @@ class CrossPublishCommand extends Command {
           updatedFlags.deliveryToken = await cliux.prompt('Enter delivery token of your source environment');
         }
         updatedFlags.bulkPublish = updatedFlags.bulkPublish === 'false' ? false : true;
-
+        updatedFlags.includeVariants = updatedFlags.includeVariants === false ? false : true;
         stack = await getStack(config);
       }
 
@@ -155,6 +155,10 @@ class CrossPublishCommand extends Command {
       _flags.deliveryToken = _flags['delivery-token'];
       delete _flags['delivery-token'];
     }
+    if ('include-variants' in _flags) {
+      _flags.includeVariants = _flags['include-variants'];
+      delete _flags['include-variants'];
+    }
     return _flags;
   }
 }
@@ -186,17 +190,17 @@ CrossPublishCommand.flags = {
     char: 'b',
     hidden: true,
     description:
-      "This flag is set to true by default. It indicates that contentstack's bulkpublish API will be used to publish the entries",
+      "Set this flag to use Contentstack’s Bulk Publish APIs. It is true, by default.",
     default: 'true',
     parse: printFlagDeprecation(['--bulkPublish', '-b'], ['--bulk-publish']),
   }),
   'bulk-publish': flags.string({
     description:
-      "This flag is set to true by default. It indicates that contentstack's bulkpublish API will be used to publish the entries",
+      "Set this flag to use Contentstack’s Bulk Publish APIs. It is true, by default.",
     default: 'true',
   }),
   'api-version': flags.string({
-    description: 'API Version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].',
+    description: 'API version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].',
   }),
   contentType: flags.string({
     char: 't',
@@ -240,12 +244,12 @@ CrossPublishCommand.flags = {
   }),
   deliveryToken: flags.string({
     char: 'x',
-    description: 'Delivery token for source environment',
+    description: 'The delivery token of the source environment.',
     hidden: true,
     parse: printFlagDeprecation(['--deliveryToken', '-x'], ['--delivery-token']),
   }),
   'delivery-token': flags.string({
-    description: 'Delivery token for source environment',
+    description: 'The delivery token of the source environment.',
   }),
   config: flags.string({ char: 'c', description: 'Path to the config file' }),
   yes: flags.boolean({ char: 'y', description: 'Agree to process the command with the current configuration' }),
@@ -257,6 +261,10 @@ CrossPublishCommand.flags = {
   }),
   onlyAssets: flags.boolean({ description: 'Unpublish only assets', default: false }),
   onlyEntries: flags.boolean({ description: 'Unpublish only entries', default: false }),
+  'include-variants': flags.boolean({
+    description: 'Include Variants flag will publish all associated variant entries.',
+    default: false,
+  }),
 };
 
 CrossPublishCommand.examples = [
@@ -278,8 +286,11 @@ CrossPublishCommand.examples = [
   'Using --stack-api-key flag',
   'csdx cm:bulk-publish:cross-publish --content-type [CONTENT TYPE] --source-env [SOURCE ENV] --environments [DESTINATION ENVIRONMENT] --locales [LOCALE] --stack-api-key [STACK API KEY] --delivery-token [DELIVERY TOKEN]',
   '',
+  'Using --include-variants flag',
+  'csdx cm:bulk-publish:cross-publish --content-type [CONTENT TYPE] --source-env [SOURCE ENV] --environments [DESTINATION ENVIRONMENT] --locales [LOCALE] --stack-api-key [STACK API KEY] --delivery-token [DELIVERY TOKEN] [--include-variants]',
+  '',
 ];
 
-CrossPublishCommand.usage = `cm:bulk-publish:cross-publish [-a <value>] [--retry-failed <value>] [--bulk-publish <value>] [--content-type <value>] [--locales <value>] [--source-env <value>] [--environments <value>] [--delivery-token <value>] [-c <value>] [-y] [--branch <value>] [--onlyAssets] [--onlyEntries]`;
+CrossPublishCommand.usage = `cm:bulk-publish:cross-publish [-a <value>] [--retry-failed <value>] [--bulk-publish <value>] [--content-type <value>] [--locales <value>] [--source-env <value>] [--environments <value>] [--delivery-token <value>] [-c <value>] [-y] [--branch <value>] [--onlyAssets] [--onlyEntries] [--include-variants]`;
 
 module.exports = CrossPublishCommand;

package/src/commands/cm/entries/publish-modified.js

@@ -125,69 +125,69 @@ But, if retry-failed flag is set, then only a logfile is required
 `;
 
 PublishModifiedCommand.flags = {
-  alias: flags.string({ char: 'a', description: 'Alias(name) for the management token' }),
+  alias: flags.string({ char: 'a', description: 'Alias (name) of the management token. You must use either the --alias flag or the --stack-api-key flag.' }),
   'stack-api-key': flags.string({
     char: 'k',
-    description: 'Stack api key to be used',
+    description: 'API key of the source stack. You must use either the --stack-api-key flag or the --alias flag.',
     required: false,
   }),
   retryFailed: flags.string({
     char: 'r',
-    description: 'Retry publishing failed entries from the logfile (optional, overrides all other flags)',
+    description: '(optional) Use this option to retry publishing the failed entries/assets from the logfile. Specify the name of the logfile that lists failed publish calls. If this option is used, it will override all other flags',
     hidden: true,
     parse: printFlagDeprecation(['-r', '--retryFailed'], ['--retry-failed']),
   }),
   'retry-failed': flags.string({
-    description: 'Retry publishing failed entries from the logfile (optional, overrides all other flags)',
+    description: '(optional) Use this option to retry publishing the failed entries/assets from the logfile. Specify the name of the logfile that lists failed publish calls. If this option is used, it will override all other flags',
   }),
   bulkPublish: flags.string({
     char: 'b',
     description:
-      "This flag is set to true by default. It indicates that contentstack's bulkpublish API will be used to publish the entries",
+      "Set this flag to use Contentstack\'s Bulk Publish APIs. It is true, by default.",
     hidden: true,
     parse: printFlagDeprecation(['-b', '--bulkPublish'], ['--bulk-publish']),
   }),
   'bulk-publish': flags.string({
     description:
-      "This flag is set to true by default. It indicates that contentstack's bulkpublish API will be used to publish the entries",
+      "Set this flag to use Contentstack\'s Bulk Publish APIs. It is true, by default.",
     default: 'true',
   }),
   'api-version': flags.string({
-    description : "API Version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
+    description : "API version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
   }),
   sourceEnv: flags.string({
     char: 's',
-    description: 'Environment from which edited entries will be published',
+    description: 'The name of the source environment where the entries were initially published.',
     hidden: true,
     parse: printFlagDeprecation(['-s', '--sourceEnv'], ['--source-env']),
   }),
   'source-env': flags.string({
-    description: 'Environment from which edited entries will be published',
+    description: 'The name of the source environment where the entries were initially published.',
   }),
   contentTypes: flags.string({
     char: 't',
-    description: 'The Content-Types which will be checked for edited entries',
+    description: 'The UID of the content type(s) whose edited entries you want to publish in bulk. In case of multiple content types, specify the IDs separated by spaces.',
     multiple: true,
     parse: printFlagDeprecation(['-t', '--contentTypes'], ['--content-types']),
     hidden: true,
   }),
   'content-types': flags.string({
-    description: 'The Contenttypes which will be checked for edited entries',
+    description: 'The UID of the content type(s) whose edited entries you want to publish in bulk. In case of multiple content types, specify the IDs separated by spaces.',
     multiple: true,
   }),
   locales: flags.string({
     char: 'l',
-    description: 'Locales where edited entries will be published',
+    description: 'Locales in which entries will be published, e.g., en-us. In the case of multiple locales, specify the codes separated by spaces.',
     multiple: true,
     parse: printFlagDeprecation(['-l'], ['--locales']),
   }),
-  environments: flags.string({ char: 'e', description: 'Destination environments', multiple: true }),
-  config: flags.string({ char: 'c', description: 'Path to the config file' }),
-  yes: flags.boolean({ char: 'y', description: 'Agree to process the command with the current configuration' }),
+  environments: flags.string({ char: 'e', description: 'The name of the environment(s) on which the entries will be published. In case of multiple environments, specify their names separated by spaces.', multiple: true }),
+  config: flags.string({ char: 'c', description: '(optional) The path of the optional configuration JSON file containing all the options for a single run. Refer to the configure command to create a configuration file.' }),
+  yes: flags.boolean({ char: 'y', description: 'Set it to true to process the command with the current configuration.' }),
   branch: flags.string({
     char: 'B',
     default: 'main',
-    description: 'Specify the branch to fetch the content (by default the main branch is selected)',
+    description: 'The name of the branch where you want to perform the bulk publish operation. If you don\'t mention the branch name, then by default the entries from main branch will be published.',
     parse: printFlagDeprecation(['-B'], ['--branch']),
   }),
 };

package/src/commands/cm/entries/publish-non-localized-fields.js

@@ -129,65 +129,63 @@ But, if retryFailed flag is set, then only a logfile is required`;
 NonlocalizedFieldChangesCommand.flags = {
   alias: flags.string({
     char: 'a',
-    description: 'Alias(name) for the management token',
+    description: 'Alias (name) of the management token. You must use either the --alias flag or the --stack-api-key flag.',
   }),
   'stack-api-key': flags.string({
     char: 'k',
-    description: 'Stack api key to be used',
+    description: 'API key of the source stack. You must use either the --stack-api-key flag or the --alias flag.',
     required: false,
   }),
   'retry-failed': flags.string({
-    description: 'Retry publishing failed entries from the logfile',
+    description: 'Use this option to retry publishing the failed entries from the logfile. Specify the name of the logfile that lists failed publish calls. If this option is used, it will override all other flags.',
   }),
   'bulk-publish': flags.string({
-    description:
-      "This flag is set to true by default. It indicates that contentstack's bulkpublish API will be used to publish the entries",
+    description: "Set this flag to use Contentstack’s Bulk Publish APIs. It is true, by default.",
     default: 'true',
   }),
   'source-env': flags.string({
-    description: 'Source Environment',
+    description: 'The name of the source environment.',
   }),
   'content-types': flags.string({
-    description: 'The Contenttypes from which entries will be published',
+    description: 'The UID of the content type whose entries you want to publish in bulk. In case of multiple content types, specify their IDs separated by spaces.',
     multiple: true,
   }),
   environments: flags.string({
     char: 'e',
-    description: 'Destination environments',
+    description: 'The name of the environment on which entries will be published. In case of multiple environments, specify their names separated by spaces.',
     multiple: true,
   }),
   config: flags.string({
     char: 'c',
-    description: 'Path to the config file',
+    description: '(optional) The path of the optional configuration JSON file containing all the options for a single run. Refer to the configure command to create a configuration file.',
   }),
   yes: flags.boolean({
     char: 'y',
-    description: 'Agree to process the command with the current configuration',
+    description: 'Set it to true to process the command with the current configuration.',
   }),
   branch: flags.string({
     char: 'B',
     default: 'main',
-    description: 'Specify the branch to fetch the content (by default the main branch is selected)',
+    description: 'The name of the branch where you want to perform the bulk publish operation. If you don’t mention the branch name, then by default the content from the main branch will be published.',
     parse: printFlagDeprecation(['-B'], ['--branch']),
   }),
 
   // To be deprecated
   retryFailed: flags.string({
     char: 'r',
-    description: 'Retry publishing failed entries from the logfile',
+    description: 'Retry publishing failed entries from the logfile.',
     hidden: true,
     parse: printFlagDeprecation(['-r', '--retryFailed'], ['--retry-failed']),
   }),
   bulkPublish: flags.string({
     char: 'b',
-    description:
-      "This flag is set to true by default. It indicates that contentstack's bulkpublish API will be used to publish the entries",
+    description: "This flag is set to true by default. It indicates that Contentstack's bulk publish API will be used to publish the entries.",
     default: 'true',
     hidden: true,
     parse: printFlagDeprecation(['-b', '--bulkPublish'], ['--bulk-publish']),
   }),
   'api-version': flags.string({
-    description : "API Version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
+    description: "API version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
   }),
   sourceEnv: flags.string({
     char: 's',
@@ -197,7 +195,7 @@ NonlocalizedFieldChangesCommand.flags = {
   }),
   contentTypes: flags.string({
     char: 't',
-    description: 'The contenttypes from which entries will be published',
+    description: 'The content types from which entries will be published.',
     multiple: true,
     hidden: true,
     parse: printFlagDeprecation(['-t', '--contentTypes'], ['--content-types']),

package/src/commands/cm/entries/publish-only-unpublished.js

@@ -21,73 +21,73 @@ But, if retry-failed flag is set, then only a logfile is required
 `;
 
 PublishOnlyUnpublished.flags = {
-  alias: flags.string({ char: 'a', description: 'Alias(name) for the management token' }),
+  alias: flags.string({ char: 'a', description: 'Alias (name) of the management token. You must use either the --alias flag or the --stack-api-key flag.' }),
   'stack-api-key': flags.string({
     char: 'k',
-    description: 'Stack api key to be used',
+    description: 'API key of the source stack. You must use either the --stack-api-key flag or the --alias flag.',
   }),
   retryFailed: flags.string({
     char: 'r',
     hidden: true,
-    description: 'Retry publishing failed entries from the logfile',
+    description: '(optional) Use this option to retry publishing the failed entries from the logfile. It is optional. Specify the name of the logfile that lists failed publish calls. If this option is used, it will override all other flags.',
     parse: printFlagDeprecation(['--retryFailed', '-r'], ['--retry-failed']),
   }),
   'retry-failed': flags.string({
-    description: 'Retry publishing failed entries from the logfile',
+    description: '(optional) Use this option to retry publishing the failed entries from the logfile. It is optional. Specify the name of the logfile that lists failed publish calls. If this option is used, it will override all other flags.',
   }),
   bulkPublish: flags.string({
     char: 'b',
     hidden: true,
     description:
-      "This flag is set to true by default. It indicates that contentstack's bulkpublish API will be used to publish the entries",
+      "Set this flag to use Contentstack\'s Bulk Publish APIs. It is true, by default.",
     default: 'true',
     parse: printFlagDeprecation(['--bulkPublish', '-b'], ['--bulk-publish']),
   }),
   'bulk-publish': flags.string({
     char: 'b',
     description:
-      "This flag is set to true by default. It indicates that contentstack's bulkpublish API will be used to publish the entries",
+      "Set this flag to use Contentstack\'s Bulk Publish APIs. It is true, by default.",
     default: 'true',
   }),
   'api-version': flags.string({
-    description : "API Version to be used. Values [Default: 3, Nested Reference Publishing: 3.2].",
+    description : "API version to be used. Values [Default: 3, Nested Reference Publishing: 3.2]..",
   }),
   sourceEnv: flags.string({
     char: 's',
     hidden: true,
-    description: 'Source Env',
+    description: 'The name of the source environment where the entries were initially published.',
     parse: printFlagDeprecation(['--sourceEnv', '-s'], ['--source-env']),
   }),
   'source-env': flags.string({
-    description: 'Source Env',
+    description: 'The name of the source environment where the entries were initially published.',
   }),
   contentTypes: flags.string({
     char: 't',
-    description: 'The Content-Types from which entries need to be published',
+    description: 'The UID of the content type(s) whose entries you want to publish in bulk. In case of multiple content types, specify their IDs separated by spaces.',
     multiple: true,
     hidden: true,
     parse: printFlagDeprecation(['--contentTypes', '-t'], ['--content-types']),
   }),
   'content-types': flags.string({
-    description: 'The Contenttypes from which entries will be published',
+    description: 'The UID of the content type(s) whose entries you want to publish in bulk. In case of multiple content types, specify their IDs separated by spaces.',
     multiple: true,
   }),
   locale: flags.string({
     hidden: true,
     char: 'l',
-    description: 'Source locale',
+    description: 'Locale in which entries will be published, e.g., en-us',
     parse: printFlagDeprecation(['-l'], ['--locales']),
   }),
   locales: flags.string({
-    description: 'Source locale',
+    description: 'Locale in which entries will be published, e.g., en-us',
   }),
-  environments: flags.string({ char: 'e', description: 'Destination environments', multiple: true }),
-  config: flags.string({ char: 'c', description: 'Path to the config file' }),
-  yes: flags.boolean({ char: 'y', description: 'Agree to process the command with the current configuration' }),
+  environments: flags.string({ char: 'e', description: 'The name of the environment on which entries will be published. In case of multiple environments, specify their names separated by spaces.', multiple: true }),
+  config: flags.string({ char: 'c', description: '(optional)  The path of the optional configuration JSON file containing all the options for a single run. Refer to the configure command to create a configuration file.' }),
+  yes: flags.boolean({ char: 'y', description: 'Set it to true to process the command with the current configuration.' }),
   branch: flags.string({
     char: 'B',
     default: 'main',
-    description: 'Specify the branch to fetch the content (by default the main branch is selected)',
+    description: 'The name of the branch where you want to perform the bulk publish operation. If you don\'t mention the branch name, then by default the entries from main branch will be published.',
     parse: printFlagDeprecation(['-B'], ['--branch']),
   }),
 };