@codingame/monaco-vscode-api 25.0.1 → 25.1.1

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration.js

@@ -32,11 +32,11 @@ const autoApproveBoolean = {
         false,
     ],
     enumDescriptions: [
-        ( localize(12095, "Automatically approve the pattern.")),
-        ( localize(12096, "Require explicit approval for the pattern.")),
+        ( localize(12096, "Automatically approve the pattern.")),
+        ( localize(12097, "Require explicit approval for the pattern.")),
     ],
     description: ( localize(
-        12097,
+        12098,
         "The start of a command to match against. A regular expression can be provided by wrapping the string in `/` characters."
     )),
 };
@@ -45,7 +45,7 @@ const terminalChatAgentProfileSchema = {
     required: ['path'],
     properties: {
         path: {
-            description: ( localize(12098, "A path to a shell executable.")),
+            description: ( localize(12099, "A path to a shell executable.")),
             type: 'string',
         },
         ...terminalProfileBaseProperties,
@@ -54,7 +54,7 @@ const terminalChatAgentProfileSchema = {
 const terminalChatAgentToolsConfiguration = {
     [TerminalChatAgentToolsSettingId.EnableAutoApprove]: {
         description: ( localize(
-            12099,
+            12100,
             "Controls whether to allow auto approval in the run in terminal tool."
         )),
         type: 'boolean',
@@ -67,7 +67,7 @@ const terminalChatAgentToolsConfiguration = {
                 description: {
                     key: 'autoApproveMode.description',
                     value: ( localize(
-                        12099,
+                        12100,
                         "Controls whether to allow auto approval in the run in terminal tool."
                     )),
                 }
@@ -77,20 +77,20 @@ const terminalChatAgentToolsConfiguration = {
     [TerminalChatAgentToolsSettingId.AutoApprove]: {
         markdownDescription: [
             ( localize(
-            12100,
+            12101,
             "A list of commands or regular expressions that control whether the run in terminal tool commands require explicit approval. These will be matched against the start of a command. A regular expression can be provided by wrapping the string in {0} characters followed by optional flags such as {1} for case-insensitivity.",
             '`/`',
             '`i`'
         )),
             ( localize(
-            12101,
+            12102,
             "Set to {0} to automatically approve commands, {1} to always require explicit approval or {2} to unset the value.",
             '`true`',
             '`false`',
             '`null`'
         )),
             ( localize(
-            12102,
+            12103,
             "Note that these commands and regular expressions are evaluated for every _sub-command_ within the full _command line_, so {0} for example will need both {1} and {2} to match a {3} entry and must not match a {4} entry in order to auto approve. Inline commands such as {5} (process substitution) should also be detected.",
             '`foo && bar`',
             '`foo`',
@@ -100,48 +100,48 @@ const terminalChatAgentToolsConfiguration = {
             '`<(foo)`'
         )),
             ( localize(
-            12103,
+            12104,
             "An object can be used to match against the full command line instead of matching sub-commands and inline commands, for example {0}. In order to be auto approved _both_ the sub-command and command line must not be explicitly denied, then _either_ all sub-commands or command line needs to be approved.",
             '`{ approve: false, matchCommandLine: true }`'
         )),
             ( localize(
-            12104,
+            12105,
             "Note that there's a default set of rules to allow and also deny commands. Consider setting {0} to {1} to ignore all default rules to ensure there are no conflicts with your own rules. Do this at your own risk, the default denial rules are designed to protect you against running dangerous commands.",
             `\`#${TerminalChatAgentToolsSettingId.IgnoreDefaultAutoApproveRules}#\``,
             '`true`'
         )),
             [
-                ( localize(12105, 'Examples:')),
-                `|${( localize(12106, "Value"))}|${( localize(12107, "Description"))}|`,
+                ( localize(12106, 'Examples:')),
+                `|${( localize(12107, "Value"))}|${( localize(12108, "Description"))}|`,
                 '|---|---|',
-                '| `\"mkdir\": true` | ' + ( localize(12108, "Allow all commands starting with {0}", '`mkdir`')),
-                '| `\"npm run build\": true` | ' + ( localize(12109, "Allow all commands starting with {0}", '`npm run build`')),
+                '| `\"mkdir\": true` | ' + ( localize(12109, "Allow all commands starting with {0}", '`mkdir`')),
+                '| `\"npm run build\": true` | ' + ( localize(12110, "Allow all commands starting with {0}", '`npm run build`')),
                 '| `\"bin/test.sh\": true` | ' + ( localize(
-                    12110,
+                    12111,
                     "Allow all commands that match the path {0} ({1}, {2}, etc.)",
                     '`bin/test.sh`',
                     '`bin\\test.sh`',
                     '`./bin/test.sh`'
                 )),
                 '| `\"/^git (status\\|show\\\\b.*)$/\": true` | ' + ( localize(
-                    12111,
+                    12112,
                     "Allow {0} and all commands starting with {1}",
                     '`git status`',
                     '`git show`'
                 )),
-                '| `\"/^Get-ChildItem\\\\b/i\": true` | ' + ( localize(12112, "will allow {0} commands regardless of casing", '`Get-ChildItem`')),
-                '| `\"/.*/\": true` | ' + ( localize(12113, "Allow all commands (denied commands still require approval)")),
+                '| `\"/^Get-ChildItem\\\\b/i\": true` | ' + ( localize(12113, "will allow {0} commands regardless of casing", '`Get-ChildItem`')),
+                '| `\"/.*/\": true` | ' + ( localize(12114, "Allow all commands (denied commands still require approval)")),
                 '| `\"rm\": false` | ' + ( localize(
-                    12114,
+                    12115,
                     "Require explicit approval for all commands starting with {0}",
                     '`rm`'
                 )),
                 '| `\"/\\\\.ps1/i\": { approve: false, matchCommandLine: true }` | ' + ( localize(
-                    12115,
+                    12116,
                     "Require explicit approval for any _command line_ that contains {0} regardless of casing",
                     '`".ps1"`'
                 )),
-                '| `\"rm\": null` | ' + ( localize(12116, "Unset the default {0} value for {1}", '`false`', '`rm`')),
+                '| `\"rm\": null` | ' + ( localize(12117, "Unset the default {0} value for {1}", '`false`', '`rm`')),
             ].join('\n'),
         ].join('\n\n'),
         type: 'object',
@@ -159,14 +159,14 @@ const terminalChatAgentToolsConfiguration = {
                                 false,
                             ],
                             enumDescriptions: [
-                                ( localize(12117, "Match against the full command line, eg. `foo && bar`.")),
+                                ( localize(12118, "Match against the full command line, eg. `foo && bar`.")),
                                 ( localize(
-                                12118,
+                                12119,
                                 "Match against sub-commands and inline commands, eg. `foo && bar` will need both `foo` and `bar` to match."
                             )),
                             ],
                             description: ( localize(
-                                12119,
+                                12120,
                                 "Whether to match against the full command line, as opposed to splitting by sub-commands and inline commands."
                             )),
                         }
@@ -176,7 +176,7 @@ const terminalChatAgentToolsConfiguration = {
                 {
                     type: 'null',
                     description: ( localize(
-                        12120,
+                        12121,
                         "Ignore the pattern, this is useful for unsetting the same pattern set at a higher scope."
                     )),
                 },
@@ -285,7 +285,7 @@ const terminalChatAgentToolsConfiguration = {
         default: false,
         tags: ['experimental'],
         markdownDescription: ( localize(
-            12121,
+            12122,
             "Whether to ignore the built-in default auto-approve rules used by the run in terminal tool as defined in {0}. When this setting is enabled, the run in terminal tool will ignore any rule that comes from the default set but still follow rules defined in the user, remote and workspace settings. Use this setting at your own risk; the default auto-approve rules are designed to protect you against running dangerous commands.",
             `\`#${TerminalChatAgentToolsSettingId.AutoApprove}#\``
         )),
@@ -296,7 +296,7 @@ const terminalChatAgentToolsConfiguration = {
         default: true,
         tags: ['experimental'],
         markdownDescription: ( localize(
-            12122,
+            12123,
             "Whether to automatically approve npm, yarn, and pnpm run commands when the script is defined in a workspace package.json file. Since the workspace is trusted, scripts defined in package.json are considered safe to run without explicit approval."
         )),
     },
@@ -304,23 +304,23 @@ const terminalChatAgentToolsConfiguration = {
         type: 'string',
         enum: ['never', 'outsideWorkspace', 'all'],
         enumDescriptions: [
-            ( localize(12123, "Allow all detected file writes.")),
+            ( localize(12124, "Allow all detected file writes.")),
             ( localize(
-            12124,
+            12125,
             "Block file writes detected outside the workspace. This depends on the shell integration feature working correctly to determine the current working directory of the terminal."
         )),
-            ( localize(12125, "Block all detected file writes.")),
+            ( localize(12126, "Block all detected file writes.")),
         ],
         default: 'outsideWorkspace',
         tags: ['experimental'],
         markdownDescription: ( localize(
-            12126,
+            12127,
             "Controls whether detected file write operations are blocked in the run in terminal tool. When detected, this will require explicit approval regardless of whether the command would normally be auto approved. Note that this cannot detect all possible methods of writing files, this is what is currently detected:\n\n- File redirection (detected via the bash or PowerShell tree sitter grammar)"
         )),
     },
     [TerminalChatAgentToolsSettingId.ShellIntegrationTimeout]: {
         markdownDescription: ( localize(
-            12127,
+            12128,
             "Configures the duration in milliseconds to wait for shell integration to be detected when the run in terminal tool launches a new terminal. Set to `0` to wait the minimum time, the default value `-1` means the wait time is variable based on the value of {0} and whether it's a remote window. A large value can be useful if your shell starts very slowly and a low value if you're intentionally not using shell integration.",
             `\`#${TerminalSettingId.ShellIntegrationEnabled}#\``
         )),
@@ -329,7 +329,7 @@ const terminalChatAgentToolsConfiguration = {
         maximum: 60000,
         default: -1,
         markdownDeprecationMessage: ( localize(
-            12128,
+            12129,
             'Use {0} instead',
             `\`#${TerminalSettingId.ShellIntegrationTimeout}#\``
         ))
@@ -337,7 +337,7 @@ const terminalChatAgentToolsConfiguration = {
     [TerminalChatAgentToolsSettingId.TerminalProfileLinux]: {
         restricted: true,
         markdownDescription: ( localize(
-            12129,
+            12130,
             "The terminal profile to use on Linux for chat agent's run in terminal tool."
         )),
         type: ['object', 'null'],
@@ -357,7 +357,7 @@ const terminalChatAgentToolsConfiguration = {
     [TerminalChatAgentToolsSettingId.TerminalProfileMacOs]: {
         restricted: true,
         markdownDescription: ( localize(
-            12130,
+            12131,
             "The terminal profile to use on macOS for chat agent's run in terminal tool."
         )),
         type: ['object', 'null'],
@@ -377,7 +377,7 @@ const terminalChatAgentToolsConfiguration = {
     [TerminalChatAgentToolsSettingId.TerminalProfileWindows]: {
         restricted: true,
         markdownDescription: ( localize(
-            12131,
+            12132,
             "The terminal profile to use on Windows for chat agent's run in terminal tool."
         )),
         type: ['object', 'null'],
@@ -399,17 +399,17 @@ const terminalChatAgentToolsConfiguration = {
         default: false,
         tags: ['experimental'],
         markdownDescription: ( localize(
-            12132,
+            12133,
             "Whether to automatically respond to prompts in the terminal such as `Confirm? y/n`. This is an experimental feature and may not work in all scenarios."
         )),
     },
     [TerminalChatAgentToolsSettingId.OutputLocation]: {
-        markdownDescription: ( localize(12133, "Where to show the output from the run in terminal tool session.")),
+        markdownDescription: ( localize(12134, "Where to show the output from the run in terminal tool session.")),
         type: 'string',
         enum: ['terminal', 'none'],
         enumDescriptions: [
-            ( localize(12134, "Reveal the terminal when running the command.")),
-            ( localize(12135, "Do not reveal the terminal automatically.")),
+            ( localize(12135, "Reveal the terminal when running the command.")),
+            ( localize(12136, "Do not reveal the terminal automatically.")),
         ],
         default: product.quality !== 'stable' ? 'none' : 'terminal',
         tags: ['experimental'],
@@ -422,23 +422,23 @@ const terminalChatAgentToolsConfiguration = {
         default: true,
         markdownDescription: [
             ( localize(
-            12136,
+            12137,
             "Whether to exclude commands run by the terminal tool from the shell history. See below for the supported shells and the method used for each:"
         )),
             `- \`bash\`: ${( localize(
-                12137,
+                12138,
                 "Sets `HISTCONTROL=ignorespace` and prepends the command with space"
             ))}`,
             `- \`zsh\`: ${( localize(
-                12138,
+                12139,
                 "Sets `HIST_IGNORE_SPACE` option and prepends the command with space"
             ))}`,
             `- \`fish\`: ${( localize(
-                12139,
+                12140,
                 "Sets `fish_private_mode` to prevent any command from entering history"
             ))}`,
             `- \`pwsh\`: ${( localize(
-                12140,
+                12141,
                 "Sets a custom history handler via PSReadLine's `AddToHistoryHandler` to prevent any command from entering history"
             ))}`,
         ].join('\n'),
@@ -454,7 +454,7 @@ for (const id of [
     terminalChatAgentToolsConfiguration[id] = {
         deprecated: true,
         markdownDeprecationMessage: ( localize(
-            12141,
+            12142,
             'Use {0} instead',
             `\`#${TerminalChatAgentToolsSettingId.AutoApprove}#\``
         ))

package/vscode/src/vs/workbench/contrib/terminalContrib/commandGuide/common/terminalCommandGuideConfiguration.js

@@ -10,7 +10,7 @@ const terminalCommandGuideConfiguration = {
     [TerminalCommandGuideSettingId.ShowCommandGuide]: {
         restricted: true,
         markdownDescription: ( localize(
-            12156,
+            12157,
             "Whether to show the command guide when hovering over a command in the terminal."
         )),
         type: 'boolean',

package/vscode/src/vs/workbench/contrib/terminalContrib/history/common/terminal.history.js

@@ -19,7 +19,7 @@ const terminalHistoryConfiguration = {
     [TerminalHistorySettingId.ShellIntegrationCommandHistory]: {
         restricted: true,
         markdownDescription: ( localize(
-            12188,
+            12189,
             "Controls the number of recently used commands to keep in the terminal command history. Set to 0 to disable terminal command history."
         )),
         type: 'number',

package/vscode/src/vs/workbench/contrib/terminalContrib/inlineHint/common/terminalInitialHintConfiguration.js

@@ -9,7 +9,7 @@ const terminalInitialHintConfiguration = {
     [TerminalInitialHintSettingId.Enabled]: {
         restricted: true,
         markdownDescription: ( localize(
-            12197,
+            12198,
             "Controls if the first terminal without input will show a hint about available actions when it is focused."
         )),
         type: 'boolean',

package/vscode/src/vs/workbench/contrib/terminalContrib/stickyScroll/common/terminalStickyScrollConfiguration.js

@@ -10,7 +10,7 @@ var TerminalStickyScrollSettingId;
 const terminalStickyScrollConfiguration = {
     [TerminalStickyScrollSettingId.Enabled]: {
         markdownDescription: ( localize(
-            12264,
+            12265,
             "Shows the current command at the top of the terminal. This feature requires [shell integration]({0}) to be activated. See {1}.",
             'https://code.visualstudio.com/docs/terminal/shell-integration',
             `\`#${TerminalSettingId.ShellIntegrationEnabled}#\``
@@ -20,7 +20,7 @@ const terminalStickyScrollConfiguration = {
     },
     [TerminalStickyScrollSettingId.MaxLineCount]: {
         markdownDescription: ( localize(
-            12265,
+            12266,
             "Defines the maximum number of sticky lines to show. Sticky scroll lines will never exceed 40% of the viewport regardless of this setting."
         )),
         type: 'number',

package/vscode/src/vs/workbench/contrib/terminalContrib/suggest/common/terminalSuggestConfiguration.js

@@ -47,7 +47,7 @@ const terminalSuggestConfiguration = {
     [TerminalSuggestSettingId.Enabled]: {
         restricted: true,
         markdownDescription: ( localize(
-            12346,
+            12347,
             "Enables terminal IntelliSense suggestions (also known as autocomplete) for supported shells ({0}). This requires {1} to be enabled and working or [manually installed](https://code.visualstudio.com/docs/terminal/shell-integration#_manual-installation-install).",
             'Windows PowerShell, PowerShell v7+, zsh, bash, fish',
             `\`#${TerminalSettingId.ShellIntegrationEnabled}#\``
@@ -58,7 +58,7 @@ const terminalSuggestConfiguration = {
     [TerminalSuggestSettingId.Providers]: {
         restricted: true,
         markdownDescription: ( localize(
-            12347,
+            12348,
             "Providers are enabled by default. Omit them by setting the id of the provider to `false`."
         )),
         type: 'object',
@@ -67,7 +67,7 @@ const terminalSuggestConfiguration = {
     [TerminalSuggestSettingId.QuickSuggestions]: {
         restricted: true,
         markdownDescription: ( localize(
-            12348,
+            12349,
             "Controls whether suggestions should automatically show up while typing. Also be aware of the {0}-setting which controls if suggestions are triggered by special characters.",
             `\`#${TerminalSuggestSettingId.SuggestOnTriggerCharacters}#\``
         )),
@@ -80,7 +80,7 @@ const terminalSuggestConfiguration = {
                 properties: {
                     commands: {
                         description: ( localize(
-                            12349,
+                            12350,
                             'Enable quick suggestions for commands, the first word in a command line input.'
                         )),
                         type: 'string',
@@ -88,7 +88,7 @@ const terminalSuggestConfiguration = {
                     },
                     arguments: {
                         description: ( localize(
-                            12350,
+                            12351,
                             'Enable quick suggestions for arguments, anything after the first word in a command line input.'
                         )),
                         type: 'string',
@@ -96,7 +96,7 @@ const terminalSuggestConfiguration = {
                     },
                     unknown: {
                         description: ( localize(
-                            12351,
+                            12352,
                             'Enable quick suggestions when it\'s unclear what the best suggestion is, if this is on files and folders will be suggested as a fallback.'
                         )),
                         type: 'string',
@@ -110,7 +110,7 @@ const terminalSuggestConfiguration = {
     [TerminalSuggestSettingId.SuggestOnTriggerCharacters]: {
         restricted: true,
         markdownDescription: ( localize(
-            12352,
+            12353,
             "Controls whether suggestions should automatically show up when typing trigger characters."
         )),
         type: 'boolean',
@@ -119,39 +119,39 @@ const terminalSuggestConfiguration = {
     [TerminalSuggestSettingId.RunOnEnter]: {
         restricted: true,
         markdownDescription: ( localize(
-            12353,
+            12354,
             "Controls whether suggestions should run immediately when `Enter` (not `Tab`) is used to accept the result."
         )),
         enum: ['never', 'exactMatch', 'exactMatchIgnoreExtension', 'always'],
         markdownEnumDescriptions: [
-            ( localize(12354, "Never run on `Enter`.")),
-            ( localize(12355, "Run on `Enter` when the suggestion is typed in its entirety.")),
+            ( localize(12355, "Never run on `Enter`.")),
+            ( localize(12356, "Run on `Enter` when the suggestion is typed in its entirety.")),
             ( localize(
-            12356,
+            12357,
             "Run on `Enter` when the suggestion is typed in its entirety or when a file is typed without its extension included."
         )),
-            ( localize(12357, "Always run on `Enter`."))
+            ( localize(12358, "Always run on `Enter`."))
         ],
         default: 'never',
     },
     [TerminalSuggestSettingId.SelectionMode]: {
         markdownDescription: ( localize(
-            12358,
+            12359,
             "Controls how suggestion selection works in the integrated terminal."
         )),
         type: 'string',
         enum: ['partial', 'always', 'never'],
         markdownEnumDescriptions: [
             ( localize(
-            12359,
+            12360,
             "Partially select a suggestion when automatically triggering IntelliSense. `Tab` can be used to accept the first suggestion, only after navigating the suggestions via `Down` will `Enter` also accept the active suggestion."
         )),
             ( localize(
-            12360,
+            12361,
             "Always select a suggestion when automatically triggering IntelliSense. `Enter` or `Tab` can be used to accept the first suggestion."
         )),
             ( localize(
-            12361,
+            12362,
             "Never select a suggestion when automatically triggering IntelliSense. The list must be navigated via `Down` before `Enter` or `Tab` can be used to accept the active suggestion."
         )),
         ],
@@ -160,7 +160,7 @@ const terminalSuggestConfiguration = {
     [TerminalSuggestSettingId.WindowsExecutableExtensions]: {
         restricted: true,
         markdownDescription: ( localize(
-            12362,
+            12363,
             "A set of windows command executable extensions that will be included as suggestions in the terminal.\n\nMany executables are included by default, listed below:\n\n{0}.\n\nTo exclude an extension, set it to `false`\n\n. To include one not in the list, add it and set it to `true`.",
             ( windowsDefaultExecutableExtensions.sort().map(extension => `- ${extension}`)).join('\n')
         )),
@@ -170,7 +170,7 @@ const terminalSuggestConfiguration = {
     [TerminalSuggestSettingId.ShowStatusBar]: {
         restricted: true,
         markdownDescription: ( localize(
-            12363,
+            12364,
             "Controls whether the terminal suggestions status bar should be shown."
         )),
         type: 'boolean',
@@ -179,16 +179,16 @@ const terminalSuggestConfiguration = {
     [TerminalSuggestSettingId.CdPath]: {
         restricted: true,
         markdownDescription: ( localize(
-            12364,
+            12365,
             "Controls whether to enable $CDPATH support which exposes children of the folders in the $CDPATH variable regardless of the current working directory. $CDPATH is expected to be semi colon-separated on Windows and colon-separated on other platforms."
         )),
         type: 'string',
         enum: ['off', 'relative', 'absolute'],
         markdownEnumDescriptions: [
-            ( localize(12365, "Disable the feature.")),
-            ( localize(12366, "Enable the feature and use relative paths.")),
+            ( localize(12366, "Disable the feature.")),
+            ( localize(12367, "Enable the feature and use relative paths.")),
             ( localize(
-            12367,
+            12368,
             "Enable the feature and use absolute paths. This is useful when the shell doesn't natively support `$CDPATH`."
         )),
         ],
@@ -197,25 +197,25 @@ const terminalSuggestConfiguration = {
     [TerminalSuggestSettingId.InlineSuggestion]: {
         restricted: true,
         markdownDescription: ( localize(
-            12368,
+            12369,
             "Controls whether the shell's inline suggestion should be detected and how it is scored."
         )),
         type: 'string',
         enum: ['off', 'alwaysOnTopExceptExactMatch', 'alwaysOnTop'],
         markdownEnumDescriptions: [
-            ( localize(12369, "Disable the feature.")),
+            ( localize(12370, "Disable the feature.")),
             ( localize(
-            12370,
+            12371,
             "Enable the feature and sort the inline suggestion without forcing it to be on top. This means that exact matches will be above the inline suggestion."
         )),
-            ( localize(12371, "Enable the feature and always put the inline suggestion on top.")),
+            ( localize(12372, "Enable the feature and always put the inline suggestion on top.")),
         ],
         default: 'alwaysOnTop',
     },
     [TerminalSuggestSettingId.UpArrowNavigatesHistory]: {
         restricted: true,
         markdownDescription: ( localize(
-            12372,
+            12373,
             "Determines whether the up arrow key navigates the command history when focus is on the first suggestion and navigation has not yet occurred. When set to false, the up arrow will move focus to the last suggestion instead."
         )),
         type: 'boolean',
@@ -224,7 +224,7 @@ const terminalSuggestConfiguration = {
     [TerminalSuggestSettingId.InsertTrailingSpace]: {
         restricted: true,
         markdownDescription: ( localize(
-            12373,
+            12374,
             "Controls whether a space is automatically inserted after accepting a suggestion and re-trigger suggestions. Folders and symbolic link folders will never have a trailing space added."
         )),
         type: 'boolean',
@@ -238,7 +238,7 @@ function registerTerminalSuggestProvidersConfiguration(providers) {
     if (!( providers.has('lsp'))) {
         providers.set('lsp', {
             id: 'lsp',
-            description: ( localize(12374, 'Show suggestions from language servers.'))
+            description: ( localize(12375, 'Show suggestions from language servers.'))
         });
     }
     const providersProperties = {};
@@ -247,7 +247,7 @@ function registerTerminalSuggestProvidersConfiguration(providers) {
             type: 'boolean',
             default: id === 'lsp' ? false : true,
             description: providers.get(id)?.description ??
-                ( localize(12375, "Show suggestions from {0}.", id))
+                ( localize(12376, "Show suggestions from {0}.", id))
         };
     }
     const defaultValue = {};
@@ -257,13 +257,13 @@ function registerTerminalSuggestProvidersConfiguration(providers) {
     terminalSuggestProvidersConfiguration = {
         id: 'terminalSuggestProviders',
         order: 100,
-        title: ( localize(12376, "Terminal Suggest Providers")),
+        title: ( localize(12377, "Terminal Suggest Providers")),
         type: 'object',
         properties: {
             [TerminalSuggestSettingId.Providers]: {
                 restricted: true,
                 markdownDescription: ( localize(
-                    12377,
+                    12378,
                     "Controls which suggestions automatically show up while typing. Suggestion providers are enabled by default."
                 )),
                 type: 'object',

package/vscode/src/vs/workbench/contrib/terminalContrib/typeAhead/common/terminalTypeAheadConfiguration.js

@@ -12,7 +12,7 @@ var TerminalTypeAheadSettingId;
 const terminalTypeAheadConfiguration = {
     [TerminalTypeAheadSettingId.LocalEchoLatencyThreshold]: {
         description: ( localize(
-            12378,
+            12379,
             "Length of network delay, in milliseconds, where local edits will be echoed on the terminal without waiting for server acknowledgement. If '0', local echo will always be on, and if '-1' it will be disabled."
         )),
         type: 'integer',
@@ -22,23 +22,23 @@ const terminalTypeAheadConfiguration = {
     },
     [TerminalTypeAheadSettingId.LocalEchoEnabled]: {
         markdownDescription: ( localize(
-            12379,
+            12380,
             "When local echo should be enabled. This will override {0}",
             '`#terminal.integrated.localEchoLatencyThreshold#`'
         )),
         type: 'string',
         enum: ['on', 'off', 'auto'],
         enumDescriptions: [
-            ( localize(12380, "Always enabled")),
-            ( localize(12381, "Always disabled")),
-            ( localize(12382, "Enabled only for remote workspaces"))
+            ( localize(12381, "Always enabled")),
+            ( localize(12382, "Always disabled")),
+            ( localize(12383, "Enabled only for remote workspaces"))
         ],
         default: 'off',
         tags: ['preview'],
     },
     [TerminalTypeAheadSettingId.LocalEchoExcludePrograms]: {
         description: ( localize(
-            12383,
+            12384,
             "Local echo will be disabled when any of these program names are found in the terminal title."
         )),
         type: 'array',
@@ -51,7 +51,7 @@ const terminalTypeAheadConfiguration = {
     },
     [TerminalTypeAheadSettingId.LocalEchoStyle]: {
         description: ( localize(
-            12384,
+            12385,
             "Terminal style of locally echoed text; either a font style or an RGB color."
         )),
         default: 'dim',

package/vscode/src/vs/workbench/contrib/terminalContrib/zoom/common/terminal.zoom.js

@@ -16,11 +16,11 @@ const terminalZoomConfiguration = {
     [TerminalZoomSettingId.MouseWheelZoom]: {
         markdownDescription: isMacintosh
             ? ( localize(
-            12399,
+            12400,
             "Zoom the font of the terminal when using mouse wheel and holding `Cmd`."
         ))
             : ( localize(
-            12400,
+            12401,
             "Zoom the font of the terminal when using mouse wheel and holding `Ctrl`."
         )),
         type: 'boolean',