overview of Vsccmdi

description::
× Mcsh-creation: {2026-04-12}
× Mcs-creation: {202-03-28}
" command ID is a unique internal identifier that VSCode uses to execute an action, distinct from its human-readable name in the Command Palette. You can find them using the following methods.
---
### 🎯 Method 1: The Keyboard Shortcuts Editor (Recommended)
This is the most straightforward method. It displays a searchable list of all commands, showing both their human-readable names and their command IDs.
1. Open the Command Palette with `Ctrl+Shift+P` (or `Cmd+Shift+P` on macOS).
2. Type **"Preferences: Open Keyboard Shortcuts"** and select it.
3. In the search bar, type the name of the action you're looking for.
4. Find the command in the list. Its ID is shown in the **"Command"** column .
---
### ⌨️ Method 2: The `keybindings.json` File
If you already know how to manually edit keybindings, this file is a direct way to see the structure.
1. Open the Command Palette (`Ctrl+Shift+P` / `Cmd+Shift+P`).
2. Type **"Preferences: Open Keyboard Shortcuts (JSON)"** and select it.
3. This opens a JSON file where each entry contains a `"command"` field. This field's value is the command ID .
---
### 💻 Method 3: Using the Developer Tools (For the Technically Inclined)
This method allows you to programmatically get a full list of all commands loaded by VS Code.
1. Open the built-in terminal in VS Code.
2. Start the VS Code command-line interface with the `--status` flag:
bash
code --status

3. In the output, look for a section labeled **"Extension Statistics"**. This section lists the commands that are currently registered.
### 🔎 Finding Your Example: "Debug: Start Debugging"
To find the command ID for "Debug: Start Debugging", you would follow **Method 1** :
1. Open the **Keyboard Shortcuts** editor.
2. Search for **`start debugging`**.
3. The command in the list will have the ID **`workbench.action.debug.start`**.
I hope this helps you find the specific command IDs you're looking for. If you're trying to find a particular command, feel free to ask."
[{2026-03-28 retrieved} https://chat.deepseek.com/a/chat/s/277c551d-1afc-4198-bdba-a4d64e405db8]

name::
* McsEngl.VSCode-command-ID!⇒Vsccmdi,
* McsEngl.Vsccmdi!=VSCode-command-ID,
* McsEngl.Vsccmdi!~McsTchInf000042,
* McsEngl.McsTchInf000042.last.html//dirTchInf//dirMcs!⇒Vsccmdi,
* McsEngl.dirTchInf/McsTchInf000042.last.html!⇒Vsccmdi,
* McsEngl.Vsccmnd'ID!⇒Vsccmdi,

info-resource of Vsccmdi

description::
*

name::
* McsEngl.Vsccmdi'InfRsc,

WHOLE-PART-TREE of Vsccmdi

whole-tree-of-Vsccmdi::
* Visual-Studio-Code,
* ... Sympan.
* McsEngl.Vsccmdi'whole-tree,

part-tree-of-Vsccmdi::
* ,
* McsEngl.Vsccmdi'part-tree,

GENERIC-SPECIFIC-TREE of Vsccmdi

generic-tree-of-Vsccmdi::
* ,
* ... entity.
* McsEngl.Vsccmdi'generic-tree,

specific-tree-of-Vsccmdi::
* ,
* McsEngl.Vsccmnd.specific-tree,
* McsEngl.Vsccmnd.specific,

Vsccmdi.runCommands::
· run other commands.
"command": "runCommands",
"args": {
"commands": [
"cursorUp",
"cursorLineEnd",
"editor.action.insertLineAfter",
{"command": "type", "args": {"text": "======"}},
"cursorLeft"
]
},

* McsEngl.Vsccmnd.runCommands,
* McsEngl.Vsccmnd.runCommands,

Vsccmdi.type::
· inserts text at cursor.
{
"command": "type",
"args": {"text": "======"}
},

* McsEngl.Vsccmnd.type,
* McsEngl.Vsccmnd.type,

Vsccmdi.@azure.askAgentAboutResource,
* McsEngl.Vsccmnd.@azure.askAgentAboutResource,

Vsccmdi.@azure.installAzureSkillsGlobally,
* McsEngl.Vsccmnd.@azure.installAzureSkillsGlobally,

Vsccmdi.@azure.installAzureSkillsLocally,
* McsEngl.Vsccmnd.@azure.installAzureSkillsLocally,

Vsccmdi.@azure.openBugReport,
* McsEngl.Vsccmnd.@azure.openBugReport,

Vsccmdi.@azure.openFeatureRequest,
* McsEngl.Vsccmnd.@azure.openFeatureRequest,

Vsccmdi.@azure.setGlobalStat,
* McsEngl.Vsccmnd.@azure.setGlobalState,

Vsccmdi.@azure.showOutputChannel,
* McsEngl.Vsccmnd.@azure.showOutputChannel,

Vsccmdi.@azure.uninstallAzureSkillsGlobally,
* McsEngl.Vsccmnd.@azure.uninstallAzureSkillsGlobally,

Vsccmdi.@azure.viewGlobalState,
* McsEngl.Vsccmnd.@azure.viewGlobalState,

Vsccmdi.acceptAlternativeSelectedSuggestion,
· key: shift+enter,
· when: suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus,
* McsEngl.Vsccmnd.acceptAlternativeSelectedSuggestion,

Vsccmdi.acceptAlternativeSelectedSuggestion,
· key: shift+tab,
· when: suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus,
* McsEngl.Vsccmnd.acceptAlternativeSelectedSuggestion,

Vsccmdi.acceptRenameInput,
· key: enter,
· when: editorFocus && renameInputVisible && !isComposing,
* McsEngl.Vsccmnd.acceptRenameInput,

Vsccmdi.acceptRenameInputWithPreview,
· key: ctrl+enter,
· when: config.editor.rename.enablePreview && editorFocus && renameInputVisible && !isComposing,
* McsEngl.Vsccmnd.acceptRenameInputWithPreview,

Vsccmdi.acceptSelectedCodeAction,
· key: ctrl+.,
· when: codeActionMenuVisible && kb-macro.active,
* McsEngl.Vsccmnd.acceptSelectedCodeAction,

Vsccmdi.acceptSelectedCodeAction,
· key: ctrl+.,
· when: codeActionMenuVisible,
* McsEngl.Vsccmnd.acceptSelectedCodeAction,

Vsccmdi.acceptSelectedCodeAction,
· key: enter,
· when: codeActionMenuVisible && kb-macro.active,
* McsEngl.Vsccmnd.acceptSelectedCodeAction,

Vsccmdi.acceptSelectedCodeAction,
· key: enter,
· when: codeActionMenuVisible,
* McsEngl.Vsccmnd.acceptSelectedCodeAction,

Vsccmdi.acceptSelectedSuggestion,
· key: enter,
· when: acceptSuggestionOnEnter && suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && suggestionMakesTextEdit && textInputFocus,
* McsEngl.Vsccmnd.acceptSelectedSuggestion,

Vsccmdi.acceptSelectedSuggestion,
· key: tab,
· when: suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus,
* McsEngl.Vsccmnd.acceptSelectedSuggestion,

Vsccmdi.acceptSelectedSuggestionOnEnter,
* McsEngl.Vsccmnd.acceptSelectedSuggestionOnEnter,

Vsccmdi.acceptSnippet,
* McsEngl.Vsccmnd.acceptSnippet,

Vsccmdi.accessibility.announcement.help,
* McsEngl.Vsccmnd.accessibility.announcement.help,

Vsccmdi.actions.find,
· key: ctrl+f,
· when: editorFocus || editorIsOpen,
* McsEngl.Vsccmnd.actions.find,

Vsccmdi.actions.findWithSelection,
* McsEngl.Vsccmnd.actions.findWithSelection,

Vsccmdi.addCursorsAtSearchResults,
· key: ctrl+shift+l,
· when: fileMatchOrMatchFocus && searchViewletVisible,
* McsEngl.Vsccmnd.addCursorsAtSearchResults,

Vsccmdi.addRootFolder,
* McsEngl.Vsccmnd.addRootFolder,

Vsccmdi.agentSession.archive,
· key: delete,
· when: agentSessionsViewerFocused && !agentSessionIsArchived,
* McsEngl.Vsccmnd.agentSession.archive,

Vsccmdi.agentSession.delete,
* McsEngl.Vsccmnd.agentSession.delete,

Vsccmdi.agentSession.enterAgentSessionProjection,
* McsEngl.Vsccmnd.agentSession.enterAgentSessionProjection,

Vsccmdi.agentSession.exitAgentSessionProjection,
· key: escape,
· when: chatInAgentSessionProjection && chatIsEnabled,
* McsEngl.Vsccmnd.agentSession.exitAgentSessionProjection,

Vsccmdi.agentSession.markRead,
* McsEngl.Vsccmnd.agentSession.markRead,

Vsccmdi.agentSession.markUnread,
* McsEngl.Vsccmnd.agentSession.markUnread,

Vsccmdi.agentSession.pin,
* McsEngl.Vsccmnd.agentSession.pin,

Vsccmdi.agentSession.rename,
· key: f2,
· when: agentSessionsViewerFocused && !agentSessionHasMultipleSelected && chatSessionType == 'local',
* McsEngl.Vsccmnd.agentSession.rename,

Vsccmdi.agentSession.unarchive,
· key: shift+delete,
· when: agentSessionIsArchived && agentSessionsViewerFocused,
* McsEngl.Vsccmnd.agentSession.unarchive,

Vsccmdi.agentSession.unpin,
* McsEngl.Vsccmnd.agentSession.unpin,

Vsccmdi.agentSessionSection.archive,
* McsEngl.Vsccmnd.agentSessionSection.archive,

Vsccmdi.agentSessionSection.collapseAll,
* McsEngl.Vsccmnd.agentSessionSection.collapseAll,

Vsccmdi.agentSessionSection.markRead,
* McsEngl.Vsccmnd.agentSessionSection.markRead,

Vsccmdi.agentSessionSection.unarchive,
* McsEngl.Vsccmnd.agentSessionSection.unarchive,

Vsccmdi.agentSessions.hideAgentSessionsSidebar,
* McsEngl.Vsccmnd.agentSessions.hideAgentSessionsSidebar,

Vsccmdi.agentSessions.showAgentSessionsSidebar,
* McsEngl.Vsccmnd.agentSessions.showAgentSessionsSidebar,

Vsccmdi.agentSessions.toggleAgentSessionsSidebar,
* McsEngl.Vsccmnd.agentSessions.toggleAgentSessionsSidebar,

Vsccmdi.agentSessionsViewer.find,
* McsEngl.Vsccmnd.agentSessionsViewer.find,

Vsccmdi.agentSessionsViewer.refresh,
* McsEngl.Vsccmnd.agentSessionsViewer.refresh,

Vsccmdi.ai-mlstudio.addRemoteInferenceEndpoint,
* McsEngl.Vsccmnd.ai-mlstudio.addRemoteInferenceEndpoint,

Vsccmdi.ai-mlstudio.agent-ghcp.add-eval,
* McsEngl.Vsccmnd.ai-mlstudio.agent-ghcp.add-eval,

Vsccmdi.ai-mlstudio.agent-ghcp.create-agent,
* McsEngl.Vsccmnd.ai-mlstudio.agent-ghcp.create-agent,

Vsccmdi.ai-mlstudio.agent-ghcp.enable-tracing,
* McsEngl.Vsccmnd.ai-mlstudio.agent-ghcp.enable-tracing,

Vsccmdi.ai-mlstudio.agent-ghcp.new-workflow,
* McsEngl.Vsccmnd.ai-mlstudio.agent-ghcp.new-workflow,

Vsccmdi.ai-mlstudio.agent-ghcp.orchestrate-foundry-agents,
* McsEngl.Vsccmnd.ai-mlstudio.agent-ghcp.orchestrate-foundry-agents,

Vsccmdi.ai-mlstudio.agentBuilder,
* McsEngl.Vsccmnd.ai-mlstudio.agentBuilder,

Vsccmdi.ai-mlstudio.command.submitEvaluation,
* McsEngl.Vsccmnd.ai-mlstudio.command.submitEvaluation,

Vsccmdi.ai-mlstudio.commandPalette.addRemoteInferenceEndpoint,
* McsEngl.Vsccmnd.ai-mlstudio.commandPalette.addRemoteInferenceEndpoint,

Vsccmdi.ai-mlstudio.copyGHAccessToken,
* McsEngl.Vsccmnd.ai-mlstudio.copyGHAccessToken,

Vsccmdi.ai-mlstudio.createMcpToolConnection,
* McsEngl.Vsccmnd.ai-mlstudio.createMcpToolConnection,

Vsccmdi.ai-mlstudio.createNewAgent,
* McsEngl.Vsccmnd.ai-mlstudio.createNewAgent,

Vsccmdi.ai-mlstudio.deleteInferenceModel,
* McsEngl.Vsccmnd.ai-mlstudio.deleteInferenceModel,

Vsccmdi.ai-mlstudio.deployHostedAgent,
* McsEngl.Vsccmnd.ai-mlstudio.deployHostedAgent,

Vsccmdi.ai-mlstudio.deployInference,
* McsEngl.Vsccmnd.ai-mlstudio.deployInference,

Vsccmdi.ai-mlstudio.documentation,
* McsEngl.Vsccmnd.ai-mlstudio.documentation,

Vsccmdi.ai-mlstudio.downloadInferenceModel,
* McsEngl.Vsccmnd.ai-mlstudio.downloadInferenceModel,

Vsccmdi.ai-mlstudio.editSecret,
* McsEngl.Vsccmnd.ai-mlstudio.editSecret,

Vsccmdi.ai-mlstudio.encryptCustomModelValue,
* McsEngl.Vsccmnd.ai-mlstudio.encryptCustomModelValue,

Vsccmdi.ai-mlstudio.evaluation.addCustomEvaluator,
* McsEngl.Vsccmnd.ai-mlstudio.evaluation.addCustomEvaluator,

Vsccmdi.ai-mlstudio.evaluation.analyzeResults,
* McsEngl.Vsccmnd.ai-mlstudio.evaluation.analyzeResults,

Vsccmdi.ai-mlstudio.evaluation.downloadRemoteResult,
* McsEngl.Vsccmnd.ai-mlstudio.evaluation.downloadRemoteResult,

Vsccmdi.ai-mlstudio.evaluation.generateTestCases,
* McsEngl.Vsccmnd.ai-mlstudio.evaluation.generateTestCases,

Vsccmdi.ai-mlstudio.evaluation.openDataset,
* McsEngl.Vsccmnd.ai-mlstudio.evaluation.openDataset,

Vsccmdi.ai-mlstudio.evaluation.refreshAgentEvals,
* McsEngl.Vsccmnd.ai-mlstudio.evaluation.refreshAgentEvals,

Vsccmdi.ai-mlstudio.evaluation.refreshRemoteResults,
* McsEngl.Vsccmnd.ai-mlstudio.evaluation.refreshRemoteResults,

Vsccmdi.ai-mlstudio.evaluation.updateCustomEvaluator,
* McsEngl.Vsccmnd.ai-mlstudio.evaluation.updateCustomEvaluator,

Vsccmdi.ai-mlstudio.generateProject,
* McsEngl.Vsccmnd.ai-mlstudio.generateProject,

Vsccmdi.ai-mlstudio.generateProjectAndRefreshVSCodeWindow,
* McsEngl.Vsccmnd.ai-mlstudio.generateProjectAndRefreshVSCodeWindow,

Vsccmdi.ai-mlstudio.getProjectSettings,
* McsEngl.Vsccmnd.ai-mlstudio.getProjectSettings,

Vsccmdi.ai-mlstudio.installCondaWslLinux,
* McsEngl.Vsccmnd.ai-mlstudio.installCondaWslLinux,

Vsccmdi.ai-mlstudio.installCudaWslLinux,
* McsEngl.Vsccmnd.ai-mlstudio.installCudaWslLinux,

Vsccmdi.ai-mlstudio.installFoundrySkill,
* McsEngl.Vsccmnd.ai-mlstudio.installFoundrySkill,

Vsccmdi.ai-mlstudio.internal.GHModelsDoc,
* McsEngl.Vsccmnd.ai-mlstudio.internal.GHModelsDoc,

Vsccmdi.ai-mlstudio.joinCommunity,
* McsEngl.Vsccmnd.ai-mlstudio.joinCommunity,

Vsccmdi.ai-mlstudio.mcp.addHttpServer,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.addHttpServer,

Vsccmdi.ai-mlstudio.mcp.addServer,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.addServer,

Vsccmdi.ai-mlstudio.mcp.addStdioServer,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.addStdioServer,

Vsccmdi.ai-mlstudio.mcp.cancelServer,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.cancelServer,

Vsccmdi.ai-mlstudio.mcp.configureFoundryServer,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.configureFoundryServer,

Vsccmdi.ai-mlstudio.mcp.connectToAgent,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.connectToAgent,

Vsccmdi.ai-mlstudio.mcp.createNewServer,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.createNewServer,

Vsccmdi.ai-mlstudio.mcp.editConfiguration,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.editConfiguration,

Vsccmdi.ai-mlstudio.mcp.editFoundryServer,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.editFoundryServer,

Vsccmdi.ai-mlstudio.mcp.openDocumentation,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.openDocumentation,

Vsccmdi.ai-mlstudio.mcp.refreshServer,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.refreshServer,

Vsccmdi.ai-mlstudio.mcp.removeAzureAISearchConnection,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.removeAzureAISearchConnection,

Vsccmdi.ai-mlstudio.mcp.removeBingConnection,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.removeBingConnection,

Vsccmdi.ai-mlstudio.mcp.removeFoundryServer,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.removeFoundryServer,

Vsccmdi.ai-mlstudio.mcp.removeServer,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.removeServer,

Vsccmdi.ai-mlstudio.mcp.startServer,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.startServer,

Vsccmdi.ai-mlstudio.mcp.stopServer,
* McsEngl.Vsccmnd.ai-mlstudio.mcp.stopServer,

Vsccmdi.ai-mlstudio.modelComparison,
* McsEngl.Vsccmnd.ai-mlstudio.modelComparison,

Vsccmdi.ai-mlstudio.modelLab.createFinetuningWorkspace,
* McsEngl.Vsccmnd.ai-mlstudio.modelLab.createFinetuningWorkspace,

Vsccmdi.ai-mlstudio.modelLab.createWorkspace,
* McsEngl.Vsccmnd.ai-mlstudio.modelLab.createWorkspace,

Vsccmdi.ai-mlstudio.modelLab.finetuningFirstEnterNewProj,
* McsEngl.Vsccmnd.ai-mlstudio.modelLab.finetuningFirstEnterNewProj,

Vsccmdi.ai-mlstudio.modelLab.firstEnterNewProj,
* McsEngl.Vsccmnd.ai-mlstudio.modelLab.firstEnterNewProj,

Vsccmdi.ai-mlstudio.modelLab.generationCompleted,
* McsEngl.Vsccmnd.ai-mlstudio.modelLab.generationCompleted,

Vsccmdi.ai-mlstudio.modelLab.openFinetuningMetricsPage,
* McsEngl.Vsccmnd.ai-mlstudio.modelLab.openFinetuningMetricsPage,

Vsccmdi.ai-mlstudio.modelLab.openFinetuningOverview,
* McsEngl.Vsccmnd.ai-mlstudio.modelLab.openFinetuningOverview,

Vsccmdi.ai-mlstudio.modelLab.openProfiling,
* McsEngl.Vsccmnd.ai-mlstudio.modelLab.openProfiling,

Vsccmdi.ai-mlstudio.modelLab.openWorkflow,
* McsEngl.Vsccmnd.ai-mlstudio.modelLab.openWorkflow,

Vsccmdi.ai-mlstudio.modelPlayground,
* McsEngl.Vsccmnd.ai-mlstudio.modelPlayground,

Vsccmdi.ai-mlstudio.models,
* McsEngl.Vsccmnd.ai-mlstudio.models,

Vsccmdi.ai-mlstudio.openConversationHistory,
* McsEngl.Vsccmnd.ai-mlstudio.openConversationHistory,

Vsccmdi.ai-mlstudio.openDataViewer,
* McsEngl.Vsccmnd.ai-mlstudio.openDataViewer,

Vsccmdi.ai-mlstudio.openDataset,
* McsEngl.Vsccmnd.ai-mlstudio.openDataset,

Vsccmdi.ai-mlstudio.openEvaluationOverview,
* McsEngl.Vsccmnd.ai-mlstudio.openEvaluationOverview,

Vsccmdi.ai-mlstudio.openFinetuningOverview,
* McsEngl.Vsccmnd.ai-mlstudio.openFinetuningOverview,

Vsccmdi.ai-mlstudio.openHostedAgentPlayground,
* McsEngl.Vsccmnd.ai-mlstudio.openHostedAgentPlayground,

Vsccmdi.ai-mlstudio.openModelCardMarkdown,
* McsEngl.Vsccmnd.ai-mlstudio.openModelCardMarkdown,

Vsccmdi.ai-mlstudio.openModelLicense,
* McsEngl.Vsccmnd.ai-mlstudio.openModelLicense,

Vsccmdi.ai-mlstudio.openTestTool,
* McsEngl.Vsccmnd.ai-mlstudio.openTestTool,

Vsccmdi.ai-mlstudio.openTutorial,
* McsEngl.Vsccmnd.ai-mlstudio.openTutorial,

Vsccmdi.ai-mlstudio.prepareEnvironment,
* McsEngl.Vsccmnd.ai-mlstudio.prepareEnvironment,

Vsccmdi.ai-mlstudio.promptBuilder,
* McsEngl.Vsccmnd.ai-mlstudio.promptBuilder,

Vsccmdi.ai-mlstudio.promptConsole,
* McsEngl.Vsccmnd.ai-mlstudio.promptConsole,

Vsccmdi.ai-mlstudio.provision,
* McsEngl.Vsccmnd.ai-mlstudio.provision,

Vsccmdi.ai-mlstudio.provisionInference,
* McsEngl.Vsccmnd.ai-mlstudio.provisionInference,

Vsccmdi.ai-mlstudio.recentAgents.createInCode,
* McsEngl.Vsccmnd.ai-mlstudio.recentAgents.createInCode,

Vsccmdi.ai-mlstudio.recentAgents.designWithBuilder,
* McsEngl.Vsccmnd.ai-mlstudio.recentAgents.designWithBuilder,

Vsccmdi.ai-mlstudio.refreshVSCodeWindow,
* McsEngl.Vsccmnd.ai-mlstudio.refreshVSCodeWindow,

Vsccmdi.ai-mlstudio.reportIssue,
* McsEngl.Vsccmnd.ai-mlstudio.reportIssue,

Vsccmdi.ai-mlstudio.resetAllTokens,
* McsEngl.Vsccmnd.ai-mlstudio.resetAllTokens,

Vsccmdi.ai-mlstudio.run,
* McsEngl.Vsccmnd.ai-mlstudio.run,

Vsccmdi.ai-mlstudio.setGHAccessToken,
* McsEngl.Vsccmnd.ai-mlstudio.setGHAccessToken,

Vsccmdi.ai-mlstudio.setHFAccessToken,
* McsEngl.Vsccmnd.ai-mlstudio.setHFAccessToken,

Vsccmdi.ai-mlstudio.setTreeViewMode,
* McsEngl.Vsccmnd.ai-mlstudio.setTreeViewMode,

Vsccmdi.ai-mlstudio.setupAIModel,
* McsEngl.Vsccmnd.ai-mlstudio.setupAIModel,

Vsccmdi.ai-mlstudio.setupDatasetFlow,
* McsEngl.Vsccmnd.ai-mlstudio.setupDatasetFlow,

Vsccmdi.ai-mlstudio.showJobOutputChannel,
* McsEngl.Vsccmnd.ai-mlstudio.showJobOutputChannel,

Vsccmdi.ai-mlstudio.showOutputChannel,
* McsEngl.Vsccmnd.ai-mlstudio.showOutputChannel,

Vsccmdi.ai-mlstudio.showWhatsNew,
* McsEngl.Vsccmnd.ai-mlstudio.showWhatsNew,

Vsccmdi.ai-mlstudio.shutdownInferenceAgent,
* McsEngl.Vsccmnd.ai-mlstudio.shutdownInferenceAgent,

Vsccmdi.ai-mlstudio.streamingLog,
* McsEngl.Vsccmnd.ai-mlstudio.streamingLog,

Vsccmdi.ai-mlstudio.switchToFunctionalMode,
* McsEngl.Vsccmnd.ai-mlstudio.switchToFunctionalMode,

Vsccmdi.ai-mlstudio.switchToFunctionalMode.active,
* McsEngl.Vsccmnd.ai-mlstudio.switchToFunctionalMode.active,

Vsccmdi.ai-mlstudio.switchToLifecycleMode,
* McsEngl.Vsccmnd.ai-mlstudio.switchToLifecycleMode,

Vsccmdi.ai-mlstudio.switchToLifecycleMode.active,
* McsEngl.Vsccmnd.ai-mlstudio.switchToLifecycleMode.active,

Vsccmdi.ai-mlstudio.switchTreeViewMode,
* McsEngl.Vsccmnd.ai-mlstudio.switchTreeViewMode,

Vsccmdi.ai-mlstudio.test.happyPath,
* McsEngl.Vsccmnd.ai-mlstudio.test.happyPath,

Vsccmdi.ai-mlstudio.toolCatalog,
* McsEngl.Vsccmnd.ai-mlstudio.toolCatalog,

Vsccmdi.ai-mlstudio.tracing.open,
* McsEngl.Vsccmnd.ai-mlstudio.tracing.open,

Vsccmdi.ai-mlstudio.tracing.openFoundryTrace,
* McsEngl.Vsccmnd.ai-mlstudio.tracing.openFoundryTrace,

Vsccmdi.ai-mlstudio.tracing.showStatus,
* McsEngl.Vsccmnd.ai-mlstudio.tracing.showStatus,

Vsccmdi.ai-mlstudio.tracing.startCollector,
* McsEngl.Vsccmnd.ai-mlstudio.tracing.startCollector,

Vsccmdi.ai-mlstudio.tracing.stopCollector,
* McsEngl.Vsccmnd.ai-mlstudio.tracing.stopCollector,

Vsccmdi.ai-mlstudio.tracingViewer,
* McsEngl.Vsccmnd.ai-mlstudio.tracingViewer,

Vsccmdi.ai-mlstudio.treeView.agents.deleteAgent,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.agents.deleteAgent,

Vsccmdi.ai-mlstudio.treeView.agents.deleteAgentVersion,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.agents.deleteAgentVersion,

Vsccmdi.ai-mlstudio.treeView.agents.designWithBuilder,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.agents.designWithBuilder,

Vsccmdi.ai-mlstudio.treeView.agents.refreshFoundryAgents,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.agents.refreshFoundryAgents,

Vsccmdi.ai-mlstudio.treeView.agents.refreshLocalAgents,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.agents.refreshLocalAgents,

Vsccmdi.ai-mlstudio.treeView.agents.renameAgent,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.agents.renameAgent,

Vsccmdi.ai-mlstudio.treeView.agents.renameAgentVersion,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.agents.renameAgentVersion,

Vsccmdi.ai-mlstudio.treeView.evaluation.openInDataViewer,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.evaluation.openInDataViewer,

Vsccmdi.ai-mlstudio.treeView.models.about,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.about,

Vsccmdi.ai-mlstudio.treeView.models.addRemoteInferenceEndpoint,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.addRemoteInferenceEndpoint,

Vsccmdi.ai-mlstudio.treeView.models.cancelDownloading,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.cancelDownloading,

Vsccmdi.ai-mlstudio.treeView.models.click,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.click,

Vsccmdi.ai-mlstudio.treeView.models.copyEndpoint,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.copyEndpoint,

Vsccmdi.ai-mlstudio.treeView.models.copyModelName,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.copyModelName,

Vsccmdi.ai-mlstudio.treeView.models.createFineTuneProject,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.createFineTuneProject,

Vsccmdi.ai-mlstudio.treeView.models.delete,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.delete,

Vsccmdi.ai-mlstudio.treeView.models.edit,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.edit,

Vsccmdi.ai-mlstudio.treeView.models.foundry.selectProject,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.foundry.selectProject,

Vsccmdi.ai-mlstudio.treeView.models.loadInAgentBuilder,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.loadInAgentBuilder,

Vsccmdi.ai-mlstudio.treeView.models.loadInPlayground,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.loadInPlayground,

Vsccmdi.ai-mlstudio.treeView.models.refresh,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.refresh,

Vsccmdi.ai-mlstudio.treeView.models.remoteInferenceInPlaygroundDocs,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.remoteInferenceInPlaygroundDocs,

Vsccmdi.ai-mlstudio.treeView.models.startServer,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.startServer,

Vsccmdi.ai-mlstudio.treeView.models.stopServer,
* McsEngl.Vsccmnd.ai-mlstudio.treeView.models.stopServer,

Vsccmdi.ai-mlstudio.triggerFoundryModelDeployment,
* McsEngl.Vsccmnd.ai-mlstudio.triggerFoundryModelDeployment,

Vsccmdi.ai-mlstudio.tutorials,
* McsEngl.Vsccmnd.ai-mlstudio.tutorials,

Vsccmdi.ai-mlstudio.unloadInferenceModel,
* McsEngl.Vsccmnd.ai-mlstudio.unloadInferenceModel,

Vsccmdi.ai-mlstudio.view.evaluation.focus,
* McsEngl.Vsccmnd.ai-mlstudio.view.evaluation.focus,

Vsccmdi.ai-mlstudio.view.evaluation.removeView,
* McsEngl.Vsccmnd.ai-mlstudio.view.evaluation.removeView,

Vsccmdi.ai-mlstudio.view.evaluation.resetViewLocation,
* McsEngl.Vsccmnd.ai-mlstudio.view.evaluation.resetViewLocation,

Vsccmdi.ai-mlstudio.view.evaluation.toggleVisibility,
* McsEngl.Vsccmnd.ai-mlstudio.view.evaluation.toggleVisibility,

Vsccmdi.ai-mlstudio.viewPrompts,
* McsEngl.Vsccmnd.ai-mlstudio.viewPrompts,

Vsccmdi.ai-mlstudio.walkthrough.installCopilotChat,
* McsEngl.Vsccmnd.ai-mlstudio.walkthrough.installCopilotChat,

Vsccmdi.ai-mlstudio.walkthrough.openGetStartedPage,
* McsEngl.Vsccmnd.ai-mlstudio.walkthrough.openGetStartedPage,

Vsccmdi.ai-mlstudio.walkthrough.showAllCommands,
* McsEngl.Vsccmnd.ai-mlstudio.walkthrough.showAllCommands,

Vsccmdi.ai-mlstudio.walkthrough.signInFoundry,
* McsEngl.Vsccmnd.ai-mlstudio.walkthrough.signInFoundry,

Vsccmdi.ai-mlstudio.walkthrough.tryRemoteModel,
* McsEngl.Vsccmnd.ai-mlstudio.walkthrough.tryRemoteModel,

Vsccmdi.aiCustomization.openManagementEditor,
* McsEngl.Vsccmnd.aiCustomization.openManagementEditor,

Vsccmdi.aiCustomizationManagement.copyPath,
* McsEngl.Vsccmnd.aiCustomizationManagement.copyPath,

Vsccmdi.aiCustomizationManagement.delete,
* McsEngl.Vsccmnd.aiCustomizationManagement.delete,

Vsccmdi.aiCustomizationManagement.disableItem,
* McsEngl.Vsccmnd.aiCustomizationManagement.disableItem,

Vsccmdi.aiCustomizationManagement.enableItem,
* McsEngl.Vsccmnd.aiCustomizationManagement.enableItem,

Vsccmdi.aiCustomizationManagement.openFile,
* McsEngl.Vsccmnd.aiCustomizationManagement.openFile,

Vsccmdi.aiCustomizationManagement.revealInOS,
* McsEngl.Vsccmnd.aiCustomizationManagement.revealInOS,

Vsccmdi.aiCustomizationManagement.runPrompt,
* McsEngl.Vsccmnd.aiCustomizationManagement.runPrompt,

Vsccmdi.aiCustomizationManagement.showPlugin,
* McsEngl.Vsccmnd.aiCustomizationManagement.showPlugin,

Vsccmdi.aiCustomizationManagement.uninstallPlugin,
* McsEngl.Vsccmnd.aiCustomizationManagement.uninstallPlugin,

Vsccmdi.aiToolkitHelpAndFeedback.focus,
* McsEngl.Vsccmnd.aiToolkitHelpAndFeedback.focus,

Vsccmdi.aiToolkitHelpAndFeedback.removeView,
* McsEngl.Vsccmnd.aiToolkitHelpAndFeedback.removeView,

Vsccmdi.aiToolkitHelpAndFeedback.resetViewLocation,
* McsEngl.Vsccmnd.aiToolkitHelpAndFeedback.resetViewLocation,

Vsccmdi.aiToolkitHelpAndFeedback.toggleVisibility,
* McsEngl.Vsccmnd.aiToolkitHelpAndFeedback.toggleVisibility,

Vsccmdi.aiToolkitRemoteResources.focus,
* McsEngl.Vsccmnd.aiToolkitRemoteResources.focus,

Vsccmdi.aiToolkitRemoteResources.removeView,
* McsEngl.Vsccmnd.aiToolkitRemoteResources.removeView,

Vsccmdi.aiToolkitRemoteResources.resetViewLocation,
* McsEngl.Vsccmnd.aiToolkitRemoteResources.resetViewLocation,

Vsccmdi.aiToolkitRemoteResources.toggleVisibility,
* McsEngl.Vsccmnd.aiToolkitRemoteResources.toggleVisibility,

Vsccmdi.aiToolkitUserTools.focus,
* McsEngl.Vsccmnd.aiToolkitUserTools.focus,

Vsccmdi.aiToolkitUserTools.removeView,
* McsEngl.Vsccmnd.aiToolkitUserTools.removeView,

Vsccmdi.aiToolkitUserTools.resetViewLocation,
* McsEngl.Vsccmnd.aiToolkitUserTools.resetViewLocation,

Vsccmdi.aiToolkitUserTools.toggleVisibility,
* McsEngl.Vsccmnd.aiToolkitUserTools.toggleVisibility,

Vsccmdi.azure-ai-foundry.commandPalette.clearDefault,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.clearDefault,

Vsccmdi.azure-ai-foundry.commandPalette.createMultiAgentWorkflow,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.createMultiAgentWorkflow,

Vsccmdi.azure-ai-foundry.commandPalette.createProject,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.createProject,

Vsccmdi.azure-ai-foundry.commandPalette.deleteThread,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.deleteThread,

Vsccmdi.azure-ai-foundry.commandPalette.deployWorkflow,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.deployWorkflow,

Vsccmdi.azure-ai-foundry.commandPalette.llmDeploy,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.llmDeploy,

Vsccmdi.azure-ai-foundry.commandPalette.model.copyApiKey,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.model.copyApiKey,

Vsccmdi.azure-ai-foundry.commandPalette.model.copyEndpoint,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.model.copyEndpoint,

Vsccmdi.azure-ai-foundry.commandPalette.model.delete,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.model.delete,

Vsccmdi.azure-ai-foundry.commandPalette.model.edit,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.model.edit,

Vsccmdi.azure-ai-foundry.commandPalette.openAgentCodeFile,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.openAgentCodeFile,

Vsccmdi.azure-ai-foundry.commandPalette.openCatalog,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.openCatalog,

Vsccmdi.azure-ai-foundry.commandPalette.openConversationHistory,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.openConversationHistory,

Vsccmdi.azure-ai-foundry.commandPalette.openModelCodeFile,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.openModelCodeFile,

Vsccmdi.azure-ai-foundry.commandPalette.project.copyApiKey,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.project.copyApiKey,

Vsccmdi.azure-ai-foundry.commandPalette.project.copyEndpoint,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.project.copyEndpoint,

Vsccmdi.azure-ai-foundry.commandPalette.runAgent,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.runAgent,

Vsccmdi.azure-ai-foundry.commandPalette.runInContainerAgentPlayground,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.runInContainerAgentPlayground,

Vsccmdi.azure-ai-foundry.commandPalette.setDefault,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.setDefault,

Vsccmdi.azure-ai-foundry.commandPalette.stopMultiAgentVisualizer,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.stopMultiAgentVisualizer,

Vsccmdi.azure-ai-foundry.commandPalette.visualizeWorkflow,
* McsEngl.Vsccmnd.azure-ai-foundry.commandPalette.visualizeWorkflow,

Vsccmdi.azure-ai-foundry.editorTitle.deployPromptAgent,
* McsEngl.Vsccmnd.azure-ai-foundry.editorTitle.deployPromptAgent,

Vsccmdi.azure-ai-foundry.editorTitle.deployYamlWorkflow,
* McsEngl.Vsccmnd.azure-ai-foundry.editorTitle.deployYamlWorkflow,

Vsccmdi.azure-ai-foundry.editorTitle.openAgentDesigner,
* McsEngl.Vsccmnd.azure-ai-foundry.editorTitle.openAgentDesigner,

Vsccmdi.azure-ai-foundry.explorerContext.openAgentDesigner,
* McsEngl.Vsccmnd.azure-ai-foundry.explorerContext.openAgentDesigner,

Vsccmdi.azure-ai-foundry.listModels,
* McsEngl.Vsccmnd.azure-ai-foundry.listModels,

Vsccmdi.azure-ai-foundry.openAIFoundry,
* McsEngl.Vsccmnd.azure-ai-foundry.openAIFoundry,

Vsccmdi.azure-ai-foundry.openBingConnectionDetails,
* McsEngl.Vsccmnd.azure-ai-foundry.openBingConnectionDetails,

Vsccmdi.azure-ai-foundry.openExternalLink,
* McsEngl.Vsccmnd.azure-ai-foundry.openExternalLink,

Vsccmdi.azure-ai-foundry.openFoundryProject,
* McsEngl.Vsccmnd.azure-ai-foundry.openFoundryProject,

Vsccmdi.azure-ai-foundry.openInVSCodeAzure,
* McsEngl.Vsccmnd.azure-ai-foundry.openInVSCodeAzure,

Vsccmdi.azure-ai-foundry.openVectorStoreDetails,
* McsEngl.Vsccmnd.azure-ai-foundry.openVectorStoreDetails,

Vsccmdi.azure-ai-foundry.reportIssue,
* McsEngl.Vsccmnd.azure-ai-foundry.reportIssue,

Vsccmdi.azure-ai-foundry.viewContext.agent.copyConnectionString,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.agent.copyConnectionString,

Vsccmdi.azure-ai-foundry.viewContext.agent.copyEndpoint,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.agent.copyEndpoint,

Vsccmdi.azure-ai-foundry.viewContext.agent.copyId,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.agent.copyId,

Vsccmdi.azure-ai-foundry.viewContext.agent.delete,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.agent.delete,

Vsccmdi.azure-ai-foundry.viewContext.createAgent,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.createAgent,

Vsccmdi.azure-ai-foundry.viewContext.createBingConnection,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.createBingConnection,

Vsccmdi.azure-ai-foundry.viewContext.createMultiAgentWorkflow,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.createMultiAgentWorkflow,

Vsccmdi.azure-ai-foundry.viewContext.createPromptAgent,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.createPromptAgent,

Vsccmdi.azure-ai-foundry.viewContext.createVectorStore,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.createVectorStore,

Vsccmdi.azure-ai-foundry.viewContext.deleteProject,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.deleteProject,

Vsccmdi.azure-ai-foundry.viewContext.deletePromptAgent,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.deletePromptAgent,

Vsccmdi.azure-ai-foundry.viewContext.deletePromptAgentVersion,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.deletePromptAgentVersion,

Vsccmdi.azure-ai-foundry.viewContext.deleteTool,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.deleteTool,

Vsccmdi.azure-ai-foundry.viewContext.deleteYamlWorkflow,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.deleteYamlWorkflow,

Vsccmdi.azure-ai-foundry.viewContext.deleteYamlWorkflowVersion,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.deleteYamlWorkflowVersion,

Vsccmdi.azure-ai-foundry.viewContext.llmDeploy,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.llmDeploy,

Vsccmdi.azure-ai-foundry.viewContext.loadMoreThreads,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.loadMoreThreads,

Vsccmdi.azure-ai-foundry.viewContext.model.copyApiKey,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.model.copyApiKey,

Vsccmdi.azure-ai-foundry.viewContext.model.copyEndpoint,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.model.copyEndpoint,

Vsccmdi.azure-ai-foundry.viewContext.model.delete,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.model.delete,

Vsccmdi.azure-ai-foundry.viewContext.model.openInPlayground,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.model.openInPlayground,

Vsccmdi.azure-ai-foundry.viewContext.openAgentCodeFile,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.openAgentCodeFile,

Vsccmdi.azure-ai-foundry.viewContext.openAgentDesigner,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.openAgentDesigner,

Vsccmdi.azure-ai-foundry.viewContext.openContainerPlayground,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.openContainerPlayground,

Vsccmdi.azure-ai-foundry.viewContext.openHostedAgentCodeFile,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.openHostedAgentCodeFile,

Vsccmdi.azure-ai-foundry.viewContext.openInFoundryView,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.openInFoundryView,

Vsccmdi.azure-ai-foundry.viewContext.openMCPServerToolCatalog,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.openMCPServerToolCatalog,

Vsccmdi.azure-ai-foundry.viewContext.openModelCodeFile,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.openModelCodeFile,

Vsccmdi.azure-ai-foundry.viewContext.openPromptAgentCodeFile,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.openPromptAgentCodeFile,

Vsccmdi.azure-ai-foundry.viewContext.openPromptAgentPlayground,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.openPromptAgentPlayground,

Vsccmdi.azure-ai-foundry.viewContext.openYamlBasedWorkflowCodeFile,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.openYamlBasedWorkflowCodeFile,

Vsccmdi.azure-ai-foundry.viewContext.openYamlWorkflowPlayground,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.openYamlWorkflowPlayground,

Vsccmdi.azure-ai-foundry.viewContext.project.copyApiKey,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.project.copyApiKey,

Vsccmdi.azure-ai-foundry.viewContext.refreshNode,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.refreshNode,

Vsccmdi.azure-ai-foundry.viewContext.refreshResources,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.refreshResources,

Vsccmdi.azure-ai-foundry.viewContext.runRemotePlayground,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.runRemotePlayground,

Vsccmdi.azure-ai-foundry.viewContext.searchProjectResources.aiToolkitView,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.searchProjectResources.aiToolkitView,

Vsccmdi.azure-ai-foundry.viewContext.searchProjectResources.explorerView,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.searchProjectResources.explorerView,

Vsccmdi.azure-ai-foundry.viewContext.searchProjectResources.resourcesView,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.searchProjectResources.resourcesView,

Vsccmdi.azure-ai-foundry.viewContext.switchDefaultProject,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.switchDefaultProject,

Vsccmdi.azure-ai-foundry.viewContext.viewModel,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.viewModel,

Vsccmdi.azure-ai-foundry.viewContext.viewThreadDetails,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.viewThreadDetails,

Vsccmdi.azure-ai-foundry.viewContext.viewWorkflowContainer,
* McsEngl.Vsccmnd.azure-ai-foundry.viewContext.viewWorkflowContainer,

Vsccmdi.azureActivityLog.focus,
* McsEngl.Vsccmnd.azureActivityLog.focus,

Vsccmdi.azureActivityLog.removeView,
* McsEngl.Vsccmnd.azureActivityLog.removeView,

Vsccmdi.azureActivityLog.resetViewLocation,
* McsEngl.Vsccmnd.azureActivityLog.resetViewLocation,

Vsccmdi.azureActivityLog.toggleVisibility,
* McsEngl.Vsccmnd.azureActivityLog.toggleVisibility,

Vsccmdi.azureActivityLogView.refresh,
* McsEngl.Vsccmnd.azureActivityLogView.refresh,

Vsccmdi.azureFocusView.focus,
* McsEngl.Vsccmnd.azureFocusView.focus,

Vsccmdi.azureFocusView.refresh,
* McsEngl.Vsccmnd.azureFocusView.refresh,

Vsccmdi.azureFocusView.refreshTree,
* McsEngl.Vsccmnd.azureFocusView.refreshTree,

Vsccmdi.azureFocusView.resetViewLocation,
* McsEngl.Vsccmnd.azureFocusView.resetViewLocation,

Vsccmdi.azureResourceGroups.askAgentAboutActivityLog,
* McsEngl.Vsccmnd.azureResourceGroups.askAgentAboutActivityLog,

Vsccmdi.azureResourceGroups.askAgentAboutActivityLogItem,
* McsEngl.Vsccmnd.azureResourceGroups.askAgentAboutActivityLogItem,

Vsccmdi.azureResourceGroups.askAgentAboutResource,
* McsEngl.Vsccmnd.azureResourceGroups.askAgentAboutResource,

Vsccmdi.azureResourceGroups.askAzure,
* McsEngl.Vsccmnd.azureResourceGroups.askAzure,

Vsccmdi.azureResourceGroups.clearActivities,
* McsEngl.Vsccmnd.azureResourceGroups.clearActivities,

Vsccmdi.azureResourceGroups.createResource,
* McsEngl.Vsccmnd.azureResourceGroups.createResource,

Vsccmdi.azureResourceGroups.createResourceGroup,
* McsEngl.Vsccmnd.azureResourceGroups.createResourceGroup,

Vsccmdi.azureResourceGroups.deleteResourceGroupV2,
* McsEngl.Vsccmnd.azureResourceGroups.deleteResourceGroupV2,

Vsccmdi.azureResourceGroups.editTags,
* McsEngl.Vsccmnd.azureResourceGroups.editTags,

Vsccmdi.azureResourceGroups.focus,
* McsEngl.Vsccmnd.azureResourceGroups.focus,

Vsccmdi.azureResourceGroups.focusGroup,
* McsEngl.Vsccmnd.azureResourceGroups.focusGroup,

Vsccmdi.azureResourceGroups.groupBy.armTag,
* McsEngl.Vsccmnd.azureResourceGroups.groupBy.armTag,

Vsccmdi.azureResourceGroups.groupBy.location,
* McsEngl.Vsccmnd.azureResourceGroups.groupBy.location,

Vsccmdi.azureResourceGroups.groupBy.resourceGroup,
* McsEngl.Vsccmnd.azureResourceGroups.groupBy.resourceGroup,

Vsccmdi.azureResourceGroups.groupBy.resourceType,
* McsEngl.Vsccmnd.azureResourceGroups.groupBy.resourceType,

Vsccmdi.azureResourceGroups.installExtension,
* McsEngl.Vsccmnd.azureResourceGroups.installExtension,

Vsccmdi.azureResourceGroups.loadAllSubscriptionRoleAssignments,
* McsEngl.Vsccmnd.azureResourceGroups.loadAllSubscriptionRoleAssignments,

Vsccmdi.azureResourceGroups.loadMore,
* McsEngl.Vsccmnd.azureResourceGroups.loadMore,

Vsccmdi.azureResourceGroups.logIn,
* McsEngl.Vsccmnd.azureResourceGroups.logIn,

Vsccmdi.azureResourceGroups.openInPortal,
* McsEngl.Vsccmnd.azureResourceGroups.openInPortal,

Vsccmdi.azureResourceGroups.openUrl,
* McsEngl.Vsccmnd.azureResourceGroups.openUrl,

Vsccmdi.azureResourceGroups.refresh,
* McsEngl.Vsccmnd.azureResourceGroups.refresh,

Vsccmdi.azureResourceGroups.refreshTree,
* McsEngl.Vsccmnd.azureResourceGroups.refreshTree,

Vsccmdi.azureResourceGroups.removeView,
* McsEngl.Vsccmnd.azureResourceGroups.removeView,

Vsccmdi.azureResourceGroups.reportIssue,
* McsEngl.Vsccmnd.azureResourceGroups.reportIssue,

Vsccmdi.azureResourceGroups.resetViewLocation,
* McsEngl.Vsccmnd.azureResourceGroups.resetViewLocation,

Vsccmdi.azureResourceGroups.revealResource,
* McsEngl.Vsccmnd.azureResourceGroups.revealResource,

Vsccmdi.azureResourceGroups.selectSubscriptions,
* McsEngl.Vsccmnd.azureResourceGroups.selectSubscriptions,

Vsccmdi.azureResourceGroups.showGroupOptions,
* McsEngl.Vsccmnd.azureResourceGroups.showGroupOptions,

Vsccmdi.azureResourceGroups.signInToTenant,
* McsEngl.Vsccmnd.azureResourceGroups.signInToTenant,

Vsccmdi.azureResourceGroups.toggleVisibility,
* McsEngl.Vsccmnd.azureResourceGroups.toggleVisibility,

Vsccmdi.azureResourceGroups.unfocusGroup,
* McsEngl.Vsccmnd.azureResourceGroups.unfocusGroup,

Vsccmdi.azureResourceGroups.uploadFileCloudConsole,
* McsEngl.Vsccmnd.azureResourceGroups.uploadFileCloudConsole,

Vsccmdi.azureResourceGroups.viewProperties,
* McsEngl.Vsccmnd.azureResourceGroups.viewProperties,

Vsccmdi.azureTenantsView.addAccount,
* McsEngl.Vsccmnd.azureTenantsView.addAccount,

Vsccmdi.azureTenantsView.configureSovereignCloud,
* McsEngl.Vsccmnd.azureTenantsView.configureSovereignCloud,

Vsccmdi.azureTenantsView.focus,
* McsEngl.Vsccmnd.azureTenantsView.focus,

Vsccmdi.azureTenantsView.refresh,
* McsEngl.Vsccmnd.azureTenantsView.refresh,

Vsccmdi.azureTenantsView.refreshTree,
* McsEngl.Vsccmnd.azureTenantsView.refreshTree,

Vsccmdi.azureTenantsView.removeView,
* McsEngl.Vsccmnd.azureTenantsView.removeView,

Vsccmdi.azureTenantsView.resetViewLocation,
* McsEngl.Vsccmnd.azureTenantsView.resetViewLocation,

Vsccmdi.azureTenantsView.signInToTenant,
* McsEngl.Vsccmnd.azureTenantsView.signInToTenant,

Vsccmdi.azureTenantsView.toggleVisibility,
* McsEngl.Vsccmnd.azureTenantsView.toggleVisibility,

Vsccmdi.azureWorkspace.focus,
* McsEngl.Vsccmnd.azureWorkspace.focus,

Vsccmdi.azureWorkspace.loadMore,
* McsEngl.Vsccmnd.azureWorkspace.loadMore,

Vsccmdi.azureWorkspace.refresh,
* McsEngl.Vsccmnd.azureWorkspace.refresh,

Vsccmdi.azureWorkspace.refreshTree,
* McsEngl.Vsccmnd.azureWorkspace.refreshTree,

Vsccmdi.azureWorkspace.removeView,
* McsEngl.Vsccmnd.azureWorkspace.removeView,

Vsccmdi.azureWorkspace.resetViewLocation,
* McsEngl.Vsccmnd.azureWorkspace.resetViewLocation,

Vsccmdi.azureWorkspace.toggleVisibility,
* McsEngl.Vsccmnd.azureWorkspace.toggleVisibility,

Vsccmdi.breadcrumbs.copyPath,
* McsEngl.Vsccmnd.breadcrumbs.copyPath,

Vsccmdi.breadcrumbs.focus,
· key: ctrl+shift+;,
· when: breadcrumbsPossible && breadcrumbsVisible,
* McsEngl.Vsccmnd.breadcrumbs.focus,

Vsccmdi.breadcrumbs.focusAndSelect,
· key: ctrl+shift+.,
· when: breadcrumbsPossible && breadcrumbsVisible,
* McsEngl.Vsccmnd.breadcrumbs.focusAndSelect,

Vsccmdi.breadcrumbs.focusNext,
· key: ctrl+right,
· when: breadcrumbsActive && breadcrumbsVisible,
* McsEngl.Vsccmnd.breadcrumbs.focusNext,

Vsccmdi.breadcrumbs.focusNext,
· key: right,
· when: breadcrumbsActive && breadcrumbsVisible,
* McsEngl.Vsccmnd.breadcrumbs.focusNext,

Vsccmdi.breadcrumbs.focusNextWithPicker,
· key: ctrl+right,
· when: breadcrumbsActive && breadcrumbsVisible && listFocus && !inputFocus && !treestickyScrollFocused,
* McsEngl.Vsccmnd.breadcrumbs.focusNextWithPicker,

Vsccmdi.breadcrumbs.focusPrevious,
· key: ctrl+left,
· when: breadcrumbsActive && breadcrumbsVisible,
* McsEngl.Vsccmnd.breadcrumbs.focusPrevious,

Vsccmdi.breadcrumbs.focusPrevious,
· key: left,
· when: breadcrumbsActive && breadcrumbsVisible,
* McsEngl.Vsccmnd.breadcrumbs.focusPrevious,

Vsccmdi.breadcrumbs.focusPreviousWithPicker,
· key: ctrl+left,
· when: breadcrumbsActive && breadcrumbsVisible && listFocus && !inputFocus && !treestickyScrollFocused,
* McsEngl.Vsccmnd.breadcrumbs.focusPreviousWithPicker,

Vsccmdi.breadcrumbs.revealFocused,
· key: ctrl+enter,
· when: breadcrumbsActive && breadcrumbsVisible,
* McsEngl.Vsccmnd.breadcrumbs.revealFocused,

Vsccmdi.breadcrumbs.revealFocused,
· key: space,
· when: breadcrumbsActive && breadcrumbsVisible,
* McsEngl.Vsccmnd.breadcrumbs.revealFocused,

Vsccmdi.breadcrumbs.revealFocusedFromTreeAside,
· key: ctrl+enter,
· when: breadcrumbsActive && breadcrumbsVisible && listFocus && !inputFocus && !treestickyScrollFocused,
* McsEngl.Vsccmnd.breadcrumbs.revealFocusedFromTreeAside,

Vsccmdi.breadcrumbs.selectEditor,
· key: escape,
· when: breadcrumbsActive && breadcrumbsVisible,
* McsEngl.Vsccmnd.breadcrumbs.selectEditor,

Vsccmdi.breadcrumbs.selectFocused,
· key: down,
· when: breadcrumbsActive && breadcrumbsVisible,
* McsEngl.Vsccmnd.breadcrumbs.selectFocused,

Vsccmdi.breadcrumbs.selectFocused,
· key: enter,
· when: breadcrumbsActive && breadcrumbsVisible,
* McsEngl.Vsccmnd.breadcrumbs.selectFocused,

Vsccmdi.breadcrumbs.toggle,
* McsEngl.Vsccmnd.breadcrumbs.toggle,

Vsccmdi.breadcrumbs.toggleFromEditorTitle,
* McsEngl.Vsccmnd.breadcrumbs.toggleFromEditorTitle,

Vsccmdi.breadcrumbs.toggleToOn,
· key: ctrl+shift+.,
· when: !config.breadcrumbs.enabled,
* McsEngl.Vsccmnd.breadcrumbs.toggleToOn,

Vsccmdi.breakpointWidget.action.acceptInput,
· key: enter,
· when: breakpointWidgetVisible && inBreakpointWidget,
* McsEngl.Vsccmnd.breakpointWidget.action.acceptInput,

Vsccmdi.callStack.collapse,
* McsEngl.Vsccmnd.callStack.collapse,

Vsccmdi.callStackWidget.goToFile,
* McsEngl.Vsccmnd.callStackWidget.goToFile,

Vsccmdi.cancelLinkedEditingInput,
· key: escape,
· when: LinkedEditingInputVisible && editorTextFocus,
* McsEngl.Vsccmnd.cancelLinkedEditingInput,

Vsccmdi.cancelLinkedEditingInput,
· key: shift+escape,
· when: LinkedEditingInputVisible && editorTextFocus,
* McsEngl.Vsccmnd.cancelLinkedEditingInput,

Vsccmdi.cancelRenameInput,
· key: escape,
· when: editorFocus && renameInputVisible,
* McsEngl.Vsccmnd.cancelRenameInput,

Vsccmdi.cancelRenameInput,
· key: shift+escape,
· when: editorFocus && renameInputVisible,
* McsEngl.Vsccmnd.cancelRenameInput,

Vsccmdi.cancelSelection,
· key: escape,
· when: editorHasSelection && textInputFocus,
* McsEngl.Vsccmnd.cancelSelection,

Vsccmdi.cancelSelection,
· key: shift+escape,
· when: editorHasSelection && textInputFocus,
* McsEngl.Vsccmnd.cancelSelection,

Vsccmdi.changeEditorIndentation1,
* McsEngl.Vsccmnd.changeEditorIndentation1,

Vsccmdi.chat.action.focus,
· key: ctrl+down,
· when: inChat && inChatInput && quickChatHasFocus,
* McsEngl.Vsccmnd.chat.action.focus,

Vsccmdi.chat.action.focus,
· key: ctrl+up,
· when: chatCursorAtTop && inChatInput && !quickChatHasFocus,
* McsEngl.Vsccmnd.chat.action.focus,

Vsccmdi.chat.action.focus,
· key: ctrl+up,
· when: inChatInput && isLinux && !quickChatHasFocus || inChatInput && isWindows && !quickChatHasFocus,
* McsEngl.Vsccmnd.chat.action.focus,

Vsccmdi.chat.configureToolSets,
* McsEngl.Vsccmnd.chat.configureToolSets,

Vsccmdi.chat.enablePremiumOverages,
* McsEngl.Vsccmnd.chat.enablePremiumOverages,

Vsccmdi.chat.inlineResourceAnchor.addFileToChat,
* McsEngl.Vsccmnd.chat.inlineResourceAnchor.addFileToChat,

Vsccmdi.chat.inlineResourceAnchor.copyResource,
· key: ctrl+c,
· when: chatAttachmentResource,
* McsEngl.Vsccmnd.chat.inlineResourceAnchor.copyResource,

Vsccmdi.chat.inlineResourceAnchor.openToSide,
· key: ctrl+enter,
· when: chatAttachmentResource,
* McsEngl.Vsccmnd.chat.inlineResourceAnchor.openToSide,

Vsccmdi.chat.inlineSymbolAnchor.goToDefinition,
* McsEngl.Vsccmnd.chat.inlineSymbolAnchor.goToDefinition,

Vsccmdi.chat.inlineSymbolAnchor.goToImplementations,
* McsEngl.Vsccmnd.chat.inlineSymbolAnchor.goToImplementations,

Vsccmdi.chat.inlineSymbolAnchor.goToReferences,
* McsEngl.Vsccmnd.chat.inlineSymbolAnchor.goToReferences,

Vsccmdi.chat.inlineSymbolAnchor.goToTypeDefinitions,
* McsEngl.Vsccmnd.chat.inlineSymbolAnchor.goToTypeDefinitions,

Vsccmdi.chat.installRecommendation.github.copilot-chat.cli,
* McsEngl.Vsccmnd.chat.installRecommendation.github.copilot-chat.cli,

Vsccmdi.chat.installRecommendation.github.copilot-chat.cloud,
* McsEngl.Vsccmnd.chat.installRecommendation.github.copilot-chat.cloud,

Vsccmdi.chat.installRecommendation.openai.chatgpt.codex,
* McsEngl.Vsccmnd.chat.installRecommendation.openai.chatgpt.codex,

Vsccmdi.chat.internal.codeReview.run,
* McsEngl.Vsccmnd.chat.internal.codeReview.run,

Vsccmdi.chat.internal.explain,
* McsEngl.Vsccmnd.chat.internal.explain,

Vsccmdi.chat.internal.fix,
* McsEngl.Vsccmnd.chat.internal.fix,

Vsccmdi.chat.internal.review,
* McsEngl.Vsccmnd.chat.internal.review,

Vsccmdi.chat.models.action.clearSearchResults,
* McsEngl.Vsccmnd.chat.models.action.clearSearchResults,

Vsccmdi.chat.openFileSnapshot,
* McsEngl.Vsccmnd.chat.openFileSnapshot,

Vsccmdi.chat.openFileUpdatedBySnapshot,
* McsEngl.Vsccmnd.chat.openFileUpdatedBySnapshot,

Vsccmdi.chat.toolOutput.save,
* McsEngl.Vsccmnd.chat.toolOutput.save,

Vsccmdi.chatEditing.acceptAllFiles,
· key: ctrl+enter,
· when: hasUndecidedChatEditingResource && inChatInput,
* McsEngl.Vsccmnd.chatEditing.acceptAllFiles,

Vsccmdi.chatEditing.acceptFile,
* McsEngl.Vsccmnd.chatEditing.acceptFile,

Vsccmdi.chatEditing.discardAllFiles,
· key: ctrl+backspace,
· when: hasUndecidedChatEditingResource && inChatInput && !chatInputHasText,
* McsEngl.Vsccmnd.chatEditing.discardAllFiles,

Vsccmdi.chatEditing.discardFile,
* McsEngl.Vsccmnd.chatEditing.discardFile,

Vsccmdi.chatEditing.multidiff.acceptAllFiles,
* McsEngl.Vsccmnd.chatEditing.multidiff.acceptAllFiles,

Vsccmdi.chatEditing.multidiff.discardAllFiles,
* McsEngl.Vsccmnd.chatEditing.multidiff.discardAllFiles,

Vsccmdi.chatEditing.multidiff.explain,
* McsEngl.Vsccmnd.chatEditing.multidiff.explain,

Vsccmdi.chatEditing.openFileInDiff,
* McsEngl.Vsccmnd.chatEditing.openFileInDiff,

Vsccmdi.chatEditing.toggleExplanationWidget,
* McsEngl.Vsccmnd.chatEditing.toggleExplanationWidget,

Vsccmdi.chatEditing.viewAllSessionChanges,
* McsEngl.Vsccmnd.chatEditing.viewAllSessionChanges,

Vsccmdi.chatEditing.viewChanges,
* McsEngl.Vsccmnd.chatEditing.viewChanges,

Vsccmdi.chatEditing.viewPreviousEdits,
* McsEngl.Vsccmnd.chatEditing.viewPreviousEdits,

Vsccmdi.chatEditor.action.accept,
· key: ctrl+shift+y,
· when: chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified || chatEdits.hasEditorModifications && notebookEditorFocused && !chatEdits.isCurrentlyBeingModified,
* McsEngl.Vsccmnd.chatEditor.action.accept,

Vsccmdi.chatEditor.action.acceptAllEdits,
· key: ctrl+alt+y,
· when: chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified || chatEdits.hasEditorModifications && notebookEditorFocused && !chatEdits.isCurrentlyBeingModified,
* McsEngl.Vsccmnd.chatEditor.action.acceptAllEdits,

Vsccmdi.chatEditor.action.acceptHunk,
· key: ctrl+y,
· when: chatEdits.cursorInChangeRange && chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified || chatEdits.cursorInChangeRange && chatEdits.hasEditorModifications && notebookCellListFocused && !chatEdits.isCurrentlyBeingModified,
* McsEngl.Vsccmnd.chatEditor.action.acceptHunk,

Vsccmdi.chatEditor.action.navigateNext,
· key: alt+f5,
· when: chatEdits.hasEditorModifications && chatIsEnabled && editorFocus || chatEdits.hasEditorModifications && chatIsEnabled && notebookCellListFocused,
* McsEngl.Vsccmnd.chatEditor.action.navigateNext,

Vsccmdi.chatEditor.action.navigatePrevious,
· key: shift+alt+f5,
· when: chatEdits.hasEditorModifications && chatIsEnabled && editorFocus || chatEdits.hasEditorModifications && chatIsEnabled && notebookCellListFocused,
* McsEngl.Vsccmnd.chatEditor.action.navigatePrevious,

Vsccmdi.chatEditor.action.reject,
· key: ctrl+shift+n,
· when: chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified || chatEdits.hasEditorModifications && notebookEditorFocused && !chatEdits.isCurrentlyBeingModified,
* McsEngl.Vsccmnd.chatEditor.action.reject,

Vsccmdi.chatEditor.action.reviewChanges,
* McsEngl.Vsccmnd.chatEditor.action.reviewChanges,

Vsccmdi.chatEditor.action.showAccessibleDiffView,
· key: f7,
· when: accessibilityModeEnabled && chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified,
* McsEngl.Vsccmnd.chatEditor.action.showAccessibleDiffView,

Vsccmdi.chatEditor.action.toggleDiff,
· key: shift+alt+f7,
· when: chatEdits.hasEditorModifications && editorFocus,
* McsEngl.Vsccmnd.chatEditor.action.toggleDiff,

Vsccmdi.chatEditor.action.undoHunk,
· key: ctrl+n,
· when: chatEdits.cursorInChangeRange && chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified || chatEdits.cursorInChangeRange && chatEdits.hasEditorModifications && notebookCellListFocused && !chatEdits.isCurrentlyBeingModified,
* McsEngl.Vsccmnd.chatEditor.action.undoHunk,

Vsccmdi.cleanSearchEditorState,
* McsEngl.Vsccmnd.cleanSearchEditorState,

Vsccmdi.clearFilterCodeActionWidget,
· key: escape,
· when: codeActionMenuFilterFocused && codeActionMenuVisible,
* McsEngl.Vsccmnd.clearFilterCodeActionWidget,

Vsccmdi.closeBreakpointWidget,
· key: escape,
· when: breakpointWidgetVisible && textInputFocus,
* McsEngl.Vsccmnd.closeBreakpointWidget,

Vsccmdi.closeBreakpointWidget,
· key: shift+escape,
· when: breakpointWidgetVisible && textInputFocus,
* McsEngl.Vsccmnd.closeBreakpointWidget,

Vsccmdi.closeFindWidget,
· key: escape,
· when: editorFocus && findWidgetVisible && !isComposing,
* McsEngl.Vsccmnd.closeFindWidget,

Vsccmdi.closeFindWidget,
· key: shift+escape,
· when: editorFocus && findWidgetVisible && !isComposing,
* McsEngl.Vsccmnd.closeFindWidget,

Vsccmdi.closeMarkersNavigation,
· key: escape,
· when: editorFocus && markersNavigationVisible,
* McsEngl.Vsccmnd.closeMarkersNavigation,

Vsccmdi.closeMarkersNavigation,
· key: shift+escape,
· when: editorFocus && markersNavigationVisible,
* McsEngl.Vsccmnd.closeMarkersNavigation,

Vsccmdi.closeParameterHints,
· key: escape,
· when: editorFocus && parameterHintsVisible,
* McsEngl.Vsccmnd.closeParameterHints,

Vsccmdi.closeParameterHints,
· key: shift+escape,
· when: editorFocus && parameterHintsVisible,
* McsEngl.Vsccmnd.closeParameterHints,

Vsccmdi.closeQuickDiff,
· key: escape,
· when: dirtyDiffVisible,
* McsEngl.Vsccmnd.closeQuickDiff,

Vsccmdi.closeQuickDiff,
· key: shift+escape,
· when: dirtyDiffVisible,
* McsEngl.Vsccmnd.closeQuickDiff,

Vsccmdi.closeReferenceSearch,
· key: escape,
· when: editorTextFocus && referenceSearchVisible && !config.editor.stablePeek || referenceSearchVisible && !config.editor.stablePeek && !inputFocus,
* McsEngl.Vsccmnd.closeReferenceSearch,

Vsccmdi.closeReferenceSearch,
· key: escape,
· when: inReferenceSearchEditor && !config.editor.stablePeek,
* McsEngl.Vsccmnd.closeReferenceSearch,

Vsccmdi.closeReferenceSearch,
· key: shift+escape,
· when: editorTextFocus && referenceSearchVisible && !config.editor.stablePeek || referenceSearchVisible && !config.editor.stablePeek && !inputFocus,
* McsEngl.Vsccmnd.closeReferenceSearch,

Vsccmdi.closeReferenceSearch,
· key: shift+escape,
· when: inReferenceSearchEditor && !config.editor.stablePeek,
* McsEngl.Vsccmnd.closeReferenceSearch,

Vsccmdi.closeReferenceSearchEditor,
* McsEngl.Vsccmnd.closeReferenceSearchEditor,

Vsccmdi.closeReplaceInFilesWidget,
· key: escape,
· when: replaceInputBoxFocus && searchViewletVisible,
* McsEngl.Vsccmnd.closeReplaceInFilesWidget,

Vsccmdi.codelens.showLensesInCurrentLine,
* McsEngl.Vsccmnd.codelens.showLensesInCurrentLine,

Vsccmdi.codepoint.describe,
* McsEngl.Vsccmnd.codepoint.describe,

Vsccmdi.codereferencing.showOutputPane2,
* McsEngl.Vsccmnd.codereferencing.showOutputPane2,

Vsccmdi.collapseSectionCodeAction,
· key: left,
· when: codeActionMenuVisible && !codeActionMenuFilterFocused,
* McsEngl.Vsccmnd.collapseSectionCodeAction,

Vsccmdi.columnSelect,
* McsEngl.Vsccmnd.columnSelect,

Vsccmdi.comments.collapse,
* McsEngl.Vsccmnd.comments.collapse,

Vsccmdi.comments.expand,
* McsEngl.Vsccmnd.comments.expand,

Vsccmdi.comments.reply,
* McsEngl.Vsccmnd.comments.reply,

Vsccmdi.commentsClearFilterText,
· key: escape,
· when: commentsFilterFocus,
* McsEngl.Vsccmnd.commentsClearFilterText,

Vsccmdi.commentsFocusFilter,
· key: ctrl+f,
· when: focusedView == 'workbench.panel.comments',
* McsEngl.Vsccmnd.commentsFocusFilter,

Vsccmdi.commentsFocusViewFromFilter,
· key: ctrl+down,
· when: commentsFilterFocus,
* McsEngl.Vsccmnd.commentsFocusViewFromFilter,

Vsccmdi.compareFiles,
* McsEngl.Vsccmnd.compareFiles,

Vsccmdi.compareSelected,
* McsEngl.Vsccmnd.compareSelected,

Vsccmdi.compositionEnd,
* McsEngl.Vsccmnd.compositionEnd,

Vsccmdi.compositionStart,
* McsEngl.Vsccmnd.compositionStart,

Vsccmdi.compositionType,
* McsEngl.Vsccmnd.compositionType,

Vsccmdi.context-inspector.focus,
* McsEngl.Vsccmnd.context-inspector.focus,

Vsccmdi.context-inspector.resetViewLocation,
* McsEngl.Vsccmnd.context-inspector.resetViewLocation,

Vsccmdi.copilot-chat.focus,
* McsEngl.Vsccmnd.copilot-chat.focus,

Vsccmdi.copilot-chat.resetViewLocation,
* McsEngl.Vsccmnd.copilot-chat.resetViewLocation,

Vsccmdi.copilot.claude.agents,
* McsEngl.Vsccmnd.copilot.claude.agents,

Vsccmdi.copilot.claude.hooks,
* McsEngl.Vsccmnd.copilot.claude.hooks,

Vsccmdi.copilot.claude.memory,
* McsEngl.Vsccmnd.copilot.claude.memory,

Vsccmdi.copyFilePath,
· key: shift+alt+c,
· when: !editorFocus,
* McsEngl.Vsccmnd.copyFilePath,

Vsccmdi.copyFilePath,
· key: shift+alt+c,
· when: editorFocus,
* McsEngl.Vsccmnd.copyFilePath,

Vsccmdi.copyRelativeFilePath,
· key: ctrl+k ctrl+shift+c,
· when: !editorFocus,
* McsEngl.Vsccmnd.copyRelativeFilePath,

Vsccmdi.copyRelativeFilePath,
· key: ctrl+k ctrl+shift+c,
· when: editorFocus,
* McsEngl.Vsccmnd.copyRelativeFilePath,

Vsccmdi.createCursor,
* McsEngl.Vsccmnd.createCursor,

Vsccmdi.cursorBottom,
· key: ctrl+end,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorBottom,

Vsccmdi.cursorBottomSelect,
· key: ctrl+shift+end,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorBottomSelect,

Vsccmdi.cursorColumnSelectDown,
· key: ctrl+shift+alt+down,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorColumnSelectDown,

Vsccmdi.cursorColumnSelectDown,
· key: shift+down,
· when: editorColumnSelection && textInputFocus,
* McsEngl.Vsccmnd.cursorColumnSelectDown,

Vsccmdi.cursorColumnSelectLeft,
· key: ctrl+shift+alt+left,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorColumnSelectLeft,

Vsccmdi.cursorColumnSelectLeft,
· key: shift+left,
· when: editorColumnSelection && textInputFocus,
* McsEngl.Vsccmnd.cursorColumnSelectLeft,

Vsccmdi.cursorColumnSelectPageDown,
· key: ctrl+shift+alt+pagedown,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorColumnSelectPageDown,

Vsccmdi.cursorColumnSelectPageDown,
· key: shift+pagedown,
· when: editorColumnSelection && textInputFocus,
* McsEngl.Vsccmnd.cursorColumnSelectPageDown,

Vsccmdi.cursorColumnSelectPageUp,
· key: ctrl+shift+alt+pageup,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorColumnSelectPageUp,

Vsccmdi.cursorColumnSelectPageUp,
· key: shift+pageup,
· when: editorColumnSelection && textInputFocus,
* McsEngl.Vsccmnd.cursorColumnSelectPageUp,

Vsccmdi.cursorColumnSelectRight,
· key: ctrl+shift+alt+right,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorColumnSelectRight,

Vsccmdi.cursorColumnSelectRight,
· key: shift+right,
· when: editorColumnSelection && textInputFocus,
* McsEngl.Vsccmnd.cursorColumnSelectRight,

Vsccmdi.cursorColumnSelectUp,
· key: ctrl+shift+alt+up,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorColumnSelectUp,

Vsccmdi.cursorColumnSelectUp,
· key: shift+up,
· when: editorColumnSelection && textInputFocus,
* McsEngl.Vsccmnd.cursorColumnSelectUp,

Vsccmdi.cursorDown,
· key: down,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorDown,

Vsccmdi.cursorDownSelect,
· key: ctrl+shift+down,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorDownSelect,

Vsccmdi.cursorDownSelect,
· key: shift+down,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorDownSelect,

Vsccmdi.cursorEnd,
· key: end,
· when: textInputFocus,
· args: {"sticky":false},
* McsEngl.Vsccmnd.cursorEnd,

Vsccmdi.cursorEndSelect,
· key: shift+end,
· when: textInputFocus,
· args: {"sticky":false},
* McsEngl.Vsccmnd.cursorEndSelect,

Vsccmdi.cursorHome,
· key: home,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorHome,

Vsccmdi.cursorHomeSelect,
· key: shift+home,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorHomeSelect,

Vsccmdi.cursorLeft,
· key: left,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorLeft,

Vsccmdi.cursorLeftSelect,
· key: shift+left,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorLeftSelect,

Vsccmdi.cursorLineEnd,
* McsEngl.Vsccmnd.cursorLineEnd,

Vsccmdi.cursorLineEndSelect,
* McsEngl.Vsccmnd.cursorLineEndSelect,

Vsccmdi.cursorLineStart,
* McsEngl.Vsccmnd.cursorLineStart,

Vsccmdi.cursorLineStartSelect,
* McsEngl.Vsccmnd.cursorLineStartSelect,

Vsccmdi.cursorPageDown,
· key: pagedown,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorPageDown,

Vsccmdi.cursorPageDownSelect,
· key: shift+pagedown,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorPageDownSelect,

Vsccmdi.cursorPageUp,
· key: pageup,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorPageUp,

Vsccmdi.cursorPageUpSelect,
· key: shift+pageup,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorPageUpSelect,

Vsccmdi.cursorRedo,
* McsEngl.Vsccmnd.cursorRedo,

Vsccmdi.cursorRight,
· key: right,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorRight,

Vsccmdi.cursorRightSelect,
· key: shift+right,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorRightSelect,

Vsccmdi.cursorTop,
· key: ctrl+home,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorTop,

Vsccmdi.cursorTopSelect,
· key: ctrl+shift+home,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorTopSelect,

Vsccmdi.cursorUndo,
· key: ctrl+u,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorUndo,

Vsccmdi.cursorUp,
· key: up,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorUp,

Vsccmdi.cursorUpSelect,
· key: ctrl+shift+up,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorUpSelect,

Vsccmdi.cursorUpSelect,
· key: shift+up,
· when: textInputFocus,
* McsEngl.Vsccmnd.cursorUpSelect,

Vsccmdi.cursorWordAccessibilityLeft,
· key: ctrl+left,
· when: accessibilityModeEnabled && isWindows && textInputFocus && focusedView == 'workbench.panel.output',
* McsEngl.Vsccmnd.cursorWordAccessibilityLeft,

Vsccmdi.cursorWordAccessibilityLeftSelect,
· key: ctrl+shift+left,
· when: accessibilityModeEnabled && isWindows && textInputFocus && focusedView == 'workbench.panel.output',
* McsEngl.Vsccmnd.cursorWordAccessibilityLeftSelect,

Vsccmdi.cursorWordAccessibilityRight,
· key: ctrl+right,
· when: accessibilityModeEnabled && isWindows && textInputFocus && focusedView == 'workbench.panel.output',
* McsEngl.Vsccmnd.cursorWordAccessibilityRight,

Vsccmdi.cursorWordAccessibilityRightSelect,
· key: ctrl+shift+right,
· when: accessibilityModeEnabled && isWindows && textInputFocus && focusedView == 'workbench.panel.output',
* McsEngl.Vsccmnd.cursorWordAccessibilityRightSelect,

Vsccmdi.cursorWordEndLeft,
* McsEngl.Vsccmnd.cursorWordEndLeft,

Vsccmdi.cursorWordEndLeftSelect,
* McsEngl.Vsccmnd.cursorWordEndLeftSelect,

Vsccmdi.cursorWordEndRight,
· key: ctrl+right,
· when: textInputFocus && !accessibilityModeEnabled,
* McsEngl.Vsccmnd.cursorWordEndRight,

Vsccmdi.cursorWordEndRightSelect,
· key: ctrl+shift+right,
· when: textInputFocus && !accessibilityModeEnabled,
* McsEngl.Vsccmnd.cursorWordEndRightSelect,

Vsccmdi.cursorWordLeft,
· key: ctrl+left,
· when: textInputFocus && !accessibilityModeEnabled,
* McsEngl.Vsccmnd.cursorWordLeft,

Vsccmdi.cursorWordLeftSelect,
· key: ctrl+shift+left,
· when: textInputFocus && !accessibilityModeEnabled,
* McsEngl.Vsccmnd.cursorWordLeftSelect,

Vsccmdi.cursorWordPartLeft,
* McsEngl.Vsccmnd.cursorWordPartLeft,

Vsccmdi.cursorWordPartLeftSelect,
* McsEngl.Vsccmnd.cursorWordPartLeftSelect,

Vsccmdi.cursorWordPartRight,
* McsEngl.Vsccmnd.cursorWordPartRight,

Vsccmdi.cursorWordPartRightSelect,
* McsEngl.Vsccmnd.cursorWordPartRightSelect,

Vsccmdi.cursorWordPartStartLeft,
* McsEngl.Vsccmnd.cursorWordPartStartLeft,

Vsccmdi.cursorWordPartStartLeftSelect,
* McsEngl.Vsccmnd.cursorWordPartStartLeftSelect,

Vsccmdi.cursorWordRight,
* McsEngl.Vsccmnd.cursorWordRight,

Vsccmdi.cursorWordRightSelect,
* McsEngl.Vsccmnd.cursorWordRightSelect,

Vsccmdi.cursorWordStartLeft,
* McsEngl.Vsccmnd.cursorWordStartLeft,

Vsccmdi.cursorWordStartLeftSelect,
* McsEngl.Vsccmnd.cursorWordStartLeftSelect,

Vsccmdi.cursorWordStartRight,
* McsEngl.Vsccmnd.cursorWordStartRight,

Vsccmdi.cursorWordStartRightSelect,
* McsEngl.Vsccmnd.cursorWordStartRightSelect,

Vsccmdi.cut,
* McsEngl.Vsccmnd.cut,

Vsccmdi.debug.action.openDisassemblyView,
* McsEngl.Vsccmnd.debug.action.openDisassemblyView,

Vsccmdi.debug.action.toggleDisassemblyViewSourceCode,
* McsEngl.Vsccmnd.debug.action.toggleDisassemblyViewSourceCode,

Vsccmdi.debug.addConfiguration,
* McsEngl.Vsccmnd.debug.addConfiguration,

Vsccmdi.debug.addToWatchExpressions,
* McsEngl.Vsccmnd.debug.addToWatchExpressions,

Vsccmdi.debug.attachToCurrentCodeRenderer,
* McsEngl.Vsccmnd.debug.attachToCurrentCodeRenderer,

Vsccmdi.debug.breakWhenValueChanges,
* McsEngl.Vsccmnd.debug.breakWhenValueChanges,

Vsccmdi.debug.breakWhenValueIsAccessed,
* McsEngl.Vsccmnd.debug.breakWhenValueIsAccessed,

Vsccmdi.debug.breakWhenValueIsRead,
* McsEngl.Vsccmnd.debug.breakWhenValueIsRead,

Vsccmdi.debug.collapseRepl,
* McsEngl.Vsccmnd.debug.collapseRepl,

Vsccmdi.debug.copyEvaluatePath,
* McsEngl.Vsccmnd.debug.copyEvaluatePath,

Vsccmdi.debug.copyStackTrace,
* McsEngl.Vsccmnd.debug.copyStackTrace,

Vsccmdi.debug.copyWatchExpression,
· key: ctrl+alt+c,
· when: watchExpressionsExist && !expressionSelected && focusedView == 'workbench.debug.watchExpressionsView',
* McsEngl.Vsccmnd.debug.copyWatchExpression,

Vsccmdi.debug.editBreakpoint,
* McsEngl.Vsccmnd.debug.editBreakpoint,

Vsccmdi.debug.editBreakpointMode,
* McsEngl.Vsccmnd.debug.editBreakpointMode,

Vsccmdi.debug.editFunctionBreakpoint,
* McsEngl.Vsccmnd.debug.editFunctionBreakpoint,

Vsccmdi.debug.editFunctionBreakpointHitCount,
* McsEngl.Vsccmnd.debug.editFunctionBreakpointHitCount,

Vsccmdi.debug.enableOrDisableBreakpoint,
* McsEngl.Vsccmnd.debug.enableOrDisableBreakpoint,

Vsccmdi.debug.installAdditionalDebuggers,
* McsEngl.Vsccmnd.debug.installAdditionalDebuggers,

Vsccmdi.debug.jumpToCursor,
* McsEngl.Vsccmnd.debug.jumpToCursor,

Vsccmdi.debug.openBreakpointToSide,
· key: alt+enter,
· when: breakpointsFocused,
* McsEngl.Vsccmnd.debug.openBreakpointToSide,

Vsccmdi.debug.openBreakpointToSide,
· key: ctrl+enter,
· when: breakpointsFocused,
* McsEngl.Vsccmnd.debug.openBreakpointToSide,

Vsccmdi.debug.openView,
· key: ctrl+f5,
· when: !debuggersAvailable,
* McsEngl.Vsccmnd.debug.openView,

Vsccmdi.debug.openView,
· key: f5,
· when: !debuggersAvailable,
* McsEngl.Vsccmnd.debug.openView,

Vsccmdi.debug.removeBreakpoint,
· key: delete,
· when: breakpointsFocused && !breakpointInputFocused,
* McsEngl.Vsccmnd.debug.removeBreakpoint,

Vsccmdi.debug.removeWatchExpression,
· key: delete,
· when: watchExpressionsFocused && !expressionSelected,
* McsEngl.Vsccmnd.debug.removeWatchExpression,

Vsccmdi.debug.renameWatchExpression,
· key: f2,
· when: watchExpressionsFocused,
* McsEngl.Vsccmnd.debug.renameWatchExpression,

Vsccmdi.debug.replCopy,
* McsEngl.Vsccmnd.debug.replCopy,

Vsccmdi.debug.replPaste,
* McsEngl.Vsccmnd.debug.replPaste,

Vsccmdi.debug.setVariable,
· key: f2,
· when: variablesFocused,
* McsEngl.Vsccmnd.debug.setVariable,

Vsccmdi.debug.setWatchExpression,
* McsEngl.Vsccmnd.debug.setWatchExpression,

Vsccmdi.debug.startFromConfig,
* McsEngl.Vsccmnd.debug.startFromConfig,

Vsccmdi.debug.toggleBreakpoint,
· key: space,
· when: breakpointsFocused && !inputFocus,
* McsEngl.Vsccmnd.debug.toggleBreakpoint,

Vsccmdi.debug.toggleExceptionBreakpoints,
* McsEngl.Vsccmnd.debug.toggleExceptionBreakpoints,

Vsccmdi.debug.toggleReplIgnoreFocus,
* McsEngl.Vsccmnd.debug.toggleReplIgnoreFocus,

Vsccmdi.decreaseSearchEditorContextLines,
· key: alt+-,
· when: inSearchEditor,
* McsEngl.Vsccmnd.decreaseSearchEditorContextLines,

Vsccmdi.default:compositionEnd,
* McsEngl.Vsccmnd.default:compositionEnd,

Vsccmdi.default:compositionStart,
* McsEngl.Vsccmnd.default:compositionStart,

Vsccmdi.default:compositionType,
* McsEngl.Vsccmnd.default:compositionType,

Vsccmdi.default:cut,
* McsEngl.Vsccmnd.default:cut,

Vsccmdi.default:paste,
* McsEngl.Vsccmnd.default:paste,

Vsccmdi.default:redo,
* McsEngl.Vsccmnd.default:redo,

Vsccmdi.default:replacePreviousChar,
* McsEngl.Vsccmnd.default:replacePreviousChar,

Vsccmdi.default:type,
* McsEngl.Vsccmnd.default:type,

Vsccmdi.default:undo,
* McsEngl.Vsccmnd.default:undo,

Vsccmdi.deleteAllLeft,
* McsEngl.Vsccmnd.deleteAllLeft,

Vsccmdi.deleteAllRight,
* McsEngl.Vsccmnd.deleteAllRight,

Vsccmdi.deleteFile,
· key: delete,
· when: filesExplorerFocus && foldersViewVisible && !explorerResourceMoveableToTrash && !inputFocus,
* McsEngl.Vsccmnd.deleteFile,

Vsccmdi.deleteFile,
· key: shift+delete,
· when: filesExplorerFocus && foldersViewVisible && !inputFocus,
* McsEngl.Vsccmnd.deleteFile,

Vsccmdi.deleteInsideWord,
* McsEngl.Vsccmnd.deleteInsideWord,

Vsccmdi.deleteLeft,
· key: backspace,
· when: textInputFocus,
* McsEngl.Vsccmnd.deleteLeft,

Vsccmdi.deleteLeft,
· key: shift+backspace,
· when: textInputFocus,
* McsEngl.Vsccmnd.deleteLeft,

Vsccmdi.deleteRight,
· key: delete,
· when: textInputFocus,
* McsEngl.Vsccmnd.deleteRight,

Vsccmdi.deleteWordEndLeft,
* McsEngl.Vsccmnd.deleteWordEndLeft,

Vsccmdi.deleteWordEndRight,
* McsEngl.Vsccmnd.deleteWordEndRight,

Vsccmdi.deleteWordLeft,
· key: ctrl+backspace,
· when: textInputFocus && !editorReadonly,
* McsEngl.Vsccmnd.deleteWordLeft,

Vsccmdi.deleteWordPartLeft,
* McsEngl.Vsccmnd.deleteWordPartLeft,

Vsccmdi.deleteWordPartRight,
* McsEngl.Vsccmnd.deleteWordPartRight,

Vsccmdi.deleteWordRight,
· key: ctrl+delete,
· when: textInputFocus && !editorReadonly,
* McsEngl.Vsccmnd.deleteWordRight,

Vsccmdi.deleteWordStartLeft,
* McsEngl.Vsccmnd.deleteWordStartLeft,

Vsccmdi.deleteWordStartRight,
* McsEngl.Vsccmnd.deleteWordStartRight,

Vsccmdi.developer.showCurrentFileAsReleaseNotes,
* McsEngl.Vsccmnd.developer.showCurrentFileAsReleaseNotes,

Vsccmdi.diffEditor.collapseAllUnchangedRegions,
* McsEngl.Vsccmnd.diffEditor.collapseAllUnchangedRegions,

Vsccmdi.diffEditor.exitCompareMove,
· key: escape,
· when: comparingMovedCode" },
* McsEngl.Vsccmnd.diffEditor.exitCompareMove,

Vsccmdi.diffEditor.revert,
* McsEngl.Vsccmnd.diffEditor.revert,

Vsccmdi.diffEditor.showAllUnchangedRegions,
* McsEngl.Vsccmnd.diffEditor.showAllUnchangedRegions,

Vsccmdi.diffEditor.switchSide,
* McsEngl.Vsccmnd.diffEditor.switchSide,

Vsccmdi.diffEditor.toggleCollapseUnchangedRegions,
* McsEngl.Vsccmnd.diffEditor.toggleCollapseUnchangedRegions,

Vsccmdi.diffEditor.toggleShowMovedCodeBlocks,
* McsEngl.Vsccmnd.diffEditor.toggleShowMovedCodeBlocks,

Vsccmdi.diffEditor.toggleUseInlineViewWhenSpaceIsLimited,
* McsEngl.Vsccmnd.diffEditor.toggleUseInlineViewWhenSpaceIsLimited,

Vsccmdi.editor.action.accessibilityHelp,
· key: alt+f1,
· when: !accessibilityHelpIsShown,
* McsEngl.Vsccmnd.editor.action.accessibilityHelp,

Vsccmdi.editor.action.accessibilityHelpConfigureAssignedKeybindings,
· key: alt+a,
· when: accessibilityHelpIsShown && accessibleViewHasAssignedKeybindings,
* McsEngl.Vsccmnd.editor.action.accessibilityHelpConfigureAssignedKeybindings,

Vsccmdi.editor.action.accessibilityHelpConfigureKeybindings,
· key: alt+k,
· when: accessibilityHelpIsShown && accessibleViewHasUnassignedKeybindings,
* McsEngl.Vsccmnd.editor.action.accessibilityHelpConfigureKeybindings,

Vsccmdi.editor.action.accessibilityHelpOpenHelpLink,
· key: alt+h,
· when: accessibilityHelpIsShown,
* McsEngl.Vsccmnd.editor.action.accessibilityHelpOpenHelpLink,

Vsccmdi.editor.action.accessibleDiffViewer.next,
· key: f7,
· when: isInDiffEditor,
* McsEngl.Vsccmnd.editor.action.accessibleDiffViewer.next,

Vsccmdi.editor.action.accessibleDiffViewer.prev,
· key: shift+f7,
· when: isInDiffEditor,
* McsEngl.Vsccmnd.editor.action.accessibleDiffViewer.prev,

Vsccmdi.editor.action.accessibleView,
· key: alt+f2,
* McsEngl.Vsccmnd.editor.action.accessibleView,

Vsccmdi.editor.action.accessibleViewAcceptInlineCompletion,
· key: ctrl+/,
· when: accessibleViewIsShown && accessibleViewCurrentProviderId == 'inlineCompletions',
* McsEngl.Vsccmnd.editor.action.accessibleViewAcceptInlineCompletion,

Vsccmdi.editor.action.accessibleViewDisableHint,
· key: alt+f6,
· when: accessibilityHelpIsShown && accessibleViewVerbosityEnabled || accessibleViewIsShown && accessibleViewVerbosityEnabled,
* McsEngl.Vsccmnd.editor.action.accessibleViewDisableHint,

Vsccmdi.editor.action.accessibleViewGoToSymbol,
· key: ctrl+shift+.,
· when: accessibilityHelpIsShown && accessibleViewGoToSymbolSupported || accessibleViewGoToSymbolSupported && accessibleViewIsShown,
* McsEngl.Vsccmnd.editor.action.accessibleViewGoToSymbol,

Vsccmdi.editor.action.accessibleViewGoToSymbol,
· key: ctrl+shift+o,
· when: accessibilityHelpIsShown && accessibleViewGoToSymbolSupported || accessibleViewGoToSymbolSupported && accessibleViewIsShown,
* McsEngl.Vsccmnd.editor.action.accessibleViewGoToSymbol,

Vsccmdi.editor.action.accessibleViewNext,
· key: alt+],
· when: accessibleViewIsShown && accessibleViewSupportsNavigation,
* McsEngl.Vsccmnd.editor.action.accessibleViewNext,

Vsccmdi.editor.action.accessibleViewNextCodeBlock,
· key: ctrl+alt+pagedown,
· when: accessibleViewContainsCodeBlocks && accessibleViewCurrentProviderId == 'inlineChat' || accessibleViewContainsCodeBlocks && accessibleViewCurrentProviderId == 'panelChat' || accessibleViewContainsCodeBlocks && accessibleViewCurrentProviderId == 'quickChat',
* McsEngl.Vsccmnd.editor.action.accessibleViewNextCodeBlock,

Vsccmdi.editor.action.accessibleViewPrevious,
· key: alt+[,
· when: accessibleViewIsShown && accessibleViewSupportsNavigation,
* McsEngl.Vsccmnd.editor.action.accessibleViewPrevious,

Vsccmdi.editor.action.accessibleViewPreviousCodeBlock,
· key: ctrl+alt+pageup,
· when: accessibleViewContainsCodeBlocks && accessibleViewCurrentProviderId == 'inlineChat' || accessibleViewContainsCodeBlocks && accessibleViewCurrentProviderId == 'panelChat' || accessibleViewContainsCodeBlocks && accessibleViewCurrentProviderId == 'quickChat',
* McsEngl.Vsccmnd.editor.action.accessibleViewPreviousCodeBlock,

Vsccmdi.editor.action.addCommentLine,
· key: ctrl+k ctrl+c,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.addCommentLine,

Vsccmdi.editor.action.addCursorsToBottom,
* McsEngl.Vsccmnd.editor.action.addCursorsToBottom,

Vsccmdi.editor.action.addCursorsToTop,
* McsEngl.Vsccmnd.editor.action.addCursorsToTop,

Vsccmdi.editor.action.addSelectionToNextFindMatch,
· key: ctrl+d,
· when: editorFocus,
* McsEngl.Vsccmnd.editor.action.addSelectionToNextFindMatch,

Vsccmdi.editor.action.addSelectionToPreviousFindMatch,
* McsEngl.Vsccmnd.editor.action.addSelectionToPreviousFindMatch,

Vsccmdi.editor.action.announceCursorPosition,
· key: ctrl+shift+alt+g,
· when: accessibilityModeEnabled && editorTextFocus,
* McsEngl.Vsccmnd.editor.action.announceCursorPosition,

Vsccmdi.editor.action.autoFix,
· key: shift+alt+.,
· when: textInputFocus && !editorReadonly && supportedCodeAction =~ /(\\s|^)quickfix\\b/,
* McsEngl.Vsccmnd.editor.action.autoFix,

Vsccmdi.editor.action.blockComment,
· key: shift+alt+a,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.blockComment,

Vsccmdi.editor.action.cancelSelectionAnchor,
· key: escape,
· when: editorTextFocus && selectionAnchorSet,
* McsEngl.Vsccmnd.editor.action.cancelSelectionAnchor,

Vsccmdi.editor.action.changeAll,
· key: ctrl+f2,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.changeAll,

Vsccmdi.editor.action.changeTabDisplaySize,
* McsEngl.Vsccmnd.editor.action.changeTabDisplaySize,

Vsccmdi.editor.action.clipboardCopyAction,
· key: ctrl+c,
* McsEngl.Vsccmnd.editor.action.clipboardCopyAction,

Vsccmdi.editor.action.clipboardCopyAction,
· key: ctrl+insert,
* McsEngl.Vsccmnd.editor.action.clipboardCopyAction,

Vsccmdi.editor.action.clipboardCopyWithSyntaxHighlightingAction,
* McsEngl.Vsccmnd.editor.action.clipboardCopyWithSyntaxHighlightingAction,

Vsccmdi.editor.action.clipboardCutAction,
· key: ctrl+x,
* McsEngl.Vsccmnd.editor.action.clipboardCutAction,

Vsccmdi.editor.action.clipboardCutAction,
· key: shift+delete,
* McsEngl.Vsccmnd.editor.action.clipboardCutAction,

Vsccmdi.editor.action.clipboardPasteAction,
· key: ctrl+v,
* McsEngl.Vsccmnd.editor.action.clipboardPasteAction,

Vsccmdi.editor.action.clipboardPasteAction,
· key: shift+insert,
* McsEngl.Vsccmnd.editor.action.clipboardPasteAction,

Vsccmdi.editor.action.commentLine,
· key: ctrl+/,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.commentLine,

Vsccmdi.editor.action.copyLinesDownAction,
· key: shift+alt+down,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.copyLinesDownAction,

Vsccmdi.editor.action.copyLinesUpAction,
· key: shift+alt+up,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.copyLinesUpAction,

Vsccmdi.editor.action.debugEditorGpuRenderer,
* McsEngl.Vsccmnd.editor.action.debugEditorGpuRenderer,

Vsccmdi.editor.action.decreaseHoverVerbosityLevel,
* McsEngl.Vsccmnd.editor.action.decreaseHoverVerbosityLevel,

Vsccmdi.editor.action.defineKeybinding,
· key: ctrl+k ctrl+k,
· when: resource == 'vscode-userdata:/c%3A/Users/synag/AppData/Roaming/Code/User/keybindings.json',
* McsEngl.Vsccmnd.editor.action.defineKeybinding,

Vsccmdi.editor.action.deleteLines,
· key: ctrl+shift+k,
· when: textInputFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.deleteLines,

Vsccmdi.editor.action.detectIndentation,
* McsEngl.Vsccmnd.editor.action.detectIndentation,

Vsccmdi.editor.action.diffReview.next,
* McsEngl.Vsccmnd.editor.action.diffReview.next,

Vsccmdi.editor.action.diffReview.prev,
* McsEngl.Vsccmnd.editor.action.diffReview.prev,

Vsccmdi.editor.action.dirtydiff.next,
· key: alt+f3,
· when: editorTextFocus && !textCompareEditorActive,
* McsEngl.Vsccmnd.editor.action.dirtydiff.next,

Vsccmdi.editor.action.dirtydiff.previous,
· key: shift+alt+f3,
· when: editorTextFocus && !textCompareEditorActive,
* McsEngl.Vsccmnd.editor.action.dirtydiff.previous,

Vsccmdi.editor.action.duplicateSelection,
* McsEngl.Vsccmnd.editor.action.duplicateSelection,

Vsccmdi.editor.action.extensioneditor.findNext,
· key: enter,
· when: webviewFindWidgetFocused && !editorFocus && activeEditor == 'workbench.editor.extension',
* McsEngl.Vsccmnd.editor.action.extensioneditor.findNext,

Vsccmdi.editor.action.extensioneditor.findPrevious,
· key: shift+enter,
· when: webviewFindWidgetFocused && !editorFocus && activeEditor == 'workbench.editor.extension',
* McsEngl.Vsccmnd.editor.action.extensioneditor.findPrevious,

Vsccmdi.editor.action.extensioneditor.showfind,
· key: ctrl+f,
· when: !editorFocus && activeEditor == 'workbench.editor.extension',
* McsEngl.Vsccmnd.editor.action.extensioneditor.showfind,

Vsccmdi.editor.action.findReferences,
* McsEngl.Vsccmnd.editor.action.findReferences,

Vsccmdi.editor.action.fixAll,
* McsEngl.Vsccmnd.editor.action.fixAll,

Vsccmdi.editor.action.focusNextCursor,
* McsEngl.Vsccmnd.editor.action.focusNextCursor,

Vsccmdi.editor.action.focusPreviousCursor,
* McsEngl.Vsccmnd.editor.action.focusPreviousCursor,

Vsccmdi.editor.action.focusStickyScroll,
* McsEngl.Vsccmnd.editor.action.focusStickyScroll,

Vsccmdi.editor.action.fontZoomIn,
* McsEngl.Vsccmnd.editor.action.fontZoomIn,

Vsccmdi.editor.action.fontZoomOut,
* McsEngl.Vsccmnd.editor.action.fontZoomOut,

Vsccmdi.editor.action.fontZoomReset,
* McsEngl.Vsccmnd.editor.action.fontZoomReset,

Vsccmdi.editor.action.forceRetokenize,
* McsEngl.Vsccmnd.editor.action.forceRetokenize,

Vsccmdi.editor.action.format,
* McsEngl.Vsccmnd.editor.action.format,

Vsccmdi.editor.action.formatChanges,
* McsEngl.Vsccmnd.editor.action.formatChanges,

Vsccmdi.editor.action.formatDocument,
· key: shift+alt+f,
· when: editorHasDocumentFormattingProvider && editorTextFocus && !editorReadonly && !inCompositeEditor,
* McsEngl.Vsccmnd.editor.action.formatDocument,

Vsccmdi.editor.action.formatDocument.multiple,
* McsEngl.Vsccmnd.editor.action.formatDocument.multiple,

Vsccmdi.editor.action.formatDocument.none,
· key: shift+alt+f,
· when: editorTextFocus && !editorHasDocumentFormattingProvider && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.formatDocument.none,

Vsccmdi.editor.action.formatSelection,
· key: ctrl+k ctrl+f,
· when: editorHasDocumentSelectionFormattingProvider && editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.formatSelection,

Vsccmdi.editor.action.formatSelection.multiple,
* McsEngl.Vsccmnd.editor.action.formatSelection.multiple,

Vsccmdi.editor.action.goToBottomHover,
· key: ctrl+down,
· when: editorHoverFocused,
* McsEngl.Vsccmnd.editor.action.goToBottomHover,

Vsccmdi.editor.action.goToBottomHover,
· key: end,
· when: editorHoverFocused,
* McsEngl.Vsccmnd.editor.action.goToBottomHover,

Vsccmdi.editor.action.goToDeclaration,
* McsEngl.Vsccmnd.editor.action.goToDeclaration,

Vsccmdi.editor.action.goToFocusedStickyScrollLine,
· key: enter,
· when: stickyScrollFocused,
* McsEngl.Vsccmnd.editor.action.goToFocusedStickyScrollLine,

Vsccmdi.editor.action.goToImplementation,
· key: ctrl+f12,
· when: editorHasImplementationProvider && editorTextFocus,
* McsEngl.Vsccmnd.editor.action.goToImplementation,

Vsccmdi.editor.action.goToMatchFindAction,
* McsEngl.Vsccmnd.editor.action.goToMatchFindAction,

Vsccmdi.editor.action.goToReferences,
· key: shift+f12,
· when: editorHasReferenceProvider && editorTextFocus && !inReferenceSearchEditor && !isInEmbeddedEditor,
* McsEngl.Vsccmnd.editor.action.goToReferences,

Vsccmdi.editor.action.goToSelectionAnchor,
* McsEngl.Vsccmnd.editor.action.goToSelectionAnchor,

Vsccmdi.editor.action.goToTopHover,
· key: ctrl+up,
· when: editorHoverFocused,
* McsEngl.Vsccmnd.editor.action.goToTopHover,

Vsccmdi.editor.action.goToTopHover,
· key: home,
· when: editorHoverFocused,
* McsEngl.Vsccmnd.editor.action.goToTopHover,

Vsccmdi.editor.action.goToTypeDefinition,
* McsEngl.Vsccmnd.editor.action.goToTypeDefinition,

Vsccmdi.editor.action.hideColorPicker,
· key: escape,
· when: standaloneColorPickerVisible,
* McsEngl.Vsccmnd.editor.action.hideColorPicker,

Vsccmdi.editor.action.hideHover,
* McsEngl.Vsccmnd.editor.action.hideHover,

Vsccmdi.editor.action.hideLongLineWarningHover,
* McsEngl.Vsccmnd.editor.action.hideLongLineWarningHover,

Vsccmdi.editor.action.inPlaceReplace.down,
· key: ctrl+shift+.,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.inPlaceReplace.down,

Vsccmdi.editor.action.inPlaceReplace.up,
· key: ctrl+shift+,,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.inPlaceReplace.up,

Vsccmdi.editor.action.increaseHoverVerbosityLevel,
* McsEngl.Vsccmnd.editor.action.increaseHoverVerbosityLevel,

Vsccmdi.editor.action.indentLines,
· key: ctrl+],
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.indentLines,

Vsccmdi.editor.action.indentUsingSpaces,
* McsEngl.Vsccmnd.editor.action.indentUsingSpaces,

Vsccmdi.editor.action.indentUsingTabs,
* McsEngl.Vsccmnd.editor.action.indentUsingTabs,

Vsccmdi.editor.action.indentationToSpaces,
* McsEngl.Vsccmnd.editor.action.indentationToSpaces,

Vsccmdi.editor.action.indentationToTabs,
* McsEngl.Vsccmnd.editor.action.indentationToTabs,

Vsccmdi.editor.action.inlineSuggest.acceptNextLine,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.acceptNextLine,

Vsccmdi.editor.action.inlineSuggest.acceptNextWord,
· key: ctrl+right,
· when: cursorBeforeGhostText && inlineSuggestionVisible && !accessibilityModeEnabled && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.acceptNextWord,

Vsccmdi.editor.action.inlineSuggest.cancelSnooze,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.cancelSnooze,

Vsccmdi.editor.action.inlineSuggest.commit,
· key: tab,
· when: inInlineEditsPreviewEditor,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.commit,

Vsccmdi.editor.action.inlineSuggest.commit,
· key: tab,
· when: inlineEditIsVisible && tabShouldAcceptInlineEdit && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible || inlineEditIsVisible && inlineSuggestionVisible && tabShouldAcceptInlineEdit && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible || inlineSuggestionHasIndentationLessThanTabSize && inlineSuggestionVisible && !editor.hasSelection && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible || inlineEditIsVisible && inlineSuggestionHasIndentationLessThanTabSize && inlineSuggestionVisible && !editor.hasSelection && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.commit,

Vsccmdi.editor.action.inlineSuggest.commitAlternativeAction,
· key: shift+tab,
· when: inInlineEditsPreviewEditor,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.commitAlternativeAction,

Vsccmdi.editor.action.inlineSuggest.commitAlternativeAction,
· key: shift+tab,
· when: inlineEditIsVisible && inlineSuggestionAlternativeActionVisible,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.commitAlternativeAction,

Vsccmdi.editor.action.inlineSuggest.dev.extractRepro,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.dev.extractRepro,

Vsccmdi.editor.action.inlineSuggest.hide,
· key: escape,
· when: inInlineEditsPreviewEditor,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.hide,

Vsccmdi.editor.action.inlineSuggest.hide,
· key: escape,
· when: inlineEditIsVisible || inlineSuggestionVisible,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.hide,

Vsccmdi.editor.action.inlineSuggest.hide,
· key: shift+escape,
· when: inInlineEditsPreviewEditor,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.hide,

Vsccmdi.editor.action.inlineSuggest.jump,
· key: tab,
· when: inlineEditIsVisible && tabShouldJumpToInlineEdit && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.jump,

Vsccmdi.editor.action.inlineSuggest.showNext,
· key: alt+],
· when: inlineSuggestionVisible && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.showNext,

Vsccmdi.editor.action.inlineSuggest.showPrevious,
· key: alt+[,
· when: inlineSuggestionVisible && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.showPrevious,

Vsccmdi.editor.action.inlineSuggest.snooze,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.snooze,

Vsccmdi.editor.action.inlineSuggest.toggleAlwaysShowToolbar,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.toggleAlwaysShowToolbar,

Vsccmdi.editor.action.inlineSuggest.toggleShowCollapsed,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.toggleShowCollapsed,

Vsccmdi.editor.action.inlineSuggest.trigger,
* McsEngl.Vsccmnd.editor.action.inlineSuggest.trigger,

Vsccmdi.editor.action.insertColorWithStandaloneColorPicker,
· key: enter,
· when: standaloneColorPickerFocused,
* McsEngl.Vsccmnd.editor.action.insertColorWithStandaloneColorPicker,

Vsccmdi.editor.action.insertCursorAbove,
· key: ctrl+alt+up,
· when: editorTextFocus,
* McsEngl.Vsccmnd.editor.action.insertCursorAbove,

Vsccmdi.editor.action.insertCursorAtEndOfEachLineSelected,
· key: shift+alt+i,
· when: editorTextFocus,
* McsEngl.Vsccmnd.editor.action.insertCursorAtEndOfEachLineSelected,

Vsccmdi.editor.action.insertCursorBelow,
· key: ctrl+alt+down,
· when: editorTextFocus,
* McsEngl.Vsccmnd.editor.action.insertCursorBelow,

Vsccmdi.editor.action.insertFinalNewLine,
* McsEngl.Vsccmnd.editor.action.insertFinalNewLine,

Vsccmdi.editor.action.insertLineAfter,
· key: ctrl+enter,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.insertLineAfter,

Vsccmdi.editor.action.insertLineBefore,
· key: ctrl+shift+enter,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.insertLineBefore,

Vsccmdi.editor.action.insertSnippet,
* McsEngl.Vsccmnd.editor.action.insertSnippet,

Vsccmdi.editor.action.inspectTMScopes,
* McsEngl.Vsccmnd.editor.action.inspectTMScopes,

Vsccmdi.editor.action.joinLines,
* McsEngl.Vsccmnd.editor.action.joinLines,

Vsccmdi.editor.action.jumpToBracket,
· key: ctrl+shift+\\,
· when: editorTextFocus,
* McsEngl.Vsccmnd.editor.action.jumpToBracket,

Vsccmdi.editor.action.linkedEditing,
· key: ctrl+shift+f2,
· when: editorHasRenameProvider && editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.linkedEditing,

Vsccmdi.editor.action.marker.next,
· key: alt+f8,
· when: editorFocus,
* McsEngl.Vsccmnd.editor.action.marker.next,

Vsccmdi.editor.action.marker.nextInFiles,
· key: f8,
· when: editorFocus,
* McsEngl.Vsccmnd.editor.action.marker.nextInFiles,

Vsccmdi.editor.action.marker.prev,
· key: shift+alt+f8,
· when: editorFocus,
* McsEngl.Vsccmnd.editor.action.marker.prev,

Vsccmdi.editor.action.marker.prevInFiles,
· key: shift+f8,
· when: editorFocus,
* McsEngl.Vsccmnd.editor.action.marker.prevInFiles,

Vsccmdi.editor.action.measureExtHostLatency,
* McsEngl.Vsccmnd.editor.action.measureExtHostLatency,

Vsccmdi.editor.action.moveCarretLeftAction,
* McsEngl.Vsccmnd.editor.action.moveCarretLeftAction,

Vsccmdi.editor.action.moveCarretRightAction,
* McsEngl.Vsccmnd.editor.action.moveCarretRightAction,

Vsccmdi.editor.action.moveLinesDownAction,
· key: alt+down,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.moveLinesDownAction,

Vsccmdi.editor.action.moveLinesUpAction,
· key: alt+up,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.moveLinesUpAction,

Vsccmdi.editor.action.moveSelectionToNextFindMatch,
· key: ctrl+k ctrl+d,
· when: editorFocus,
* McsEngl.Vsccmnd.editor.action.moveSelectionToNextFindMatch,

Vsccmdi.editor.action.moveSelectionToPreviousFindMatch,
* McsEngl.Vsccmnd.editor.action.moveSelectionToPreviousFindMatch,

Vsccmdi.editor.action.nextCommentThreadAction,
· key: alt+f9,
* McsEngl.Vsccmnd.editor.action.nextCommentThreadAction,

Vsccmdi.editor.action.nextCommentedRangeAction,
· key: alt+f10,
· when: activeEditorHasCommentingRange,
* McsEngl.Vsccmnd.editor.action.nextCommentedRangeAction,

Vsccmdi.editor.action.nextCommentingRange,
· key: ctrl+k ctrl+alt+down,
· when: accessibilityModeEnabled && commentFocused || accessibilityModeEnabled && editorFocus || accessibilityHelpIsShown && accessibilityModeEnabled && accessibleViewCurrentProviderId == 'comments',
* McsEngl.Vsccmnd.editor.action.nextCommentingRange,

Vsccmdi.editor.action.nextMatchFindAction,
· key: enter,
· when: editorFocus && findInputFocussed,
* McsEngl.Vsccmnd.editor.action.nextMatchFindAction,

Vsccmdi.editor.action.nextMatchFindAction,
· key: f3,
· when: editorFocus,
* McsEngl.Vsccmnd.editor.action.nextMatchFindAction,

Vsccmdi.editor.action.nextSelectionMatchFindAction,
· key: ctrl+f3,
· when: editorFocus,
* McsEngl.Vsccmnd.editor.action.nextSelectionMatchFindAction,

Vsccmdi.editor.action.openDeclarationToTheSide,
* McsEngl.Vsccmnd.editor.action.openDeclarationToTheSide,

Vsccmdi.editor.action.openLink,
* McsEngl.Vsccmnd.editor.action.openLink,

Vsccmdi.editor.action.organizeImports,
· key: shift+alt+o,
· when: textInputFocus && !editorReadonly && supportedCodeAction =~ /(\\s|^)source\\.organizeImports\\b/,
* McsEngl.Vsccmnd.editor.action.organizeImports,

Vsccmdi.editor.action.outdentLines,
· key: ctrl+[,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.outdentLines,

Vsccmdi.editor.action.pageDownHover,
· key: alt+down,
· when: editorHoverFocused,
* McsEngl.Vsccmnd.editor.action.pageDownHover,

Vsccmdi.editor.action.pageDownHover,
· key: pagedown,
· when: editorHoverFocused,
* McsEngl.Vsccmnd.editor.action.pageDownHover,

Vsccmdi.editor.action.pageUpHover,
· key: alt+up,
· when: editorHoverFocused,
* McsEngl.Vsccmnd.editor.action.pageUpHover,

Vsccmdi.editor.action.pageUpHover,
· key: pageup,
· when: editorHoverFocused,
* McsEngl.Vsccmnd.editor.action.pageUpHover,

Vsccmdi.editor.action.pasteAs,
* McsEngl.Vsccmnd.editor.action.pasteAs,

Vsccmdi.editor.action.pasteAsText,
* McsEngl.Vsccmnd.editor.action.pasteAsText,

Vsccmdi.editor.action.peekDeclaration,
* McsEngl.Vsccmnd.editor.action.peekDeclaration,

Vsccmdi.editor.action.peekDefinition,
· key: alt+f12,
· when: editorHasDefinitionProvider && editorTextFocus && !inReferenceSearchEditor && !isInEmbeddedEditor,
* McsEngl.Vsccmnd.editor.action.peekDefinition,

Vsccmdi.editor.action.peekImplementation,
· key: ctrl+shift+f12,
· when: editorHasImplementationProvider && editorTextFocus && !inReferenceSearchEditor && !isInEmbeddedEditor,
* McsEngl.Vsccmnd.editor.action.peekImplementation,

Vsccmdi.editor.action.peekTypeDefinition,
* McsEngl.Vsccmnd.editor.action.peekTypeDefinition,

Vsccmdi.editor.action.previewDeclaration,
* McsEngl.Vsccmnd.editor.action.previewDeclaration,

Vsccmdi.editor.action.previousCommentThreadAction,
· key: shift+alt+f9,
* McsEngl.Vsccmnd.editor.action.previousCommentThreadAction,

Vsccmdi.editor.action.previousCommentedRangeAction,
· key: shift+alt+f10,
· when: activeEditorHasCommentingRange,
* McsEngl.Vsccmnd.editor.action.previousCommentedRangeAction,

Vsccmdi.editor.action.previousCommentingRange,
· key: ctrl+k ctrl+alt+up,
· when: accessibilityModeEnabled && commentFocused || accessibilityModeEnabled && editorFocus || accessibilityHelpIsShown && accessibilityModeEnabled && accessibleViewCurrentProviderId == 'comments',
* McsEngl.Vsccmnd.editor.action.previousCommentingRange,

Vsccmdi.editor.action.previousMatchFindAction,
· key: shift+enter,
· when: editorFocus && findInputFocussed,
* McsEngl.Vsccmnd.editor.action.previousMatchFindAction,

Vsccmdi.editor.action.previousMatchFindAction,
· key: shift+f3,
· when: editorFocus,
* McsEngl.Vsccmnd.editor.action.previousMatchFindAction,

Vsccmdi.editor.action.previousSelectionMatchFindAction,
· key: ctrl+shift+f3,
· when: editorFocus,
* McsEngl.Vsccmnd.editor.action.previousSelectionMatchFindAction,

Vsccmdi.editor.action.quickFix,
· key: ctrl+.,
· when: editorHasCodeActionsProvider && kb-macro.active && textInputFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.quickFix,

Vsccmdi.editor.action.quickFix,
· key: ctrl+.,
· when: editorHasCodeActionsProvider && textInputFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.quickFix,

Vsccmdi.editor.action.refactor,
· key: ctrl+shift+r,
· when: editorHasCodeActionsProvider && textInputFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.refactor,

Vsccmdi.editor.action.referenceSearch.trigger,
* McsEngl.Vsccmnd.editor.action.referenceSearch.trigger,

Vsccmdi.editor.action.reindentlines,
* McsEngl.Vsccmnd.editor.action.reindentlines,

Vsccmdi.editor.action.reindentselectedlines,
* McsEngl.Vsccmnd.editor.action.reindentselectedlines,

Vsccmdi.editor.action.removeBrackets,
· key: ctrl+alt+backspace,
· when: editorTextFocus,
* McsEngl.Vsccmnd.editor.action.removeBrackets,

Vsccmdi.editor.action.removeCommentLine,
· key: ctrl+k ctrl+u,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.removeCommentLine,

Vsccmdi.editor.action.removeDuplicateLines,
* McsEngl.Vsccmnd.editor.action.removeDuplicateLines,

Vsccmdi.editor.action.rename,
· key: f2,
· when: editorHasRenameProvider && editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.rename,

Vsccmdi.editor.action.replaceAll,
· key: ctrl+alt+enter,
· when: editorFocus && findWidgetVisible,
* McsEngl.Vsccmnd.editor.action.replaceAll,

Vsccmdi.editor.action.replaceOne,
· key: ctrl+shift+1,
· when: editorFocus && findWidgetVisible,
* McsEngl.Vsccmnd.editor.action.replaceOne,

Vsccmdi.editor.action.replaceOne,
· key: enter,
· when: editorFocus && findWidgetVisible && replaceInputFocussed && !isComposing,
* McsEngl.Vsccmnd.editor.action.replaceOne,

Vsccmdi.editor.action.resetSuggestSize,
* McsEngl.Vsccmnd.editor.action.resetSuggestSize,

Vsccmdi.editor.action.revealDeclaration,
* McsEngl.Vsccmnd.editor.action.revealDeclaration,

Vsccmdi.editor.action.revealDefinition,
· key: ctrl+f12,
· when: editorHasDefinitionProvider && editorTextFocus && isWeb,
* McsEngl.Vsccmnd.editor.action.revealDefinition,

Vsccmdi.editor.action.revealDefinition,
· key: f12,
· when: editorHasDefinitionProvider && editorTextFocus,
* McsEngl.Vsccmnd.editor.action.revealDefinition,

Vsccmdi.editor.action.revealDefinitionAside,
· key: ctrl+k ctrl+f12,
· when: editorHasDefinitionProvider && editorTextFocus && isWeb && !isInEmbeddedEditor,
* McsEngl.Vsccmnd.editor.action.revealDefinitionAside,

Vsccmdi.editor.action.revealDefinitionAside,
· key: ctrl+k f12,
· when: editorHasDefinitionProvider && editorTextFocus && !isInEmbeddedEditor,
* McsEngl.Vsccmnd.editor.action.revealDefinitionAside,

Vsccmdi.editor.action.reverseLines,
* McsEngl.Vsccmnd.editor.action.reverseLines,

Vsccmdi.editor.action.scrollDownHover,
· key: down,
· when: editorHoverFocused,
* McsEngl.Vsccmnd.editor.action.scrollDownHover,

Vsccmdi.editor.action.scrollLeftHover,
· key: left,
· when: editorHoverFocused,
* McsEngl.Vsccmnd.editor.action.scrollLeftHover,

Vsccmdi.editor.action.scrollRightHover,
· key: right,
· when: editorHoverFocused,
* McsEngl.Vsccmnd.editor.action.scrollRightHover,

Vsccmdi.editor.action.scrollUpHover,
· key: up,
· when: editorHoverFocused,
* McsEngl.Vsccmnd.editor.action.scrollUpHover,

Vsccmdi.editor.action.selectAll,
· key: ctrl+a,
* McsEngl.Vsccmnd.editor.action.selectAll,

Vsccmdi.editor.action.selectAllMatches,
· key: alt+enter,
· when: editorFocus && findWidgetVisible,
* McsEngl.Vsccmnd.editor.action.selectAllMatches,

Vsccmdi.editor.action.selectEditor,
· key: escape,
· when: stickyScrollFocused,
* McsEngl.Vsccmnd.editor.action.selectEditor,

Vsccmdi.editor.action.selectFromAnchorToCursor,
· key: ctrl+k ctrl+k,
· when: editorTextFocus && selectionAnchorSet,
* McsEngl.Vsccmnd.editor.action.selectFromAnchorToCursor,

Vsccmdi.editor.action.selectHighlights,
· key: ctrl+shift+l,
· when: editorFocus,
* McsEngl.Vsccmnd.editor.action.selectHighlights,

Vsccmdi.editor.action.selectNextStickyScrollLine,
· key: down,
· when: stickyScrollFocused,
* McsEngl.Vsccmnd.editor.action.selectNextStickyScrollLine,

Vsccmdi.editor.action.selectPreviousStickyScrollLine,
· key: up,
· when: stickyScrollFocused,
* McsEngl.Vsccmnd.editor.action.selectPreviousStickyScrollLine,

Vsccmdi.editor.action.selectToBracket,
* McsEngl.Vsccmnd.editor.action.selectToBracket,

Vsccmdi.editor.action.setSelectionAnchor,
· key: ctrl+k ctrl+b,
· when: editorTextFocus,
* McsEngl.Vsccmnd.editor.action.setSelectionAnchor,

Vsccmdi.editor.action.showContextMenu,
· key: shift+f10,
· when: textInputFocus,
* McsEngl.Vsccmnd.editor.action.showContextMenu,

Vsccmdi.editor.action.showDefinitionPreviewHover,
* McsEngl.Vsccmnd.editor.action.showDefinitionPreviewHover,

Vsccmdi.editor.action.showHover,
· key: ctrl+k ctrl+i,
· when: editorTextFocus,
* McsEngl.Vsccmnd.editor.action.showHover,

Vsccmdi.editor.action.showOrFocusStandaloneColorPicker,
* McsEngl.Vsccmnd.editor.action.showOrFocusStandaloneColorPicker,

Vsccmdi.editor.action.showReferences,
* McsEngl.Vsccmnd.editor.action.showReferences,

Vsccmdi.editor.action.showSnippets,
* McsEngl.Vsccmnd.editor.action.showSnippets,

Vsccmdi.editor.action.smartSelect.expand,
· key: shift+alt+right,
· when: editorTextFocus,
* McsEngl.Vsccmnd.editor.action.smartSelect.expand,

Vsccmdi.editor.action.smartSelect.grow,
* McsEngl.Vsccmnd.editor.action.smartSelect.grow,

Vsccmdi.editor.action.smartSelect.shrink,
· key: shift+alt+left,
· when: editorTextFocus,
* McsEngl.Vsccmnd.editor.action.smartSelect.shrink,

Vsccmdi.editor.action.sortLinesAscending,
* McsEngl.Vsccmnd.editor.action.sortLinesAscending,

Vsccmdi.editor.action.sortLinesDescending,
* McsEngl.Vsccmnd.editor.action.sortLinesDescending,

Vsccmdi.editor.action.sourceAction,
* McsEngl.Vsccmnd.editor.action.sourceAction,

Vsccmdi.editor.action.startDebugTextMate,
* McsEngl.Vsccmnd.editor.action.startDebugTextMate,

Vsccmdi.editor.action.startFindReplaceAction,
· key: ctrl+h,
· when: editorFocus || editorIsOpen,
* McsEngl.Vsccmnd.editor.action.startFindReplaceAction,

Vsccmdi.editor.action.submitComment,
· key: ctrl+enter,
· when: commentEditorFocused,
* McsEngl.Vsccmnd.editor.action.submitComment,

Vsccmdi.editor.action.surroundWithSnippet,
* McsEngl.Vsccmnd.editor.action.surroundWithSnippet,

Vsccmdi.editor.action.toggleColumnSelection,
* McsEngl.Vsccmnd.editor.action.toggleColumnSelection,

Vsccmdi.editor.action.toggleMinimap,
* McsEngl.Vsccmnd.editor.action.toggleMinimap,

Vsccmdi.editor.action.toggleOvertypeInsertMode,
· key: insert,
* McsEngl.Vsccmnd.editor.action.toggleOvertypeInsertMode,

Vsccmdi.editor.action.toggleRenderControlCharacter,
* McsEngl.Vsccmnd.editor.action.toggleRenderControlCharacter,

Vsccmdi.editor.action.toggleRenderWhitespace,
* McsEngl.Vsccmnd.editor.action.toggleRenderWhitespace,

Vsccmdi.editor.action.toggleScreenReaderAccessibilityMode,
· key: ctrl+e,
· when: accessibilityHelpIsShown,
* McsEngl.Vsccmnd.editor.action.toggleScreenReaderAccessibilityMode,

Vsccmdi.editor.action.toggleScreenReaderAccessibilityMode,
· key: shift+alt+f1,
* McsEngl.Vsccmnd.editor.action.toggleScreenReaderAccessibilityMode,

Vsccmdi.editor.action.toggleStickyScroll,
* McsEngl.Vsccmnd.editor.action.toggleStickyScroll,

Vsccmdi.editor.action.toggleTabFocusMode,
· key: ctrl+m,
* McsEngl.Vsccmnd.editor.action.toggleTabFocusMode,

Vsccmdi.editor.action.toggleWordWrap,
· key: alt+z,
* McsEngl.Vsccmnd.editor.action.toggleWordWrap,

Vsccmdi.editor.action.transformToCamelcase,
* McsEngl.Vsccmnd.editor.action.transformToCamelcase,

Vsccmdi.editor.action.transformToKebabcase,
* McsEngl.Vsccmnd.editor.action.transformToKebabcase,

Vsccmdi.editor.action.transformToLowercase,
* McsEngl.Vsccmnd.editor.action.transformToLowercase,

Vsccmdi.editor.action.transformToPascalcase,
* McsEngl.Vsccmnd.editor.action.transformToPascalcase,

Vsccmdi.editor.action.transformToSnakecase,
* McsEngl.Vsccmnd.editor.action.transformToSnakecase,

Vsccmdi.editor.action.transformToTitlecase,
* McsEngl.Vsccmnd.editor.action.transformToTitlecase,

Vsccmdi.editor.action.transformToUppercase,
* McsEngl.Vsccmnd.editor.action.transformToUppercase,

Vsccmdi.editor.action.transpose,
* McsEngl.Vsccmnd.editor.action.transpose,

Vsccmdi.editor.action.transposeLetters,
* McsEngl.Vsccmnd.editor.action.transposeLetters,

Vsccmdi.editor.action.triggerParameterHints,
· key: ctrl+shift+space,
· when: editorHasSignatureHelpProvider && editorTextFocus,
* McsEngl.Vsccmnd.editor.action.triggerParameterHints,

Vsccmdi.editor.action.triggerSuggest,
· key: ctrl+i,
· when: editorHasCompletionItemProvider && textInputFocus && !editorReadonly && !suggestWidgetVisible,
* McsEngl.Vsccmnd.editor.action.triggerSuggest,

Vsccmdi.editor.action.triggerSuggest,
· key: ctrl+space,
· when: editorHasCompletionItemProvider && textInputFocus && !editorReadonly && !suggestWidgetVisible,
* McsEngl.Vsccmnd.editor.action.triggerSuggest,

Vsccmdi.editor.action.trimTrailingWhitespace,
· key: ctrl+k ctrl+x,
· when: editorTextFocus && !editorReadonly,
* McsEngl.Vsccmnd.editor.action.trimTrailingWhitespace,

Vsccmdi.editor.action.unicodeHighlight.disableHighlightingOfAmbiguousCharacters,
* McsEngl.Vsccmnd.editor.action.unicodeHighlight.disableHighlightingOfAmbiguousCharacters,

Vsccmdi.editor.action.unicodeHighlight.disableHighlightingOfInvisibleCharacters,
* McsEngl.Vsccmnd.editor.action.unicodeHighlight.disableHighlightingOfInvisibleCharacters,

Vsccmdi.editor.action.unicodeHighlight.disableHighlightingOfNonBasicAsciiCharacters,
* McsEngl.Vsccmnd.editor.action.unicodeHighlight.disableHighlightingOfNonBasicAsciiCharacters,

Vsccmdi.editor.action.unicodeHighlight.showExcludeOptions,
* McsEngl.Vsccmnd.editor.action.unicodeHighlight.showExcludeOptions,

Vsccmdi.editor.action.webvieweditor.findNext,
· key: enter,
· when: webviewFindWidgetFocused && !editorFocus && activeEditor == 'WebviewEditor',
* McsEngl.Vsccmnd.editor.action.webvieweditor.findNext,

Vsccmdi.editor.action.webvieweditor.findPrevious,
· key: shift+enter,
· when: webviewFindWidgetFocused && !editorFocus && activeEditor == 'WebviewEditor',
* McsEngl.Vsccmnd.editor.action.webvieweditor.findPrevious,

Vsccmdi.editor.action.webvieweditor.hideFind,
· key: escape,
· when: webviewFindWidgetVisible && !editorFocus && activeEditor == 'WebviewEditor',
* McsEngl.Vsccmnd.editor.action.webvieweditor.hideFind,

Vsccmdi.editor.action.webvieweditor.showFind,
· key: ctrl+f,
· when: webviewFindWidgetEnabled && !editorFocus && activeEditor == 'WebviewEditor',
* McsEngl.Vsccmnd.editor.action.webvieweditor.showFind,

Vsccmdi.editor.action.wordHighlight.next,
· key: f7,
· when: editorTextFocus && hasWordHighlights,
* McsEngl.Vsccmnd.editor.action.wordHighlight.next,

Vsccmdi.editor.action.wordHighlight.prev,
· key: shift+f7,
· when: editorTextFocus && hasWordHighlights,
* McsEngl.Vsccmnd.editor.action.wordHighlight.prev,

Vsccmdi.editor.action.wordHighlight.trigger,
* McsEngl.Vsccmnd.editor.action.wordHighlight.trigger,

Vsccmdi.editor.actions.findWithArgs,
* McsEngl.Vsccmnd.editor.actions.findWithArgs,

Vsccmdi.editor.cancelOperation,
· key: escape,
· when: cancellableOperation,
* McsEngl.Vsccmnd.editor.cancelOperation,

Vsccmdi.editor.changeDropType,
· key: ctrl+.,
· when: dropWidgetVisible,
* McsEngl.Vsccmnd.editor.changeDropType,

Vsccmdi.editor.changePasteType,
· key: ctrl+.,
· when: pasteWidgetVisible,
* McsEngl.Vsccmnd.editor.changePasteType,

Vsccmdi.editor.closeCallHierarchy,
· key: escape,
· when: callHierarchyVisible && !config.editor.stablePeek,
* McsEngl.Vsccmnd.editor.closeCallHierarchy,

Vsccmdi.editor.closeTestPeek,
· key: escape,
· when: testing.isInPeek && !config.editor.stablePeek || testing.isPeekVisible && !config.editor.stablePeek,
* McsEngl.Vsccmnd.editor.closeTestPeek,

Vsccmdi.editor.closeTypeHierarchy,
· key: escape,
· when: typeHierarchyVisible && !config.editor.stablePeek,
* McsEngl.Vsccmnd.editor.closeTypeHierarchy,

Vsccmdi.editor.createFoldingRangeFromSelection,
· key: ctrl+k ctrl+,,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.createFoldingRangeFromSelection,

Vsccmdi.editor.debug.action.addLogPoint,
* McsEngl.Vsccmnd.editor.debug.action.addLogPoint,

Vsccmdi.editor.debug.action.closeExceptionWidget,
· key: escape,
· when: exceptionWidgetVisible,
* McsEngl.Vsccmnd.editor.debug.action.closeExceptionWidget,

Vsccmdi.editor.debug.action.conditionalBreakpoint,
* McsEngl.Vsccmnd.editor.debug.action.conditionalBreakpoint,

Vsccmdi.editor.debug.action.copyAddress,
* McsEngl.Vsccmnd.editor.debug.action.copyAddress,

Vsccmdi.editor.debug.action.editBreakpoint,
* McsEngl.Vsccmnd.editor.debug.action.editBreakpoint,

Vsccmdi.editor.debug.action.goToNextBreakpoint,
* McsEngl.Vsccmnd.editor.debug.action.goToNextBreakpoint,

Vsccmdi.editor.debug.action.goToPreviousBreakpoint,
* McsEngl.Vsccmnd.editor.debug.action.goToPreviousBreakpoint,

Vsccmdi.editor.debug.action.runToCursor,
* McsEngl.Vsccmnd.editor.debug.action.runToCursor,

Vsccmdi.editor.debug.action.selectionToRepl,
* McsEngl.Vsccmnd.editor.debug.action.selectionToRepl,

Vsccmdi.editor.debug.action.selectionToWatch,
* McsEngl.Vsccmnd.editor.debug.action.selectionToWatch,

Vsccmdi.editor.debug.action.showDebugHover,
· key: ctrl+k ctrl+i,
· when: editorTextFocus && inDebugMode,
* McsEngl.Vsccmnd.editor.debug.action.showDebugHover,

Vsccmdi.editor.debug.action.stepIntoTargets,
* McsEngl.Vsccmnd.editor.debug.action.stepIntoTargets,

Vsccmdi.editor.debug.action.toggleBreakpoint,
· key: f9,
· when: debuggersAvailable && disassemblyViewFocus || debuggersAvailable && editorTextFocus,
* McsEngl.Vsccmnd.editor.debug.action.toggleBreakpoint,

Vsccmdi.editor.debug.action.toggleInlineBreakpoint,
· key: shift+f9,
· when: editorTextFocus,
* McsEngl.Vsccmnd.editor.debug.action.toggleInlineBreakpoint,

Vsccmdi.editor.debug.action.triggerByBreakpoint,
* McsEngl.Vsccmnd.editor.debug.action.triggerByBreakpoint,

Vsccmdi.editor.detectLanguage,
· key: shift+alt+d,
· when: editorTextFocus && !notebookEditable,
* McsEngl.Vsccmnd.editor.detectLanguage,

Vsccmdi.editor.emmet.action.balanceIn,
* McsEngl.Vsccmnd.editor.emmet.action.balanceIn,

Vsccmdi.editor.emmet.action.balanceOut,
* McsEngl.Vsccmnd.editor.emmet.action.balanceOut,

Vsccmdi.editor.emmet.action.decrementNumberByOne,
* McsEngl.Vsccmnd.editor.emmet.action.decrementNumberByOne,

Vsccmdi.editor.emmet.action.decrementNumberByOneTenth,
* McsEngl.Vsccmnd.editor.emmet.action.decrementNumberByOneTenth,

Vsccmdi.editor.emmet.action.decrementNumberByTen,
* McsEngl.Vsccmnd.editor.emmet.action.decrementNumberByTen,

Vsccmdi.editor.emmet.action.evaluateMathExpression,
* McsEngl.Vsccmnd.editor.emmet.action.evaluateMathExpression,

Vsccmdi.editor.emmet.action.expandAbbreviation,
· key: tab,
· when: config.emmet.triggerExpansionOnTab && editorTextFocus && !editorReadonly && !editorTabMovesFocus,
* McsEngl.Vsccmnd.editor.emmet.action.expandAbbreviation,

Vsccmdi.editor.emmet.action.incrementNumberByOne,
* McsEngl.Vsccmnd.editor.emmet.action.incrementNumberByOne,

Vsccmdi.editor.emmet.action.incrementNumberByOneTenth,
* McsEngl.Vsccmnd.editor.emmet.action.incrementNumberByOneTenth,

Vsccmdi.editor.emmet.action.incrementNumberByTen,
* McsEngl.Vsccmnd.editor.emmet.action.incrementNumberByTen,

Vsccmdi.editor.emmet.action.matchTag,
* McsEngl.Vsccmnd.editor.emmet.action.matchTag,

Vsccmdi.editor.emmet.action.mergeLines,
* McsEngl.Vsccmnd.editor.emmet.action.mergeLines,

Vsccmdi.editor.emmet.action.nextEditPoint,
* McsEngl.Vsccmnd.editor.emmet.action.nextEditPoint,

Vsccmdi.editor.emmet.action.prevEditPoint,
* McsEngl.Vsccmnd.editor.emmet.action.prevEditPoint,

Vsccmdi.editor.emmet.action.reflectCSSValue,
* McsEngl.Vsccmnd.editor.emmet.action.reflectCSSValue,

Vsccmdi.editor.emmet.action.removeTag,
* McsEngl.Vsccmnd.editor.emmet.action.removeTag,

Vsccmdi.editor.emmet.action.selectNextItem,
* McsEngl.Vsccmnd.editor.emmet.action.selectNextItem,

Vsccmdi.editor.emmet.action.selectPrevItem,
* McsEngl.Vsccmnd.editor.emmet.action.selectPrevItem,

Vsccmdi.editor.emmet.action.splitJoinTag,
* McsEngl.Vsccmnd.editor.emmet.action.splitJoinTag,

Vsccmdi.editor.emmet.action.toggleComment,
* McsEngl.Vsccmnd.editor.emmet.action.toggleComment,

Vsccmdi.editor.emmet.action.updateImageSize,
* McsEngl.Vsccmnd.editor.emmet.action.updateImageSize,

Vsccmdi.editor.emmet.action.updateTag,
* McsEngl.Vsccmnd.editor.emmet.action.updateTag,

Vsccmdi.editor.emmet.action.wrapWithAbbreviation,
* McsEngl.Vsccmnd.editor.emmet.action.wrapWithAbbreviation,

Vsccmdi.editor.fold,
· key: ctrl+shift+[,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.fold,

Vsccmdi.editor.foldAll,
· key: ctrl+k ctrl+0,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.foldAll,

Vsccmdi.editor.foldAllBlockComments,
· key: ctrl+k ctrl+/,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.foldAllBlockComments,

Vsccmdi.editor.foldAllExcept,
· key: ctrl+k ctrl+-,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.foldAllExcept,

Vsccmdi.editor.foldAllMarkerRegions,
· key: ctrl+k ctrl+8,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.foldAllMarkerRegions,

Vsccmdi.editor.foldLevel1,
· key: ctrl+k ctrl+1,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.foldLevel1,

Vsccmdi.editor.foldLevel2,
· key: ctrl+k ctrl+2,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.foldLevel2,

Vsccmdi.editor.foldLevel3,
· key: ctrl+k ctrl+3,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.foldLevel3,

Vsccmdi.editor.foldLevel4,
· key: ctrl+k ctrl+4,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.foldLevel4,

Vsccmdi.editor.foldLevel5,
· key: ctrl+k ctrl+5,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.foldLevel5,

Vsccmdi.editor.foldLevel6,
· key: ctrl+k ctrl+6,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.foldLevel6,

Vsccmdi.editor.foldLevel7,
· key: ctrl+k ctrl+7,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.foldLevel7,

Vsccmdi.editor.foldRecursively,
· key: ctrl+k ctrl+[,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.foldRecursively,

Vsccmdi.editor.gotoNextFold,
* McsEngl.Vsccmnd.editor.gotoNextFold,

Vsccmdi.editor.gotoNextSymbolFromResult,
· key: f12,
· when: hasSymbols,
* McsEngl.Vsccmnd.editor.gotoNextSymbolFromResult,

Vsccmdi.editor.gotoNextSymbolFromResult.cancel,
· key: escape,
· when: hasSymbols,
* McsEngl.Vsccmnd.editor.gotoNextSymbolFromResult.cancel,

Vsccmdi.editor.gotoParentFold,
* McsEngl.Vsccmnd.editor.gotoParentFold,

Vsccmdi.editor.gotoPreviousFold,
* McsEngl.Vsccmnd.editor.gotoPreviousFold,

Vsccmdi.editor.hideDropWidget,
· key: escape,
· when: dropWidgetVisible,
* McsEngl.Vsccmnd.editor.hideDropWidget,

Vsccmdi.editor.hidePasteWidget,
· key: escape,
· when: pasteWidgetVisible,
* McsEngl.Vsccmnd.editor.hidePasteWidget,

Vsccmdi.editor.inlayHints.Reset,
* McsEngl.Vsccmnd.editor.inlayHints.Reset,

Vsccmdi.editor.refocusCallHierarchy,
· key: shift+enter,
· when: callHierarchyVisible,
* McsEngl.Vsccmnd.editor.refocusCallHierarchy,

Vsccmdi.editor.refocusTypeHierarchy,
· key: shift+enter,
· when: typeHierarchyVisible,
* McsEngl.Vsccmnd.editor.refocusTypeHierarchy,

Vsccmdi.editor.removeManualFoldingRanges,
· key: ctrl+k ctrl+.,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.removeManualFoldingRanges,

Vsccmdi.editor.showCallHierarchy,
· key: shift+alt+h,
· when: editorHasCallHierarchyProvider && editorTextFocus && !inReferenceSearchEditor,
* McsEngl.Vsccmnd.editor.showCallHierarchy,

Vsccmdi.editor.showIncomingCalls,
· key: shift+alt+h,
· when: callHierarchyVisible && callHierarchyDirection == 'outgoingCalls',
* McsEngl.Vsccmnd.editor.showIncomingCalls,

Vsccmdi.editor.showOutgoingCalls,
· key: shift+alt+h,
· when: callHierarchyVisible && callHierarchyDirection == 'incomingCalls',
* McsEngl.Vsccmnd.editor.showOutgoingCalls,

Vsccmdi.editor.showSubtypes,
· key: shift+alt+h,
· when: typeHierarchyVisible && typeHierarchyDirection == 'supertypes',
* McsEngl.Vsccmnd.editor.showSubtypes,

Vsccmdi.editor.showSupertypes,
· key: shift+alt+h,
· when: typeHierarchyVisible && typeHierarchyDirection == 'subtypes',
* McsEngl.Vsccmnd.editor.showSupertypes,

Vsccmdi.editor.showTypeHierarchy,
* McsEngl.Vsccmnd.editor.showTypeHierarchy,

Vsccmdi.editor.toggleFold,
· key: ctrl+k ctrl+l,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.toggleFold,

Vsccmdi.editor.toggleFoldRecursively,
· key: ctrl+k ctrl+shift+l,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.toggleFoldRecursively,

Vsccmdi.editor.toggleImportFold,
* McsEngl.Vsccmnd.editor.toggleImportFold,

Vsccmdi.editor.unfold,
· key: ctrl+shift+],
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.unfold,

Vsccmdi.editor.unfoldAll,
· key: ctrl+k ctrl+j,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.unfoldAll,

Vsccmdi.editor.unfoldAllExcept,
· key: ctrl+k ctrl+=,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.unfoldAllExcept,

Vsccmdi.editor.unfoldAllMarkerRegions,
· key: ctrl+k ctrl+9,
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.unfoldAllMarkerRegions,

Vsccmdi.editor.unfoldRecursively,
· key: ctrl+k ctrl+],
· when: editorTextFocus && foldingEnabled,
* McsEngl.Vsccmnd.editor.unfoldRecursively,

Vsccmdi.emmet.expandAbbreviation,
* McsEngl.Vsccmnd.emmet.expandAbbreviation,

Vsccmdi.eslint.applyAllFixes,
* McsEngl.Vsccmnd.eslint.applyAllFixes,

Vsccmdi.eslint.applyDisableFile,
* McsEngl.Vsccmnd.eslint.applyDisableFile,

Vsccmdi.eslint.applyDisableLine,
* McsEngl.Vsccmnd.eslint.applyDisableLine,

Vsccmdi.eslint.applySameFixes,
* McsEngl.Vsccmnd.eslint.applySameFixes,

Vsccmdi.eslint.applySingleFix,
* McsEngl.Vsccmnd.eslint.applySingleFix,

Vsccmdi.eslint.applySuggestion,
* McsEngl.Vsccmnd.eslint.applySuggestion,

Vsccmdi.eslint.createConfig,
* McsEngl.Vsccmnd.eslint.createConfig,

Vsccmdi.eslint.executeAutofix,
* McsEngl.Vsccmnd.eslint.executeAutofix,

Vsccmdi.eslint.migrateSettings,
* McsEngl.Vsccmnd.eslint.migrateSettings,

Vsccmdi.eslint.openRuleDoc,
* McsEngl.Vsccmnd.eslint.openRuleDoc,

Vsccmdi.eslint.restart,
* McsEngl.Vsccmnd.eslint.restart,

Vsccmdi.eslint.revalidate,
* McsEngl.Vsccmnd.eslint.revalidate,

Vsccmdi.eslint.showOutputChannel,
* McsEngl.Vsccmnd.eslint.showOutputChannel,

Vsccmdi.expandLineSelection,
· key: ctrl+l,
· when: textInputFocus,
* McsEngl.Vsccmnd.expandLineSelection,

Vsccmdi.expandSectionCodeAction,
· key: right,
· when: codeActionMenuVisible && !codeActionMenuFilterFocused,
* McsEngl.Vsccmnd.expandSectionCodeAction,

Vsccmdi.explorer.download,
* McsEngl.Vsccmnd.explorer.download,

Vsccmdi.explorer.newFile,
* McsEngl.Vsccmnd.explorer.newFile,

Vsccmdi.explorer.newFolder,
* McsEngl.Vsccmnd.explorer.newFolder,

Vsccmdi.explorer.openAndPassFocus,
· key: enter,
· when: filesExplorerFocus && foldersViewVisible && !explorerResourceIsFolder && !inputFocus,
* McsEngl.Vsccmnd.explorer.openAndPassFocus,

Vsccmdi.explorer.openToSide,
· key: ctrl+enter,
· when: explorerViewletFocus && foldersViewVisible && !inputFocus,
* McsEngl.Vsccmnd.explorer.openToSide,

Vsccmdi.explorer.openWith,
* McsEngl.Vsccmnd.explorer.openWith,

Vsccmdi.explorer.upload,
* McsEngl.Vsccmnd.explorer.upload,

Vsccmdi.extension.bisect.next,
* McsEngl.Vsccmnd.extension.bisect.next,

Vsccmdi.extension.bisect.start,
* McsEngl.Vsccmnd.extension.bisect.start,

Vsccmdi.extension.bisect.stop,
* McsEngl.Vsccmnd.extension.bisect.stop,

Vsccmdi.extension.charInsertInt,
· key: ctrl+alt+c i,
· when: editorTextFocus,
* McsEngl.Vsccmnd.extension.charInsertInt,

Vsccmdi.extension.htmlLtReplace,
* McsEngl.Vsccmnd.extension.htmlLtReplace,

Vsccmdi.extension.htmlTagInsert,
· key: ctrl+alt+h t,
· when: editorTextFocus,
* McsEngl.Vsccmnd.extension.htmlTagInsert,

Vsccmdi.extension.js-debug.addCustomBreakpoints,
* McsEngl.Vsccmnd.extension.js-debug.addCustomBreakpoints,

Vsccmdi.extension.js-debug.addXHRBreakpoints,
* McsEngl.Vsccmnd.extension.js-debug.addXHRBreakpoints,

Vsccmdi.extension.js-debug.callers.add,
* McsEngl.Vsccmnd.extension.js-debug.callers.add,

Vsccmdi.extension.js-debug.callers.goToCaller,
* McsEngl.Vsccmnd.extension.js-debug.callers.goToCaller,

Vsccmdi.extension.js-debug.callers.gotToTarget,
* McsEngl.Vsccmnd.extension.js-debug.callers.gotToTarget,

Vsccmdi.extension.js-debug.callers.remove,
* McsEngl.Vsccmnd.extension.js-debug.callers.remove,

Vsccmdi.extension.js-debug.callers.removeAll,
* McsEngl.Vsccmnd.extension.js-debug.callers.removeAll,

Vsccmdi.extension.js-debug.createDebuggerTerminal,
* McsEngl.Vsccmnd.extension.js-debug.createDebuggerTerminal,

Vsccmdi.extension.js-debug.createDiagnostics,
* McsEngl.Vsccmnd.extension.js-debug.createDiagnostics,

Vsccmdi.extension.js-debug.debugLink,
* McsEngl.Vsccmnd.extension.js-debug.debugLink,

Vsccmdi.extension.js-debug.disableSourceMapStepping,
* McsEngl.Vsccmnd.extension.js-debug.disableSourceMapStepping,

Vsccmdi.extension.js-debug.editXHRBreakpoints,
* McsEngl.Vsccmnd.extension.js-debug.editXHRBreakpoints,

Vsccmdi.extension.js-debug.enableSourceMapStepping,
* McsEngl.Vsccmnd.extension.js-debug.enableSourceMapStepping,

Vsccmdi.extension.js-debug.getDiagnosticLogs,
* McsEngl.Vsccmnd.extension.js-debug.getDiagnosticLogs,

Vsccmdi.extension.js-debug.network.clear,
* McsEngl.Vsccmnd.extension.js-debug.network.clear,

Vsccmdi.extension.js-debug.network.copyUri,
* McsEngl.Vsccmnd.extension.js-debug.network.copyUri,

Vsccmdi.extension.js-debug.network.openBody,
* McsEngl.Vsccmnd.extension.js-debug.network.openBody,

Vsccmdi.extension.js-debug.network.openBodyInHex,
* McsEngl.Vsccmnd.extension.js-debug.network.openBodyInHex,

Vsccmdi.extension.js-debug.network.replayXHR,
* McsEngl.Vsccmnd.extension.js-debug.network.replayXHR,

Vsccmdi.extension.js-debug.network.viewRequest,
* McsEngl.Vsccmnd.extension.js-debug.network.viewRequest,

Vsccmdi.extension.js-debug.npmScript,
* McsEngl.Vsccmnd.extension.js-debug.npmScript,

Vsccmdi.extension.js-debug.openEdgeDevTools,
* McsEngl.Vsccmnd.extension.js-debug.openEdgeDevTools,

Vsccmdi.extension.js-debug.prettyPrint,
* McsEngl.Vsccmnd.extension.js-debug.prettyPrint,

Vsccmdi.extension.js-debug.removeAllCustomBreakpoints,
* McsEngl.Vsccmnd.extension.js-debug.removeAllCustomBreakpoints,

Vsccmdi.extension.js-debug.removeXHRBreakpoint,
* McsEngl.Vsccmnd.extension.js-debug.removeXHRBreakpoint,

Vsccmdi.extension.js-debug.revealPage,
* McsEngl.Vsccmnd.extension.js-debug.revealPage,

Vsccmdi.extension.js-debug.startProfile,
* McsEngl.Vsccmnd.extension.js-debug.startProfile,

Vsccmdi.extension.js-debug.stopProfile,
* McsEngl.Vsccmnd.extension.js-debug.stopProfile,

Vsccmdi.extension.js-debug.toggleSkippingFile,
* McsEngl.Vsccmnd.extension.js-debug.toggleSkippingFile,

Vsccmdi.extension.jsProfileVisualizer.table.clearCodeLenses,
* McsEngl.Vsccmnd.extension.jsProfileVisualizer.table.clearCodeLenses,

Vsccmdi.extension.multiCommand.execute,
* McsEngl.Vsccmnd.extension.multiCommand.execute,

Vsccmdi.extension.node-debug.startWithStopOnEntry,
· key: f10,
· when: !inDebugMode && debugConfigurationType == 'node' || !inDebugMode && debugConfigurationType == 'pwa-extensionHost' || !inDebugMode && debugConfigurationType == 'pwa-node',
* McsEngl.Vsccmnd.extension.node-debug.startWithStopOnEntry,

Vsccmdi.extension.node-debug.startWithStopOnEntry,
· key: f11,
· when: !inDebugMode && activeViewlet == 'workbench.view.debug' && debugConfigurationType == 'node' || !inDebugMode && activeViewlet == 'workbench.view.debug' && debugConfigurationType == 'pwa-extensionHost' || !inDebugMode && activeViewlet == 'workbench.view.debug' && debugConfigurationType == 'pwa-node',
* McsEngl.Vsccmnd.extension.node-debug.startWithStopOnEntry,

Vsccmdi.extension.node-debug.toggleAutoAttach,
* McsEngl.Vsccmnd.extension.node-debug.toggleAutoAttach,

Vsccmdi.extension.open,
* McsEngl.Vsccmnd.extension.open,

Vsccmdi.extension.pwa-node-debug.attachNodeProcess,
* McsEngl.Vsccmnd.extension.pwa-node-debug.attachNodeProcess,

Vsccmdi.extension.userInput,
· inserts user text and selects it.
· key: ctrl+alt+t,
· when: editorTextFocus,
* McsEngl.Vsccmnd.extension.userInput,

Vsccmdi.extensions.actions.searchByCategory.AI,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.AI,

Vsccmdi.extensions.actions.searchByCategory.Azure,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Azure,

Vsccmdi.extensions.actions.searchByCategory.Chat,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Chat,

Vsccmdi.extensions.actions.searchByCategory.Data Science,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Data Science,

Vsccmdi.extensions.actions.searchByCategory.Debuggers,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Debuggers,

Vsccmdi.extensions.actions.searchByCategory.Education,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Education,

Vsccmdi.extensions.actions.searchByCategory.Extension Packs,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Extension Packs,

Vsccmdi.extensions.actions.searchByCategory.Formatters,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Formatters,

Vsccmdi.extensions.actions.searchByCategory.Keymaps,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Keymaps,

Vsccmdi.extensions.actions.searchByCategory.Language Packs,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Language Packs,

Vsccmdi.extensions.actions.searchByCategory.Linters,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Linters,

Vsccmdi.extensions.actions.searchByCategory.Machine Learning,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Machine Learning,

Vsccmdi.extensions.actions.searchByCategory.Notebooks,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Notebooks,

Vsccmdi.extensions.actions.searchByCategory.Other,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Other,

Vsccmdi.extensions.actions.searchByCategory.Programming Languages,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Programming Languages,

Vsccmdi.extensions.actions.searchByCategory.SCM Providers,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.SCM Providers,

Vsccmdi.extensions.actions.searchByCategory.Snippets,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Snippets,

Vsccmdi.extensions.actions.searchByCategory.Testing,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Testing,

Vsccmdi.extensions.actions.searchByCategory.Themes,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Themes,

Vsccmdi.extensions.actions.searchByCategory.Visualization,
* McsEngl.Vsccmnd.extensions.actions.searchByCategory.Visualization,

Vsccmdi.extensions.filter.featured,
* McsEngl.Vsccmnd.extensions.filter.featured,

Vsccmdi.extensions.recommendedList.focus,
* McsEngl.Vsccmnd.extensions.recommendedList.focus,

Vsccmdi.extensions.recommendedList.resetViewLocation,
* McsEngl.Vsccmnd.extensions.recommendedList.resetViewLocation,

Vsccmdi.extensions.sort.installs,
* McsEngl.Vsccmnd.extensions.sort.installs,

Vsccmdi.extensions.sort.name,
* McsEngl.Vsccmnd.extensions.sort.name,

Vsccmdi.extensions.sort.publishedDate,
* McsEngl.Vsccmnd.extensions.sort.publishedDate,

Vsccmdi.extensions.sort.rating,
* McsEngl.Vsccmnd.extensions.sort.rating,

Vsccmdi.extensions.sort.updateDate,
* McsEngl.Vsccmnd.extensions.sort.updateDate,

Vsccmdi.files.openTimeline,
* McsEngl.Vsccmnd.files.openTimeline,

Vsccmdi.files.participants.resetChoice,
* McsEngl.Vsccmnd.files.participants.resetChoice,

Vsccmdi.filesExplorer.cancelCut,
· key: escape,
· when: explorerResourceCut && filesExplorerFocus && foldersViewVisible && !inputFocus,
* McsEngl.Vsccmnd.filesExplorer.cancelCut,

Vsccmdi.filesExplorer.copy,
· key: ctrl+c,
· when: filesExplorerFocus && foldersViewVisible && !explorerResourceIsRoot && !inputFocus,
* McsEngl.Vsccmnd.filesExplorer.copy,

Vsccmdi.filesExplorer.cut,
· key: ctrl+x,
· when: filesExplorerFocus && foldersViewVisible && !explorerResourceIsRoot && !explorerResourceReadonly && !inputFocus,
* McsEngl.Vsccmnd.filesExplorer.cut,

Vsccmdi.filesExplorer.findInFolder,
· key: shift+alt+f,
· when: explorerResourceIsFolder && filesExplorerFocus && foldersViewVisible && !inputFocus,
* McsEngl.Vsccmnd.filesExplorer.findInFolder,

Vsccmdi.filesExplorer.findInWorkspace,
* McsEngl.Vsccmnd.filesExplorer.findInWorkspace,

Vsccmdi.filesExplorer.openFilePreserveFocus,
· key: space,
· when: filesExplorerFocus && foldersViewVisible && !explorerResourceIsFolder && !inputFocus,
* McsEngl.Vsccmnd.filesExplorer.openFilePreserveFocus,

Vsccmdi.filesExplorer.paste,
· key: ctrl+v,
· when: filesExplorerFocus && foldersViewVisible && !explorerResourceReadonly && !inputFocus,
* McsEngl.Vsccmnd.filesExplorer.paste,

Vsccmdi.firstCompressedFolder,
· key: home,
· when: explorerViewletCompressedFocus && filesExplorerFocus && foldersViewVisible && !explorerViewletCompressedFirstFocus && !inputFocus,
* McsEngl.Vsccmnd.firstCompressedFolder,

Vsccmdi.focusAndAcceptSuggestion,
* McsEngl.Vsccmnd.focusAndAcceptSuggestion,

Vsccmdi.focusNextRenameSuggestion,
· key: down,
· when: renameInputVisible,
* McsEngl.Vsccmnd.focusNextRenameSuggestion,

Vsccmdi.focusPreviousRenameSuggestion,
· key: up,
· when: renameInputVisible,
* McsEngl.Vsccmnd.focusPreviousRenameSuggestion,

Vsccmdi.focusSuggestion,
· key: ctrl+i,
· when: suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
* McsEngl.Vsccmnd.focusSuggestion,

Vsccmdi.focusSuggestion,
· key: ctrl+space,
· when: suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
* McsEngl.Vsccmnd.focusSuggestion,

Vsccmdi.getContextKeyInfo,
* McsEngl.Vsccmnd.getContextKeyInfo,

Vsccmdi.git-base.api.getRemoteSources,
* McsEngl.Vsccmnd.git-base.api.getRemoteSources,

Vsccmdi.git._syncAll,
* McsEngl.Vsccmnd.git._syncAll,

Vsccmdi.git.acceptMerge,
* McsEngl.Vsccmnd.git.acceptMerge,

Vsccmdi.git.addRemote,
* McsEngl.Vsccmnd.git.addRemote,

Vsccmdi.git.api.getRemoteSources,
* McsEngl.Vsccmnd.git.api.getRemoteSources,

Vsccmdi.git.api.getRepositories,
* McsEngl.Vsccmnd.git.api.getRepositories,

Vsccmdi.git.api.getRepositoryState,
* McsEngl.Vsccmnd.git.api.getRepositoryState,

Vsccmdi.git.blame.toggleEditorDecoration,
* McsEngl.Vsccmnd.git.blame.toggleEditorDecoration,

Vsccmdi.git.blame.toggleStatusBarItem,
* McsEngl.Vsccmnd.git.blame.toggleStatusBarItem,

Vsccmdi.git.branch,
* McsEngl.Vsccmnd.git.branch,

Vsccmdi.git.branchFrom,
* McsEngl.Vsccmnd.git.branchFrom,

Vsccmdi.git.checkout,
* McsEngl.Vsccmnd.git.checkout,

Vsccmdi.git.checkoutDetached,
* McsEngl.Vsccmnd.git.checkoutDetached,

Vsccmdi.git.cherryPick,
* McsEngl.Vsccmnd.git.cherryPick,

Vsccmdi.git.cherryPickAbort,
* McsEngl.Vsccmnd.git.cherryPickAbort,

Vsccmdi.git.clean,
* McsEngl.Vsccmnd.git.clean,

Vsccmdi.git.cleanAll,
* McsEngl.Vsccmnd.git.cleanAll,

Vsccmdi.git.cleanAllTracked,
* McsEngl.Vsccmnd.git.cleanAllTracked,

Vsccmdi.git.cleanAllUntracked,
* McsEngl.Vsccmnd.git.cleanAllUntracked,

Vsccmdi.git.clone,
* McsEngl.Vsccmnd.git.clone,

Vsccmdi.git.cloneRecursive,
* McsEngl.Vsccmnd.git.cloneRecursive,

Vsccmdi.git.close,
* McsEngl.Vsccmnd.git.close,

Vsccmdi.git.closeAllDiffEditors,
* McsEngl.Vsccmnd.git.closeAllDiffEditors,

Vsccmdi.git.closeAllUnmodifiedEditors,
* McsEngl.Vsccmnd.git.closeAllUnmodifiedEditors,

Vsccmdi.git.closeOtherRepositories,
* McsEngl.Vsccmnd.git.closeOtherRepositories,

Vsccmdi.git.commit,
* McsEngl.Vsccmnd.git.commit,

Vsccmdi.git.commitAll,
* McsEngl.Vsccmnd.git.commitAll,

Vsccmdi.git.commitAllAmend,
* McsEngl.Vsccmnd.git.commitAllAmend,

Vsccmdi.git.commitAllAmendNoVerify,
* McsEngl.Vsccmnd.git.commitAllAmendNoVerify,

Vsccmdi.git.commitAllNoVerify,
* McsEngl.Vsccmnd.git.commitAllNoVerify,

Vsccmdi.git.commitAllSigned,
* McsEngl.Vsccmnd.git.commitAllSigned,

Vsccmdi.git.commitAllSignedNoVerify,
* McsEngl.Vsccmnd.git.commitAllSignedNoVerify,

Vsccmdi.git.commitAmend,
* McsEngl.Vsccmnd.git.commitAmend,

Vsccmdi.git.commitAmendNoVerify,
* McsEngl.Vsccmnd.git.commitAmendNoVerify,

Vsccmdi.git.commitEmpty,
* McsEngl.Vsccmnd.git.commitEmpty,

Vsccmdi.git.commitEmptyNoVerify,
* McsEngl.Vsccmnd.git.commitEmptyNoVerify,

Vsccmdi.git.commitMessageAccept,
* McsEngl.Vsccmnd.git.commitMessageAccept,

Vsccmdi.git.commitMessageDiscard,
* McsEngl.Vsccmnd.git.commitMessageDiscard,

Vsccmdi.git.commitNoVerify,
* McsEngl.Vsccmnd.git.commitNoVerify,

Vsccmdi.git.commitSigned,
* McsEngl.Vsccmnd.git.commitSigned,

Vsccmdi.git.commitSignedNoVerify,
* McsEngl.Vsccmnd.git.commitSignedNoVerify,

Vsccmdi.git.commitStaged,
* McsEngl.Vsccmnd.git.commitStaged,

Vsccmdi.git.commitStagedAmend,
* McsEngl.Vsccmnd.git.commitStagedAmend,

Vsccmdi.git.commitStagedAmendNoVerify,
* McsEngl.Vsccmnd.git.commitStagedAmendNoVerify,

Vsccmdi.git.commitStagedNoVerify,
* McsEngl.Vsccmnd.git.commitStagedNoVerify,

Vsccmdi.git.commitStagedSigned,
* McsEngl.Vsccmnd.git.commitStagedSigned,

Vsccmdi.git.commitStagedSignedNoVerify,
* McsEngl.Vsccmnd.git.commitStagedSignedNoVerify,

Vsccmdi.git.compareWithWorkspace,
* McsEngl.Vsccmnd.git.compareWithWorkspace,

Vsccmdi.git.continueInLocalClone,
* McsEngl.Vsccmnd.git.continueInLocalClone,

Vsccmdi.git.copyCommitId,
* McsEngl.Vsccmnd.git.copyCommitId,

Vsccmdi.git.copyCommitMessage,
* McsEngl.Vsccmnd.git.copyCommitMessage,

Vsccmdi.git.copyContentToClipboard,
* McsEngl.Vsccmnd.git.copyContentToClipboard,

Vsccmdi.git.createTag,
* McsEngl.Vsccmnd.git.createTag,

Vsccmdi.git.createWorktree,
* McsEngl.Vsccmnd.git.createWorktree,

Vsccmdi.git.delete,
* McsEngl.Vsccmnd.git.delete,

Vsccmdi.git.deleteBranch,
* McsEngl.Vsccmnd.git.deleteBranch,

Vsccmdi.git.deleteRemoteBranch,
* McsEngl.Vsccmnd.git.deleteRemoteBranch,

Vsccmdi.git.deleteRemoteTag,
* McsEngl.Vsccmnd.git.deleteRemoteTag,

Vsccmdi.git.deleteTag,
* McsEngl.Vsccmnd.git.deleteTag,

Vsccmdi.git.deleteWorktree,
* McsEngl.Vsccmnd.git.deleteWorktree,

Vsccmdi.git.deleteWorktree2,
* McsEngl.Vsccmnd.git.deleteWorktree2,

Vsccmdi.git.diff.stageHunk,
* McsEngl.Vsccmnd.git.diff.stageHunk,

Vsccmdi.git.diff.stageSelection,
* McsEngl.Vsccmnd.git.diff.stageSelection,

Vsccmdi.git.fetch,
* McsEngl.Vsccmnd.git.fetch,

Vsccmdi.git.fetchAll,
* McsEngl.Vsccmnd.git.fetchAll,

Vsccmdi.git.fetchPrune,
* McsEngl.Vsccmnd.git.fetchPrune,

Vsccmdi.git.fetchRef,
* McsEngl.Vsccmnd.git.fetchRef,

Vsccmdi.git.graph.checkout,
* McsEngl.Vsccmnd.git.graph.checkout,

Vsccmdi.git.graph.checkoutDetached,
* McsEngl.Vsccmnd.git.graph.checkoutDetached,

Vsccmdi.git.graph.cherryPick,
* McsEngl.Vsccmnd.git.graph.cherryPick,

Vsccmdi.git.graph.compareRef,
* McsEngl.Vsccmnd.git.graph.compareRef,

Vsccmdi.git.graph.compareWithMergeBase,
* McsEngl.Vsccmnd.git.graph.compareWithMergeBase,

Vsccmdi.git.graph.compareWithRemote,
* McsEngl.Vsccmnd.git.graph.compareWithRemote,

Vsccmdi.git.graph.deleteBranch,
* McsEngl.Vsccmnd.git.graph.deleteBranch,

Vsccmdi.git.graph.deleteTag,
* McsEngl.Vsccmnd.git.graph.deleteTag,

Vsccmdi.git.ignore,
* McsEngl.Vsccmnd.git.ignore,

Vsccmdi.git.init,
* McsEngl.Vsccmnd.git.init,

Vsccmdi.git.manageUnsafeRepositories,
* McsEngl.Vsccmnd.git.manageUnsafeRepositories,

Vsccmdi.git.merge,
* McsEngl.Vsccmnd.git.merge,

Vsccmdi.git.mergeAbort,
* McsEngl.Vsccmnd.git.mergeAbort,

Vsccmdi.git.migrateWorktreeChanges,
* McsEngl.Vsccmnd.git.migrateWorktreeChanges,

Vsccmdi.git.openAllChanges,
* McsEngl.Vsccmnd.git.openAllChanges,

Vsccmdi.git.openChange,
* McsEngl.Vsccmnd.git.openChange,

Vsccmdi.git.openFile,
* McsEngl.Vsccmnd.git.openFile,

Vsccmdi.git.openFile2,
* McsEngl.Vsccmnd.git.openFile2,

Vsccmdi.git.openHEADFile,
* McsEngl.Vsccmnd.git.openHEADFile,

Vsccmdi.git.openMergeEditor,
* McsEngl.Vsccmnd.git.openMergeEditor,

Vsccmdi.git.openRepositoriesInParentFolders,
* McsEngl.Vsccmnd.git.openRepositoriesInParentFolders,

Vsccmdi.git.openRepository,
* McsEngl.Vsccmnd.git.openRepository,

Vsccmdi.git.openResource,
* McsEngl.Vsccmnd.git.openResource,

Vsccmdi.git.openWorktree,
* McsEngl.Vsccmnd.git.openWorktree,

Vsccmdi.git.openWorktreeInNewWindow,
* McsEngl.Vsccmnd.git.openWorktreeInNewWindow,

Vsccmdi.git.openWorktreeMergeEditor,
* McsEngl.Vsccmnd.git.openWorktreeMergeEditor,

Vsccmdi.git.publish,
* McsEngl.Vsccmnd.git.publish,

Vsccmdi.git.pull,
* McsEngl.Vsccmnd.git.pull,

Vsccmdi.git.pullFrom,
* McsEngl.Vsccmnd.git.pullFrom,

Vsccmdi.git.pullRebase,
* McsEngl.Vsccmnd.git.pullRebase,

Vsccmdi.git.pullRef,
* McsEngl.Vsccmnd.git.pullRef,

Vsccmdi.git.push,
* McsEngl.Vsccmnd.git.push,

Vsccmdi.git.pushForce,
* McsEngl.Vsccmnd.git.pushForce,

Vsccmdi.git.pushRef,
* McsEngl.Vsccmnd.git.pushRef,

Vsccmdi.git.pushTags,
* McsEngl.Vsccmnd.git.pushTags,

Vsccmdi.git.pushTo,
* McsEngl.Vsccmnd.git.pushTo,

Vsccmdi.git.pushToForce,
* McsEngl.Vsccmnd.git.pushToForce,

Vsccmdi.git.pushWithTags,
* McsEngl.Vsccmnd.git.pushWithTags,

Vsccmdi.git.pushWithTagsForce,
* McsEngl.Vsccmnd.git.pushWithTagsForce,

Vsccmdi.git.rebase,
* McsEngl.Vsccmnd.git.rebase,

Vsccmdi.git.rebaseAbort,
* McsEngl.Vsccmnd.git.rebaseAbort,

Vsccmdi.git.refresh,
* McsEngl.Vsccmnd.git.refresh,

Vsccmdi.git.removeRemote,
* McsEngl.Vsccmnd.git.removeRemote,

Vsccmdi.git.rename,
* McsEngl.Vsccmnd.git.rename,

Vsccmdi.git.renameBranch,
* McsEngl.Vsccmnd.git.renameBranch,

Vsccmdi.git.reopenClosedRepositories,
* McsEngl.Vsccmnd.git.reopenClosedRepositories,

Vsccmdi.git.repositories.checkout,
* McsEngl.Vsccmnd.git.repositories.checkout,

Vsccmdi.git.repositories.checkoutDetached,
* McsEngl.Vsccmnd.git.repositories.checkoutDetached,

Vsccmdi.git.repositories.compareRef,
* McsEngl.Vsccmnd.git.repositories.compareRef,

Vsccmdi.git.repositories.copyBranchName,
* McsEngl.Vsccmnd.git.repositories.copyBranchName,

Vsccmdi.git.repositories.copyCommitHash,
* McsEngl.Vsccmnd.git.repositories.copyCommitHash,

Vsccmdi.git.repositories.copyStashName,
* McsEngl.Vsccmnd.git.repositories.copyStashName,

Vsccmdi.git.repositories.copyTagName,
* McsEngl.Vsccmnd.git.repositories.copyTagName,

Vsccmdi.git.repositories.createBranch,
* McsEngl.Vsccmnd.git.repositories.createBranch,

Vsccmdi.git.repositories.createFrom,
* McsEngl.Vsccmnd.git.repositories.createFrom,

Vsccmdi.git.repositories.createTag,
* McsEngl.Vsccmnd.git.repositories.createTag,

Vsccmdi.git.repositories.createWorktree,
* McsEngl.Vsccmnd.git.repositories.createWorktree,

Vsccmdi.git.repositories.deleteBranch,
* McsEngl.Vsccmnd.git.repositories.deleteBranch,

Vsccmdi.git.repositories.deleteTag,
* McsEngl.Vsccmnd.git.repositories.deleteTag,

Vsccmdi.git.repositories.deleteWorktree,
* McsEngl.Vsccmnd.git.repositories.deleteWorktree,

Vsccmdi.git.repositories.merge,
* McsEngl.Vsccmnd.git.repositories.merge,

Vsccmdi.git.repositories.openWorktree,
* McsEngl.Vsccmnd.git.repositories.openWorktree,

Vsccmdi.git.repositories.openWorktreeInNewWindow,
* McsEngl.Vsccmnd.git.repositories.openWorktreeInNewWindow,

Vsccmdi.git.repositories.rebase,
* McsEngl.Vsccmnd.git.repositories.rebase,

Vsccmdi.git.repositories.stashApply,
* McsEngl.Vsccmnd.git.repositories.stashApply,

Vsccmdi.git.repositories.stashCopyBranchName,
* McsEngl.Vsccmnd.git.repositories.stashCopyBranchName,

Vsccmdi.git.repositories.stashDrop,
* McsEngl.Vsccmnd.git.repositories.stashDrop,

Vsccmdi.git.repositories.stashPop,
* McsEngl.Vsccmnd.git.repositories.stashPop,

Vsccmdi.git.repositories.stashView,
* McsEngl.Vsccmnd.git.repositories.stashView,

Vsccmdi.git.repositories.worktreeCopyBranchName,
* McsEngl.Vsccmnd.git.repositories.worktreeCopyBranchName,

Vsccmdi.git.repositories.worktreeCopyCommitHash,
* McsEngl.Vsccmnd.git.repositories.worktreeCopyCommitHash,

Vsccmdi.git.repositories.worktreeCopyPath,
* McsEngl.Vsccmnd.git.repositories.worktreeCopyPath,

Vsccmdi.git.restoreCommitTemplate,
* McsEngl.Vsccmnd.git.restoreCommitTemplate,

Vsccmdi.git.revealFileInOS.linux,
* McsEngl.Vsccmnd.git.revealFileInOS.linux,

Vsccmdi.git.revealFileInOS.mac,
* McsEngl.Vsccmnd.git.revealFileInOS.mac,

Vsccmdi.git.revealFileInOS.windows,
* McsEngl.Vsccmnd.git.revealFileInOS.windows,

Vsccmdi.git.revealInExplorer,
* McsEngl.Vsccmnd.git.revealInExplorer,

Vsccmdi.git.revertChange,
* McsEngl.Vsccmnd.git.revertChange,

Vsccmdi.git.revertSelectedRanges,
· key: ctrl+k ctrl+r,
· when: editorTextFocus && !operationInProgress && resourceScheme == 'file',
* McsEngl.Vsccmnd.git.revertSelectedRanges,

Vsccmdi.git.runGitMerge,
* McsEngl.Vsccmnd.git.runGitMerge,

Vsccmdi.git.runGitMergeDiff3,
* McsEngl.Vsccmnd.git.runGitMergeDiff3,

Vsccmdi.git.showOutput,
* McsEngl.Vsccmnd.git.showOutput,

Vsccmdi.git.stage,
* McsEngl.Vsccmnd.git.stage,

Vsccmdi.git.stageAll,
* McsEngl.Vsccmnd.git.stageAll,

Vsccmdi.git.stageAllMerge,
* McsEngl.Vsccmnd.git.stageAllMerge,

Vsccmdi.git.stageAllTracked,
* McsEngl.Vsccmnd.git.stageAllTracked,

Vsccmdi.git.stageAllUntracked,
* McsEngl.Vsccmnd.git.stageAllUntracked,

Vsccmdi.git.stageChange,
* McsEngl.Vsccmnd.git.stageChange,

Vsccmdi.git.stageFile,
* McsEngl.Vsccmnd.git.stageFile,

Vsccmdi.git.stageSelectedRanges,
· key: ctrl+k ctrl+alt+s,
· when: editorTextFocus && !operationInProgress && resourceScheme == 'file',
* McsEngl.Vsccmnd.git.stageSelectedRanges,

Vsccmdi.git.stash,
* McsEngl.Vsccmnd.git.stash,

Vsccmdi.git.stashApply,
* McsEngl.Vsccmnd.git.stashApply,

Vsccmdi.git.stashApplyEditor,
* McsEngl.Vsccmnd.git.stashApplyEditor,

Vsccmdi.git.stashApplyLatest,
* McsEngl.Vsccmnd.git.stashApplyLatest,

Vsccmdi.git.stashDrop,
* McsEngl.Vsccmnd.git.stashDrop,

Vsccmdi.git.stashDropAll,
* McsEngl.Vsccmnd.git.stashDropAll,

Vsccmdi.git.stashDropEditor,
* McsEngl.Vsccmnd.git.stashDropEditor,

Vsccmdi.git.stashIncludeUntracked,
* McsEngl.Vsccmnd.git.stashIncludeUntracked,

Vsccmdi.git.stashPop,
* McsEngl.Vsccmnd.git.stashPop,

Vsccmdi.git.stashPopEditor,
* McsEngl.Vsccmnd.git.stashPopEditor,

Vsccmdi.git.stashPopLatest,
* McsEngl.Vsccmnd.git.stashPopLatest,

Vsccmdi.git.stashStaged,
* McsEngl.Vsccmnd.git.stashStaged,

Vsccmdi.git.stashView,
* McsEngl.Vsccmnd.git.stashView,

Vsccmdi.git.sync,
* McsEngl.Vsccmnd.git.sync,

Vsccmdi.git.syncRebase,
* McsEngl.Vsccmnd.git.syncRebase,

Vsccmdi.git.timeline.compareWithSelected,
* McsEngl.Vsccmnd.git.timeline.compareWithSelected,

Vsccmdi.git.timeline.copyCommitId,
* McsEngl.Vsccmnd.git.timeline.copyCommitId,

Vsccmdi.git.timeline.copyCommitMessage,
* McsEngl.Vsccmnd.git.timeline.copyCommitMessage,

Vsccmdi.git.timeline.openDiff,
* McsEngl.Vsccmnd.git.timeline.openDiff,

Vsccmdi.git.timeline.selectForCompare,
* McsEngl.Vsccmnd.git.timeline.selectForCompare,

Vsccmdi.git.timeline.viewCommit,
* McsEngl.Vsccmnd.git.timeline.viewCommit,

Vsccmdi.git.undoCommit,
* McsEngl.Vsccmnd.git.undoCommit,

Vsccmdi.git.unstage,
* McsEngl.Vsccmnd.git.unstage,

Vsccmdi.git.unstageAll,
* McsEngl.Vsccmnd.git.unstageAll,

Vsccmdi.git.unstageChange,
* McsEngl.Vsccmnd.git.unstageChange,

Vsccmdi.git.unstageFile,
* McsEngl.Vsccmnd.git.unstageFile,

Vsccmdi.git.unstageSelectedRanges,
· key: ctrl+k ctrl+n,
· when: editorTextFocus && isInDiffEditor && isInDiffRightEditor && !operationInProgress && resourceScheme == 'git',
* McsEngl.Vsccmnd.git.unstageSelectedRanges,

Vsccmdi.git.viewChanges,
* McsEngl.Vsccmnd.git.viewChanges,

Vsccmdi.git.viewCommit,
* McsEngl.Vsccmnd.git.viewCommit,

Vsccmdi.git.viewStagedChanges,
* McsEngl.Vsccmnd.git.viewStagedChanges,

Vsccmdi.git.viewUntrackedChanges,
* McsEngl.Vsccmnd.git.viewUntrackedChanges,

Vsccmdi.github.copilot.acceptCursorPanelSolution,
* McsEngl.Vsccmnd.github.copilot.acceptCursorPanelSolution,

Vsccmdi.github.copilot.buildRemoteWorkspaceIndex,
* McsEngl.Vsccmnd.github.copilot.buildRemoteWorkspaceIndex,

Vsccmdi.github.copilot.chat.applyCopilotCLIAgentSessionChanges,
* McsEngl.Vsccmnd.github.copilot.chat.applyCopilotCLIAgentSessionChanges,

Vsccmdi.github.copilot.chat.applyCopilotCLIAgentSessionChanges.apply,
* McsEngl.Vsccmnd.github.copilot.chat.applyCopilotCLIAgentSessionChanges.apply,

Vsccmdi.github.copilot.chat.attachFile,
* McsEngl.Vsccmnd.github.copilot.chat.attachFile,

Vsccmdi.github.copilot.chat.attachSelection,
* McsEngl.Vsccmnd.github.copilot.chat.attachSelection,

Vsccmdi.github.copilot.chat.checkoutPullRequestReroute,
* McsEngl.Vsccmnd.github.copilot.chat.checkoutPullRequestReroute,

Vsccmdi.github.copilot.chat.clearTemporalContext,
* McsEngl.Vsccmnd.github.copilot.chat.clearTemporalContext,

Vsccmdi.github.copilot.chat.cloudSessions.clearCaches,
* McsEngl.Vsccmnd.github.copilot.chat.cloudSessions.clearCaches,

Vsccmdi.github.copilot.chat.cloudSessions.openRepository,
* McsEngl.Vsccmnd.github.copilot.chat.cloudSessions.openRepository,

Vsccmdi.github.copilot.chat.codeReview.run,
* McsEngl.Vsccmnd.github.copilot.chat.codeReview.run,

Vsccmdi.github.copilot.chat.compact,
* McsEngl.Vsccmnd.github.copilot.chat.compact,

Vsccmdi.github.copilot.chat.completions.disable,
* McsEngl.Vsccmnd.github.copilot.chat.completions.disable,

Vsccmdi.github.copilot.chat.completions.enable,
* McsEngl.Vsccmnd.github.copilot.chat.completions.enable,

Vsccmdi.github.copilot.chat.completions.toggle,
* McsEngl.Vsccmnd.github.copilot.chat.completions.toggle,

Vsccmdi.github.copilot.chat.copilotCLI.acceptDiff,
* McsEngl.Vsccmnd.github.copilot.chat.copilotCLI.acceptDiff,

Vsccmdi.github.copilot.chat.copilotCLI.addFileReference,
· key: ctrl+shift+.,
· when: editorTextFocus && github.copilot.chat.copilotCLI.hasSession,
* McsEngl.Vsccmnd.github.copilot.chat.copilotCLI.addFileReference,

Vsccmdi.github.copilot.chat.copilotCLI.addSelection,
* McsEngl.Vsccmnd.github.copilot.chat.copilotCLI.addSelection,

Vsccmdi.github.copilot.chat.copilotCLI.rejectDiff,
* McsEngl.Vsccmnd.github.copilot.chat.copilotCLI.rejectDiff,

Vsccmdi.github.copilot.chat.createDraftPullRequestCopilotCLIAgentSession.createDraftPR,
* McsEngl.Vsccmnd.github.copilot.chat.createDraftPullRequestCopilotCLIAgentSession.createDraftPR,

Vsccmdi.github.copilot.chat.createPullRequestCopilotCLIAgentSession.createPR,
* McsEngl.Vsccmnd.github.copilot.chat.createPullRequestCopilotCLIAgentSession.createPR,

Vsccmdi.github.copilot.chat.createPullRequestCopilotCLIAgentSession.updatePR,
* McsEngl.Vsccmnd.github.copilot.chat.createPullRequestCopilotCLIAgentSession.updatePR,

Vsccmdi.github.copilot.chat.debug.exportAllPromptLogsAsJson,
* McsEngl.Vsccmnd.github.copilot.chat.debug.exportAllPromptLogsAsJson,

Vsccmdi.github.copilot.chat.debug.exportLogItem,
* McsEngl.Vsccmnd.github.copilot.chat.debug.exportLogItem,

Vsccmdi.github.copilot.chat.debug.exportPromptArchive,
* McsEngl.Vsccmnd.github.copilot.chat.debug.exportPromptArchive,

Vsccmdi.github.copilot.chat.debug.exportPromptLogsAsJson,
* McsEngl.Vsccmnd.github.copilot.chat.debug.exportPromptLogsAsJson,

Vsccmdi.github.copilot.chat.debug.hideElements,
* McsEngl.Vsccmnd.github.copilot.chat.debug.hideElements,

Vsccmdi.github.copilot.chat.debug.hideGhostRequests,
* McsEngl.Vsccmnd.github.copilot.chat.debug.hideGhostRequests,

Vsccmdi.github.copilot.chat.debug.hideNesRequests,
* McsEngl.Vsccmnd.github.copilot.chat.debug.hideNesRequests,

Vsccmdi.github.copilot.chat.debug.hideTools,
* McsEngl.Vsccmnd.github.copilot.chat.debug.hideTools,

Vsccmdi.github.copilot.chat.debug.saveCurrentMarkdown,
* McsEngl.Vsccmnd.github.copilot.chat.debug.saveCurrentMarkdown,

Vsccmdi.github.copilot.chat.debug.showElements,
* McsEngl.Vsccmnd.github.copilot.chat.debug.showElements,

Vsccmdi.github.copilot.chat.debug.showGhostRequests,
* McsEngl.Vsccmnd.github.copilot.chat.debug.showGhostRequests,

Vsccmdi.github.copilot.chat.debug.showNesRequests,
* McsEngl.Vsccmnd.github.copilot.chat.debug.showNesRequests,

Vsccmdi.github.copilot.chat.debug.showRawRequestBody,
* McsEngl.Vsccmnd.github.copilot.chat.debug.showRawRequestBody,

Vsccmdi.github.copilot.chat.debug.showTools,
* McsEngl.Vsccmnd.github.copilot.chat.debug.showTools,

Vsccmdi.github.copilot.chat.explain,
* McsEngl.Vsccmnd.github.copilot.chat.explain,

Vsccmdi.github.copilot.chat.explain.palette,
* McsEngl.Vsccmnd.github.copilot.chat.explain.palette,

Vsccmdi.github.copilot.chat.fix,
* McsEngl.Vsccmnd.github.copilot.chat.fix,

Vsccmdi.github.copilot.chat.generate,
* McsEngl.Vsccmnd.github.copilot.chat.generate,

Vsccmdi.github.copilot.chat.generateAltText,
* McsEngl.Vsccmnd.github.copilot.chat.generateAltText,

Vsccmdi.github.copilot.chat.mcp.setup.check,
* McsEngl.Vsccmnd.github.copilot.chat.mcp.setup.check,

Vsccmdi.github.copilot.chat.mcp.setup.flow,
* McsEngl.Vsccmnd.github.copilot.chat.mcp.setup.flow,

Vsccmdi.github.copilot.chat.mcp.setup.validatePackage,
* McsEngl.Vsccmnd.github.copilot.chat.mcp.setup.validatePackage,

Vsccmdi.github.copilot.chat.mergeCopilotCLIAgentSessionChanges.merge,
* McsEngl.Vsccmnd.github.copilot.chat.mergeCopilotCLIAgentSessionChanges.merge,

Vsccmdi.github.copilot.chat.mergeCopilotCLIAgentSessionChanges.mergeAndSync,
* McsEngl.Vsccmnd.github.copilot.chat.mergeCopilotCLIAgentSessionChanges.mergeAndSync,

Vsccmdi.github.copilot.chat.notebook.disableFollowCellExecution,
* McsEngl.Vsccmnd.github.copilot.chat.notebook.disableFollowCellExecution,

Vsccmdi.github.copilot.chat.notebook.enableFollowCellExecution,
* McsEngl.Vsccmnd.github.copilot.chat.notebook.enableFollowCellExecution,

Vsccmdi.github.copilot.chat.openModelPicker,
* McsEngl.Vsccmnd.github.copilot.chat.openModelPicker,

Vsccmdi.github.copilot.chat.openPullRequestCopilotCLIAgentSession.openPR,
* McsEngl.Vsccmnd.github.copilot.chat.openPullRequestCopilotCLIAgentSession.openPR,

Vsccmdi.github.copilot.chat.openPullRequestReroute,
* McsEngl.Vsccmnd.github.copilot.chat.openPullRequestReroute,

Vsccmdi.github.copilot.chat.openSuggestionsPanel,
* McsEngl.Vsccmnd.github.copilot.chat.openSuggestionsPanel,

Vsccmdi.github.copilot.chat.openUserPreferences,
* McsEngl.Vsccmnd.github.copilot.chat.openUserPreferences,

Vsccmdi.github.copilot.chat.otel.exportAgentTracesDB,
* McsEngl.Vsccmnd.github.copilot.chat.otel.exportAgentTracesDB,

Vsccmdi.github.copilot.chat.otel.flush,
* McsEngl.Vsccmnd.github.copilot.chat.otel.flush,

Vsccmdi.github.copilot.chat.replay,
* McsEngl.Vsccmnd.github.copilot.chat.replay,

Vsccmdi.github.copilot.chat.replay.disableWorkspaceEditTracing,
* McsEngl.Vsccmnd.github.copilot.chat.replay.disableWorkspaceEditTracing,

Vsccmdi.github.copilot.chat.replay.enableWorkspaceEditTracing,
* McsEngl.Vsccmnd.github.copilot.chat.replay.enableWorkspaceEditTracing,

Vsccmdi.github.copilot.chat.rerunWithCopilotDebug,
· key: ctrl+alt+.,
· when: github.copilot-chat.activated && terminalFocus && terminalShellIntegrationEnabled && !terminalAltBufferActive,
* McsEngl.Vsccmnd.github.copilot.chat.rerunWithCopilotDebug,

Vsccmdi.github.copilot.chat.review,
* McsEngl.Vsccmnd.github.copilot.chat.review,

Vsccmdi.github.copilot.chat.review.apply,
* McsEngl.Vsccmnd.github.copilot.chat.review.apply,

Vsccmdi.github.copilot.chat.review.applyAndNext,
* McsEngl.Vsccmnd.github.copilot.chat.review.applyAndNext,

Vsccmdi.github.copilot.chat.review.applyShort,
* McsEngl.Vsccmnd.github.copilot.chat.review.applyShort,

Vsccmdi.github.copilot.chat.review.changes,
* McsEngl.Vsccmnd.github.copilot.chat.review.changes,

Vsccmdi.github.copilot.chat.review.continueInChat,
* McsEngl.Vsccmnd.github.copilot.chat.review.continueInChat,

Vsccmdi.github.copilot.chat.review.continueInInlineChat,
* McsEngl.Vsccmnd.github.copilot.chat.review.continueInInlineChat,

Vsccmdi.github.copilot.chat.review.current,
* McsEngl.Vsccmnd.github.copilot.chat.review.current,

Vsccmdi.github.copilot.chat.review.discard,
* McsEngl.Vsccmnd.github.copilot.chat.review.discard,

Vsccmdi.github.copilot.chat.review.discardAll,
* McsEngl.Vsccmnd.github.copilot.chat.review.discardAll,

Vsccmdi.github.copilot.chat.review.discardAndNext,
* McsEngl.Vsccmnd.github.copilot.chat.review.discardAndNext,

Vsccmdi.github.copilot.chat.review.discardShort,
* McsEngl.Vsccmnd.github.copilot.chat.review.discardShort,

Vsccmdi.github.copilot.chat.review.markHelpful,
* McsEngl.Vsccmnd.github.copilot.chat.review.markHelpful,

Vsccmdi.github.copilot.chat.review.markUnhelpful,
* McsEngl.Vsccmnd.github.copilot.chat.review.markUnhelpful,

Vsccmdi.github.copilot.chat.review.next,
* McsEngl.Vsccmnd.github.copilot.chat.review.next,

Vsccmdi.github.copilot.chat.review.previous,
* McsEngl.Vsccmnd.github.copilot.chat.review.previous,

Vsccmdi.github.copilot.chat.review.stagedChanges,
* McsEngl.Vsccmnd.github.copilot.chat.review.stagedChanges,

Vsccmdi.github.copilot.chat.review.stagedFileChange,
* McsEngl.Vsccmnd.github.copilot.chat.review.stagedFileChange,

Vsccmdi.github.copilot.chat.review.unstagedChanges,
* McsEngl.Vsccmnd.github.copilot.chat.review.unstagedChanges,

Vsccmdi.github.copilot.chat.review.unstagedFileChange,
* McsEngl.Vsccmnd.github.copilot.chat.review.unstagedFileChange,

Vsccmdi.github.copilot.chat.sendCompletionFeedback,
* McsEngl.Vsccmnd.github.copilot.chat.sendCompletionFeedback,

Vsccmdi.github.copilot.chat.showAsChatSession,
* McsEngl.Vsccmnd.github.copilot.chat.showAsChatSession,

Vsccmdi.github.copilot.chat.startCopilotDebugCommand,
* McsEngl.Vsccmnd.github.copilot.chat.startCopilotDebugCommand,

Vsccmdi.github.copilot.chat.toggleStatusMenu,
* McsEngl.Vsccmnd.github.copilot.chat.toggleStatusMenu,

Vsccmdi.github.copilot.chat.tools.memory.clearMemories,
* McsEngl.Vsccmnd.github.copilot.chat.tools.memory.clearMemories,

Vsccmdi.github.copilot.chat.tools.memory.showMemories,
* McsEngl.Vsccmnd.github.copilot.chat.tools.memory.showMemories,

Vsccmdi.github.copilot.chat.triggerPermissiveSignIn,
* McsEngl.Vsccmnd.github.copilot.chat.triggerPermissiveSignIn,

Vsccmdi.github.copilot.chat.updateCopilotCLIAgentSessionChanges.update,
* McsEngl.Vsccmnd.github.copilot.chat.updateCopilotCLIAgentSessionChanges.update,

Vsccmdi.github.copilot.claude.sessions.rename,
* McsEngl.Vsccmnd.github.copilot.claude.sessions.rename,

Vsccmdi.github.copilot.cli.newSession,
* McsEngl.Vsccmnd.github.copilot.cli.newSession,

Vsccmdi.github.copilot.cli.newSessionToSide,
* McsEngl.Vsccmnd.github.copilot.cli.newSessionToSide,

Vsccmdi.github.copilot.cli.openInCopilotCLI,
* McsEngl.Vsccmnd.github.copilot.cli.openInCopilotCLI,

Vsccmdi.github.copilot.cli.sessions.commitToRepository,
* McsEngl.Vsccmnd.github.copilot.cli.sessions.commitToRepository,

Vsccmdi.github.copilot.cli.sessions.commitToWorktree,
* McsEngl.Vsccmnd.github.copilot.cli.sessions.commitToWorktree,

Vsccmdi.github.copilot.cli.sessions.copyWorktreeBranchName,
* McsEngl.Vsccmnd.github.copilot.cli.sessions.copyWorktreeBranchName,

Vsccmdi.github.copilot.cli.sessions.delete,
* McsEngl.Vsccmnd.github.copilot.cli.sessions.delete,

Vsccmdi.github.copilot.cli.sessions.openRepository,
* McsEngl.Vsccmnd.github.copilot.cli.sessions.openRepository,

Vsccmdi.github.copilot.cli.sessions.openWorktreeInNewWindow,
* McsEngl.Vsccmnd.github.copilot.cli.sessions.openWorktreeInNewWindow,

Vsccmdi.github.copilot.cli.sessions.openWorktreeInTerminal,
* McsEngl.Vsccmnd.github.copilot.cli.sessions.openWorktreeInTerminal,

Vsccmdi.github.copilot.cli.sessions.rename,
* McsEngl.Vsccmnd.github.copilot.cli.sessions.rename,

Vsccmdi.github.copilot.cli.sessions.resumeInTerminal,
* McsEngl.Vsccmnd.github.copilot.cli.sessions.resumeInTerminal,

Vsccmdi.github.copilot.cli.sessions.setTitle,
* McsEngl.Vsccmnd.github.copilot.cli.sessions.setTitle,

Vsccmdi.github.copilot.cloud.resetWorkspaceConfirmations,
* McsEngl.Vsccmnd.github.copilot.cloud.resetWorkspaceConfirmations,

Vsccmdi.github.copilot.cloud.sessions.installPRExtension,
* McsEngl.Vsccmnd.github.copilot.cloud.sessions.installPRExtension,

Vsccmdi.github.copilot.cloud.sessions.openInBrowser,
* McsEngl.Vsccmnd.github.copilot.cloud.sessions.openInBrowser,

Vsccmdi.github.copilot.cloud.sessions.proxy.closeChatSessionPullRequest,
* McsEngl.Vsccmnd.github.copilot.cloud.sessions.proxy.closeChatSessionPullRequest,

Vsccmdi.github.copilot.completions.disable,
* McsEngl.Vsccmnd.github.copilot.completions.disable,

Vsccmdi.github.copilot.completions.enable,
* McsEngl.Vsccmnd.github.copilot.completions.enable,

Vsccmdi.github.copilot.completions.toggle,
* McsEngl.Vsccmnd.github.copilot.completions.toggle,

Vsccmdi.github.copilot.createFile,
* McsEngl.Vsccmnd.github.copilot.createFile,

Vsccmdi.github.copilot.createLaunchJsonFileWithContents,
* McsEngl.Vsccmnd.github.copilot.createLaunchJsonFileWithContents,

Vsccmdi.github.copilot.createProject,
* McsEngl.Vsccmnd.github.copilot.createProject,

Vsccmdi.github.copilot.debug.collectDiagnostics,
* McsEngl.Vsccmnd.github.copilot.debug.collectDiagnostics,

Vsccmdi.github.copilot.debug.collectDiagnostics.internal,
* McsEngl.Vsccmnd.github.copilot.debug.collectDiagnostics.internal,

Vsccmdi.github.copilot.debug.collectWorkspaceIndexDiagnostics,
* McsEngl.Vsccmnd.github.copilot.debug.collectWorkspaceIndexDiagnostics,

Vsccmdi.github.copilot.debug.extensionState,
* McsEngl.Vsccmnd.github.copilot.debug.extensionState,

Vsccmdi.github.copilot.debug.generateInlineEditTests,
* McsEngl.Vsccmnd.github.copilot.debug.generateInlineEditTests,

Vsccmdi.github.copilot.debug.generateSTest,
* McsEngl.Vsccmnd.github.copilot.debug.generateSTest,

Vsccmdi.github.copilot.debug.inlineEdit.clearCache,
* McsEngl.Vsccmnd.github.copilot.debug.inlineEdit.clearCache,

Vsccmdi.github.copilot.debug.inlineEdit.learnMore,
* McsEngl.Vsccmnd.github.copilot.debug.inlineEdit.learnMore,

Vsccmdi.github.copilot.debug.inlineEdit.pickProvider,
* McsEngl.Vsccmnd.github.copilot.debug.inlineEdit.pickProvider,

Vsccmdi.github.copilot.debug.inlineEdit.reportFeedback,
* McsEngl.Vsccmnd.github.copilot.debug.inlineEdit.reportFeedback,

Vsccmdi.github.copilot.debug.inlineEdit.reportNotebookNESIssue,
* McsEngl.Vsccmnd.github.copilot.debug.inlineEdit.reportNotebookNESIssue,

Vsccmdi.github.copilot.debug.resetVirtualToolGroups,
* McsEngl.Vsccmnd.github.copilot.debug.resetVirtualToolGroups,

Vsccmdi.github.copilot.debug.showChatLogView,
* McsEngl.Vsccmnd.github.copilot.debug.showChatLogView,

Vsccmdi.github.copilot.debug.showContextInspectorView,
* McsEngl.Vsccmnd.github.copilot.debug.showContextInspectorView,

Vsccmdi.github.copilot.debug.showNodeSystemCertificatesErrors,
* McsEngl.Vsccmnd.github.copilot.debug.showNodeSystemCertificatesErrors,

Vsccmdi.github.copilot.debug.showOutputChannel,
* McsEngl.Vsccmnd.github.copilot.debug.showOutputChannel,

Vsccmdi.github.copilot.debug.showOutputChannel.internal,
* McsEngl.Vsccmnd.github.copilot.debug.showOutputChannel.internal,

Vsccmdi.github.copilot.debug.togglePowerSaveBlocker,
* McsEngl.Vsccmnd.github.copilot.debug.togglePowerSaveBlocker,

Vsccmdi.github.copilot.debug.validateNesRename,
* McsEngl.Vsccmnd.github.copilot.debug.validateNesRename,

Vsccmdi.github.copilot.debug.workbenchState,
* McsEngl.Vsccmnd.github.copilot.debug.workbenchState,

Vsccmdi.github.copilot.deleteExternalIngestWorkspaceIndex,
* McsEngl.Vsccmnd.github.copilot.deleteExternalIngestWorkspaceIndex,

Vsccmdi.github.copilot.devcontainer.generateDevContainerConfig,
* McsEngl.Vsccmnd.github.copilot.devcontainer.generateDevContainerConfig,

Vsccmdi.github.copilot.executeSearch,
* McsEngl.Vsccmnd.github.copilot.executeSearch,

Vsccmdi.github.copilot.generate,
* McsEngl.Vsccmnd.github.copilot.generate,

Vsccmdi.github.copilot.git.generateCommitMessage,
* McsEngl.Vsccmnd.github.copilot.git.generateCommitMessage,

Vsccmdi.github.copilot.git.resolveMergeConflicts,
* McsEngl.Vsccmnd.github.copilot.git.resolveMergeConflicts,

Vsccmdi.github.copilot.interactiveSession.feedback,
* McsEngl.Vsccmnd.github.copilot.interactiveSession.feedback,

Vsccmdi.github.copilot.mcp.viewContext7,
* McsEngl.Vsccmnd.github.copilot.mcp.viewContext7,

Vsccmdi.github.copilot.nes.captureExpected.abort,
· key: escape,
· when: copilotNesCaptureMode && editorTextFocus,
* McsEngl.Vsccmnd.github.copilot.nes.captureExpected.abort,

Vsccmdi.github.copilot.nes.captureExpected.confirm,
· key: ctrl+enter,
· when: copilotNesCaptureMode && editorTextFocus,
* McsEngl.Vsccmnd.github.copilot.nes.captureExpected.confirm,

Vsccmdi.github.copilot.nes.captureExpected.start,
* McsEngl.Vsccmnd.github.copilot.nes.captureExpected.start,

Vsccmdi.github.copilot.nes.captureExpected.submit,
* McsEngl.Vsccmnd.github.copilot.nes.captureExpected.submit,

Vsccmdi.github.copilot.nes.postRename,
* McsEngl.Vsccmnd.github.copilot.nes.postRename,

Vsccmdi.github.copilot.nes.prepareRename,
* McsEngl.Vsccmnd.github.copilot.nes.prepareRename,

Vsccmdi.github.copilot.nextPanelSolution,
* McsEngl.Vsccmnd.github.copilot.nextPanelSolution,

Vsccmdi.github.copilot.open.walkthrough,
* McsEngl.Vsccmnd.github.copilot.open.walkthrough,

Vsccmdi.github.copilot.openDocs,
* McsEngl.Vsccmnd.github.copilot.openDocs,

Vsccmdi.github.copilot.openFile,
* McsEngl.Vsccmnd.github.copilot.openFile,

Vsccmdi.github.copilot.openLogs,
* McsEngl.Vsccmnd.github.copilot.openLogs,

Vsccmdi.github.copilot.openModelPicker,
* McsEngl.Vsccmnd.github.copilot.openModelPicker,

Vsccmdi.github.copilot.previousPanelSolution,
* McsEngl.Vsccmnd.github.copilot.previousPanelSolution,

Vsccmdi.github.copilot.refreshToken,
* McsEngl.Vsccmnd.github.copilot.refreshToken,

Vsccmdi.github.copilot.report,
* McsEngl.Vsccmnd.github.copilot.report,

Vsccmdi.github.copilot.search.feedback,
* McsEngl.Vsccmnd.github.copilot.search.feedback,

Vsccmdi.github.copilot.search.markHelpful,
* McsEngl.Vsccmnd.github.copilot.search.markHelpful,

Vsccmdi.github.copilot.search.markUnhelpful,
* McsEngl.Vsccmnd.github.copilot.search.markUnhelpful,

Vsccmdi.github.copilot.sessions.commitChanges,
* McsEngl.Vsccmnd.github.copilot.sessions.commitChanges,

Vsccmdi.github.copilot.sessions.discardChanges,
* McsEngl.Vsccmnd.github.copilot.sessions.discardChanges,

Vsccmdi.github.copilot.sessions.refreshChanges,
* McsEngl.Vsccmnd.github.copilot.sessions.refreshChanges,

Vsccmdi.github.copilot.startDebugging,
* McsEngl.Vsccmnd.github.copilot.startDebugging,

Vsccmdi.github.copilot.survey.signalUsage,
* McsEngl.Vsccmnd.github.copilot.survey.signalUsage,

Vsccmdi.github.copilot.terminal.explainTerminalLastCommand,
* McsEngl.Vsccmnd.github.copilot.terminal.explainTerminalLastCommand,

Vsccmdi.github.copilot.terminal.fixTerminalLastCommand,
* McsEngl.Vsccmnd.github.copilot.terminal.fixTerminalLastCommand,

Vsccmdi.github.copilot.terminal.generateCommitMessage,
* McsEngl.Vsccmnd.github.copilot.terminal.generateCommitMessage,

Vsccmdi.github.copilot.tests.applyMutations,
* McsEngl.Vsccmnd.github.copilot.tests.applyMutations,

Vsccmdi.github.copilot.tests.fixTestFailure,
* McsEngl.Vsccmnd.github.copilot.tests.fixTestFailure,

Vsccmdi.github.copilot.tests.fixTestFailure.fromInline,
* McsEngl.Vsccmnd.github.copilot.tests.fixTestFailure.fromInline,

Vsccmdi.github.copilot.toggleStatusMenu,
* McsEngl.Vsccmnd.github.copilot.toggleStatusMenu,

Vsccmdi.github.copyVscodeDevLink,
* McsEngl.Vsccmnd.github.copyVscodeDevLink,

Vsccmdi.github.copyVscodeDevLinkFile,
* McsEngl.Vsccmnd.github.copyVscodeDevLinkFile,

Vsccmdi.github.copyVscodeDevLinkWithoutRange,
* McsEngl.Vsccmnd.github.copyVscodeDevLinkWithoutRange,

Vsccmdi.github.createPullRequest,
* McsEngl.Vsccmnd.github.createPullRequest,

Vsccmdi.github.graph.openOnGitHub,
* McsEngl.Vsccmnd.github.graph.openOnGitHub,

Vsccmdi.github.openOnGitHub,
* McsEngl.Vsccmnd.github.openOnGitHub,

Vsccmdi.github.openOnVscodeDev,
* McsEngl.Vsccmnd.github.openOnVscodeDev,

Vsccmdi.github.openPullRequest,
* McsEngl.Vsccmnd.github.openPullRequest,

Vsccmdi.github.publish,
* McsEngl.Vsccmnd.github.publish,

Vsccmdi.github.timeline.openOnGitHub,
* McsEngl.Vsccmnd.github.timeline.openOnGitHub,

Vsccmdi.goToNextReference,
· key: f4,
· when: inReferenceSearchEditor || referenceSearchVisible,
* McsEngl.Vsccmnd.goToNextReference,

Vsccmdi.goToNextReference,
· key: f12,
· when: inReferenceSearchEditor || referenceSearchVisible,
* McsEngl.Vsccmnd.goToNextReference,

Vsccmdi.goToNextReferenceFromEmbeddedEditor,
* McsEngl.Vsccmnd.goToNextReferenceFromEmbeddedEditor,

Vsccmdi.goToPreviousReference,
· key: shift+f4,
· when: inReferenceSearchEditor || referenceSearchVisible,
* McsEngl.Vsccmnd.goToPreviousReference,

Vsccmdi.goToPreviousReference,
· key: shift+f12,
· when: inReferenceSearchEditor || referenceSearchVisible,
* McsEngl.Vsccmnd.goToPreviousReference,

Vsccmdi.goToPreviousReferenceFromEmbeddedEditor,
* McsEngl.Vsccmnd.goToPreviousReferenceFromEmbeddedEditor,

Vsccmdi.hideCodeActionWidget,
· key: escape,
· when: codeActionMenuVisible && kb-macro.active,
* McsEngl.Vsccmnd.hideCodeActionWidget,

Vsccmdi.hideCodeActionWidget,
· key: escape,
· when: codeActionMenuVisible,
* McsEngl.Vsccmnd.hideCodeActionWidget,

Vsccmdi.hideCodeActionWidget,
· key: shift+escape,
· when: codeActionMenuVisible && kb-macro.active,
* McsEngl.Vsccmnd.hideCodeActionWidget,

Vsccmdi.hideCodeActionWidget,
· key: shift+escape,
· when: codeActionMenuVisible,
* McsEngl.Vsccmnd.hideCodeActionWidget,

Vsccmdi.hideCustomTitleBar,
* McsEngl.Vsccmnd.hideCustomTitleBar,

Vsccmdi.hideCustomTitleBarInFullScreen,
* McsEngl.Vsccmnd.hideCustomTitleBarInFullScreen,

Vsccmdi.hideSuggestWidget,
· key: escape,
· when: suggestWidgetVisible && textInputFocus,
* McsEngl.Vsccmnd.hideSuggestWidget,

Vsccmdi.hideSuggestWidget,
· key: shift+escape,
· when: suggestWidgetVisible && textInputFocus,
* McsEngl.Vsccmnd.hideSuggestWidget,

Vsccmdi.history.showNext,
· key: alt+down,
· when: historyNavigationForwardsEnabled && historyNavigationWidgetFocus && !isComposing && !suggestWidgetVisible,
* McsEngl.Vsccmnd.history.showNext,

Vsccmdi.history.showNext,
· key: down,
· when: historyNavigationForwardsEnabled && historyNavigationWidgetFocus && !isComposing && !suggestWidgetVisible,
* McsEngl.Vsccmnd.history.showNext,

Vsccmdi.history.showPrevious,
· key: alt+up,
· when: historyNavigationBackwardsEnabled && historyNavigationWidgetFocus && !isComposing && !suggestWidgetVisible,
* McsEngl.Vsccmnd.history.showPrevious,

Vsccmdi.history.showPrevious,
· key: up,
· when: historyNavigationBackwardsEnabled && historyNavigationWidgetFocus && !isComposing && !suggestWidgetVisible,
* McsEngl.Vsccmnd.history.showPrevious,

Vsccmdi.iconSelectBox.focusDown,
· key: down,
· when: iconSelectBoxFocus,
* McsEngl.Vsccmnd.iconSelectBox.focusDown,

Vsccmdi.iconSelectBox.focusNext,
· key: right,
· when: iconSelectBoxFocus && iconSelectBoxInputEmpty || iconSelectBoxFocus && !iconSelectBoxInputFocus,
* McsEngl.Vsccmnd.iconSelectBox.focusNext,

Vsccmdi.iconSelectBox.focusPrevious,
· key: left,
· when: iconSelectBoxFocus && iconSelectBoxInputEmpty || iconSelectBoxFocus && !iconSelectBoxInputFocus,
* McsEngl.Vsccmnd.iconSelectBox.focusPrevious,

Vsccmdi.iconSelectBox.focusUp,
· key: up,
· when: iconSelectBoxFocus,
* McsEngl.Vsccmnd.iconSelectBox.focusUp,

Vsccmdi.iconSelectBox.selectFocused,
· key: enter,
· when: iconSelectBoxFocus,
* McsEngl.Vsccmnd.iconSelectBox.selectFocused,

Vsccmdi.imagePreview.copyImage,
* McsEngl.Vsccmnd.imagePreview.copyImage,

Vsccmdi.imagePreview.reopenAsPreview,
* McsEngl.Vsccmnd.imagePreview.reopenAsPreview,

Vsccmdi.imagePreview.reopenAsText,
* McsEngl.Vsccmnd.imagePreview.reopenAsText,

Vsccmdi.imagePreview.zoomIn,
* McsEngl.Vsccmnd.imagePreview.zoomIn,

Vsccmdi.imagePreview.zoomOut,
* McsEngl.Vsccmnd.imagePreview.zoomOut,

Vsccmdi.increaseSearchEditorContextLines,
· key: alt+=,
· when: inSearchEditor,
* McsEngl.Vsccmnd.increaseSearchEditorContextLines,

Vsccmdi.inlayHints.startReadingLineWithHint,
* McsEngl.Vsccmnd.inlayHints.startReadingLineWithHint,

Vsccmdi.inlayHints.stopReadingLineWithHint,
· key: escape,
· when: isReadingLineWithInlayHints,
* McsEngl.Vsccmnd.inlayHints.stopReadingLineWithHint,

Vsccmdi.inlineChat.askInChat,
· key: ctrl+i,
· when: config.inlineChat.askInChat && editorFocus && inlineChatFileBelongsToChat && inlineChatHasEditsAgent && inlineChatPossible && !editorReadonly && !editorSimpleInput || config.inlineChat.askInChat && editorFocus && inlineChatFileBelongsToChat && inlineChatHasNotebookAgent && inlineChatPossible && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || config.inlineChat.askInChat && editorFocus && inlineChatFileBelongsToChat && inlineChatHasNotebookInline && inlineChatPossible && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook',
* McsEngl.Vsccmnd.inlineChat.askInChat,

Vsccmdi.inlineChat.dismissEditorAffordance,
· key: escape,
· when: editorTextFocus && inlineChatAffordanceVisible && config.inlineChat.affordance == 'editor',
* McsEngl.Vsccmnd.inlineChat.dismissEditorAffordance,

Vsccmdi.inlineChat.fixDiagnostics,
* McsEngl.Vsccmnd.inlineChat.fixDiagnostics,

Vsccmdi.inlineChat.focus,
· key: ctrl+down,
· when: editorTextFocus && inlineChatVisible && !accessibilityModeEnabled && !inlineChatFocused && !isEmbeddedDiffEditor && inlineChatOuterCursorPosition == 'above',
* McsEngl.Vsccmnd.inlineChat.focus,

Vsccmdi.inlineChat.focus,
· key: ctrl+up,
· when: editorTextFocus && inlineChatVisible && !accessibilityModeEnabled && !inlineChatFocused && !isEmbeddedDiffEditor && inlineChatOuterCursorPosition == 'below',
* McsEngl.Vsccmnd.inlineChat.focus,

Vsccmdi.inlineChat.hideInput,
· key: escape,
· when: inlineChatHasEditsAgent && inlineChatInputWidgetFocused || inlineChatHasNotebookAgent && inlineChatInputWidgetFocused && activeEditor == 'workbench.editor.notebook',
* McsEngl.Vsccmnd.inlineChat.hideInput,

Vsccmdi.inlineChat.queueInChat,
· key: enter,
· when: config.inlineChat.askInChat && inlineChatFileBelongsToChat && inlineChatHasEditsAgent && inlineChatInputHasText && inlineChatInputWidgetFocused || config.inlineChat.askInChat && inlineChatFileBelongsToChat && inlineChatHasNotebookAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && activeEditor == 'workbench.editor.notebook',
* McsEngl.Vsccmnd.inlineChat.queueInChat,

Vsccmdi.inlineChat.resetMoveToPanelChatChoice,
* McsEngl.Vsccmnd.inlineChat.resetMoveToPanelChatChoice,

Vsccmdi.inlineChat.start,
· key: ctrl+i,
· when: editorFocus && inlineChatHasEditsAgent && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput || editorFocus && inlineChatHasEditsAgent && inlineChatPossible && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat || editorFocus && inlineChatHasEditsAgent && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat || editorFocus && inlineChatHasNotebookAgent && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatPossible && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookInline && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookInline && inlineChatPossible && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookAgent && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookAgent && inlineChatPossible && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookInline && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookInline && inlineChatPossible && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatHasNotebookInline && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatHasNotebookInline && inlineChatPossible && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookInline && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookAgent && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookInline && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatHasNotebookInline && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook',
* McsEngl.Vsccmnd.inlineChat.start,

Vsccmdi.inlineChat.submitInput,
· key: enter,
· when: inlineChatHasEditsAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && !config.inlineChat.askInChat || inlineChatHasEditsAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && !inlineChatFileBelongsToChat || inlineChatHasEditsAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && !config.inlineChat.askInChat && !inlineChatFileBelongsToChat || inlineChatHasNotebookAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && !config.inlineChat.askInChat && activeEditor == 'workbench.editor.notebook' || inlineChatHasNotebookAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || inlineChatHasNotebookAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && !config.inlineChat.askInChat && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook',
* McsEngl.Vsccmnd.inlineChat.submitInput,

Vsccmdi.inlineChat2.cancel,
· key: escape,
· when: chatEdits.isRequestInProgress && chatInputHasFocus && inlineChatHasEditsAgent && inlineChatVisible || chatEdits.isRequestInProgress && editorFocus && inlineChatHasEditsAgent && inlineChatVisible || chatEdits.isRequestInProgress && chatInputHasFocus && inlineChatHasNotebookAgent && inlineChatVisible && activeEditor == 'workbench.editor.notebook' || chatEdits.isRequestInProgress && editorFocus && inlineChatHasNotebookAgent && inlineChatVisible && activeEditor == 'workbench.editor.notebook',
* McsEngl.Vsccmnd.inlineChat2.cancel,

Vsccmdi.inlineChat2.close,
· key: escape,
· when: chatInputHasFocus && inlineChatHasEditsAgent && inlineChatVisible || chatInputHasFocus && inlineChatHasNotebookAgent && inlineChatVisible && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatVisible && !chatEdits.hasEditorModifications || editorFocus && inlineChatHasNotebookAgent && inlineChatVisible && !chatEdits.hasEditorModifications && activeEditor == 'workbench.editor.notebook',
* McsEngl.Vsccmnd.inlineChat2.close,

Vsccmdi.inlineChat2.continueInChat,
* McsEngl.Vsccmnd.inlineChat2.continueInChat,

Vsccmdi.inlineChat2.keep,
· key: ctrl+enter,
· when: chatEdits.hasEditorModifications && inlineChatHasEditsAgent && inlineChatVisible && !chatEdits.isRequestInProgress || chatEdits.hasEditorModifications && inlineChatHasNotebookAgent && inlineChatVisible && !chatEdits.isRequestInProgress && activeEditor == 'workbench.editor.notebook',
* McsEngl.Vsccmnd.inlineChat2.keep,

Vsccmdi.inlineChat2.keep,
· key: enter,
· when: chatEdits.hasEditorModifications && chatInputHasFocus && inlineChatHasEditsAgent && inlineChatVisible && !chatEdits.isRequestInProgress && !chatInputHasText || chatEdits.hasEditorModifications && chatInputHasFocus && inlineChatHasNotebookAgent && inlineChatVisible && !chatEdits.isRequestInProgress && !chatInputHasText && activeEditor == 'workbench.editor.notebook',
* McsEngl.Vsccmnd.inlineChat2.keep,

Vsccmdi.inlineChat2.rephrase,
* McsEngl.Vsccmnd.inlineChat2.rephrase,

Vsccmdi.inlineChat2.undo,
· key: escape,
· when: chatInputHasFocus && inlineChatHasEditsAgent && inlineChatVisible && config.inlineChat.renderMode == 'hover' || chatInputHasFocus && inlineChatHasNotebookAgent && inlineChatVisible && activeEditor == 'workbench.editor.notebook' && config.inlineChat.renderMode == 'hover' || editorFocus && inlineChatHasEditsAgent && inlineChatVisible && !chatEdits.hasEditorModifications && config.inlineChat.renderMode == 'hover' || editorFocus && inlineChatHasNotebookAgent && inlineChatVisible && !chatEdits.hasEditorModifications && activeEditor == 'workbench.editor.notebook' && config.inlineChat.renderMode == 'hover',
* McsEngl.Vsccmnd.inlineChat2.undo,

Vsccmdi.insertBestCompletion,
· key: tab,
· when: atEndOfWord && textInputFocus && !hasOtherSuggestions && !inSnippetMode && !suggestWidgetVisible && config.editor.tabCompletion == 'on',
* McsEngl.Vsccmnd.insertBestCompletion,

Vsccmdi.insertNextSuggestion,
· key: tab,
· when: hasOtherSuggestions && textInputFocus && !inSnippetMode && !suggestWidgetVisible && config.editor.tabCompletion == 'on',
* McsEngl.Vsccmnd.insertNextSuggestion,

Vsccmdi.insertPrevSuggestion,
· key: shift+tab,
· when: hasOtherSuggestions && textInputFocus && !inSnippetMode && !suggestWidgetVisible && config.editor.tabCompletion == 'on',
* McsEngl.Vsccmnd.insertPrevSuggestion,

Vsccmdi.insertSnippet,
· key: tab,
· when: editorTextFocus && hasSnippetCompletions && !editorTabMovesFocus && !inSnippetMode,
* McsEngl.Vsccmnd.insertSnippet,

Vsccmdi.interactive.acceptChanges,
* McsEngl.Vsccmnd.interactive.acceptChanges,

Vsccmdi.interactive.execute,
· key: ctrl+enter,
· when: isCompositeNotebook && activeEditor == 'workbench.editor.interactive',
* McsEngl.Vsccmnd.interactive.execute,

Vsccmdi.interactive.execute,
· key: enter,
· when: isCompositeNotebook && !config.interactiveWindow.executeWithShiftEnter && activeEditor == 'workbench.editor.interactive',
* McsEngl.Vsccmnd.interactive.execute,

Vsccmdi.interactive.execute,
· key: shift+enter,
· when: config.interactiveWindow.executeWithShiftEnter && isCompositeNotebook && activeEditor == 'workbench.editor.interactive',
* McsEngl.Vsccmnd.interactive.execute,

Vsccmdi.interactive.history.focus,
· key: ctrl+up,
· when: isCompositeNotebook && !notebookEditorFocused && interactiveInputCursorAtBoundary != 'bottom' && interactiveInputCursorAtBoundary != 'none',
* McsEngl.Vsccmnd.interactive.history.focus,

Vsccmdi.interactive.history.focus,
· key: ctrl+up,
· when: isCompositeNotebook && isLinux && !notebookEditorFocused || isCompositeNotebook && isWindows && !notebookEditorFocused,
* McsEngl.Vsccmnd.interactive.history.focus,

Vsccmdi.interactive.history.next,
· key: down,
· when: isCompositeNotebook && !notebookEditorFocused && !suggestWidgetVisible && interactiveInputCursorAtBoundary != 'none' && interactiveInputCursorAtBoundary != 'top',
* McsEngl.Vsccmnd.interactive.history.next,

Vsccmdi.interactive.history.previous,
· key: up,
· when: isCompositeNotebook && !notebookEditorFocused && !suggestWidgetVisible && interactiveInputCursorAtBoundary != 'bottom' && interactiveInputCursorAtBoundary != 'none',
* McsEngl.Vsccmnd.interactive.history.previous,

Vsccmdi.interactive.input.clear,
* McsEngl.Vsccmnd.interactive.input.clear,

Vsccmdi.interactive.input.focus,
* McsEngl.Vsccmnd.interactive.input.focus,

Vsccmdi.interactive.scrollToBottom,
· key: ctrl+end,
· when: activeEditor == 'workbench.editor.interactive',
* McsEngl.Vsccmnd.interactive.scrollToBottom,

Vsccmdi.interactive.scrollToTop,
· key: ctrl+home,
· when: activeEditor == 'workbench.editor.interactive',
* McsEngl.Vsccmnd.interactive.scrollToTop,

Vsccmdi.interactiveEditor.start,
* McsEngl.Vsccmnd.interactiveEditor.start,

Vsccmdi.ipynb.cleanInvalidImageAttachment,
* McsEngl.Vsccmnd.ipynb.cleanInvalidImageAttachment,

Vsccmdi.ipynb.newUntitledIpynb,
* McsEngl.Vsccmnd.ipynb.newUntitledIpynb,

Vsccmdi.ipynb.openIpynbInNotebookEditor,
* McsEngl.Vsccmnd.ipynb.openIpynbInNotebookEditor,

Vsccmdi.javascript.goToProjectConfig,
* McsEngl.Vsccmnd.javascript.goToProjectConfig,

Vsccmdi.javascript.reloadProjects,
* McsEngl.Vsccmnd.javascript.reloadProjects,

Vsccmdi.javascript.removeUnusedImports,
* McsEngl.Vsccmnd.javascript.removeUnusedImports,

Vsccmdi.javascript.sortImports,
* McsEngl.Vsccmnd.javascript.sortImports,

Vsccmdi.jsBrowserBreakpoints.focus,
* McsEngl.Vsccmnd.jsBrowserBreakpoints.focus,

Vsccmdi.jsBrowserBreakpoints.resetViewLocation,
* McsEngl.Vsccmnd.jsBrowserBreakpoints.resetViewLocation,

Vsccmdi.jsDebugNetworkTree.focus,
* McsEngl.Vsccmnd.jsDebugNetworkTree.focus,

Vsccmdi.jsDebugNetworkTree.resetViewLocation,
* McsEngl.Vsccmnd.jsDebugNetworkTree.resetViewLocation,

Vsccmdi.jsExcludedCallers.focus,
* McsEngl.Vsccmnd.jsExcludedCallers.focus,

Vsccmdi.jsExcludedCallers.resetViewLocation,
* McsEngl.Vsccmnd.jsExcludedCallers.resetViewLocation,

Vsccmdi.json.clearCache,
* McsEngl.Vsccmnd.json.clearCache,

Vsccmdi.json.sort,
* McsEngl.Vsccmnd.json.sort,

Vsccmdi.json.validate,
* McsEngl.Vsccmnd.json.validate,

Vsccmdi.jumpToNextSnippetPlaceholder,
· key: tab,
· when: hasNextTabstop && inSnippetMode && textInputFocus,
* McsEngl.Vsccmnd.jumpToNextSnippetPlaceholder,

Vsccmdi.jumpToPrevSnippetPlaceholder,
· key: shift+tab,
· when: hasPrevTabstop && inSnippetMode && textInputFocus,
* McsEngl.Vsccmnd.jumpToPrevSnippetPlaceholder,

Vsccmdi.jumpToSchema,
* McsEngl.Vsccmnd.jumpToSchema,

Vsccmdi.kb-macro.abortPlayback,
· key: escape,
· when: kb-macro.playing,
* McsEngl.Vsccmnd.kb-macro.abortPlayback,

Vsccmdi.kb-macro.cancelRecording,
· key: ctrl+alt+p,
· when: kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option1',
* McsEngl.Vsccmnd.kb-macro.cancelRecording,

Vsccmdi.kb-macro.cancelRecording,
· key: ctrl+shift+alt+p,
· when: kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option2',
* McsEngl.Vsccmnd.kb-macro.cancelRecording,

Vsccmdi.kb-macro.copyMacroAsKeybinding,
* McsEngl.Vsccmnd.kb-macro.copyMacroAsKeybinding,

Vsccmdi.kb-macro.finishRecording,
· key: ctrl+alt+r,
· when: kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option1',
* McsEngl.Vsccmnd.kb-macro.finishRecording,

Vsccmdi.kb-macro.finishRecording,
· key: ctrl+shift+alt+r,
· when: kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option2',
* McsEngl.Vsccmnd.kb-macro.finishRecording,

Vsccmdi.kb-macro.playback,
· key: ctrl+alt+p,
· when: !kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option1',
* McsEngl.Vsccmnd.kb-macro.playback,

Vsccmdi.kb-macro.playback,
· key: ctrl+shift+alt+p,
· when: !kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option2',
* McsEngl.Vsccmnd.kb-macro.playback,

Vsccmdi.kb-macro.repeatPlayback,
* McsEngl.Vsccmnd.kb-macro.repeatPlayback,

Vsccmdi.kb-macro.repeatPlaybackTillEndOfFile,
* McsEngl.Vsccmnd.kb-macro.repeatPlaybackTillEndOfFile,

Vsccmdi.kb-macro.startRecording,
· key: ctrl+alt+r,
· when: !kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option1',
* McsEngl.Vsccmnd.kb-macro.startRecording,

Vsccmdi.kb-macro.startRecording,
· key: ctrl+shift+alt+r,
· when: !kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option2',
* McsEngl.Vsccmnd.kb-macro.startRecording,

Vsccmdi.kb-macro.wrap,
· key: alt+-,
· when: inSearchEditor && kb-macro.active,
· args: {"command":"decreaseSearchEditorContextLines"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+0,
· when: kb-macro.active,
· args: {"command":"workbench.action.lastEditorInGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+1,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex1"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+2,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex2"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+3,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex3"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+4,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex4"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+5,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex5"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+6,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex6"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+7,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex7"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+8,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex8"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+9,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex9"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+=,
· when: inSearchEditor && kb-macro.active,
· args: {"command":"increaseSearchEditorContextLines"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+[,
· when: accessibleViewIsShown && accessibleViewSupportsNavigation && kb-macro.active,
· args: {"command":"editor.action.accessibleViewPrevious"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+[,
· when: inlineSuggestionVisible && kb-macro.active && !editorReadonly,
· args: {"command":"editor.action.inlineSuggest.showPrevious","record":"side-effect"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+],
· when: accessibleViewIsShown && accessibleViewSupportsNavigation && kb-macro.active,
· args: {"command":"editor.action.accessibleViewNext"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+],
· when: inlineSuggestionVisible && kb-macro.active && !editorReadonly,
· args: {"command":"editor.action.inlineSuggest.showNext","record":"side-effect"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+`,
· when: hasSpeechProvider && kb-macro.active && !editorReadonly && !speechToTextInProgress,
· args: {"command":"workbench.action.editorDictation.start"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+a,
· when: accessibilityHelpIsShown && accessibleViewHasAssignedKeybindings && kb-macro.active,
· args: {"command":"editor.action.accessibilityHelpConfigureAssignedKeybindings"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+backspace,
· when: chatHasQuestionCarousel && kb-macro.active && !chatRemoteJobCreating || chatHasToolConfirmation && kb-macro.active && !chatRemoteJobCreating || chatSessionRequestInProgress && kb-macro.active && !chatRemoteJobCreating,
· args: {"command":"workbench.action.chat.cancel"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+backspace,
· when: commentWidgetVisible && editorFocus && kb-macro.active,
· args: {"command":"workbench.action.hideComment"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+c,
· when: editorFocus && kb-macro.active,
· args: {"command":"toggleFindCaseSensitive"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+c,
· when: inSearchEditor && kb-macro.active && searchInputBoxFocus,
· args: {"command":"toggleSearchEditorCaseSensitive"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+c,
· when: kb-macro.active && searchViewletFocus,
· args: {"command":"toggleSearchCaseSensitive"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+c,
· when: kb-macro.active && terminalFindVisible && terminalHasBeenCreated || kb-macro.active && terminalFindVisible && terminalProcessSupported,
· args: {"command":"workbench.action.terminal.toggleFindCaseSensitive"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+delete,
· when: false,
· args: {"command":"deleteWordRight"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+delete,
· when: false,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001bd"}},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+delete,
· when: kb-macro.active && notebookCellEditable && notebookCellHasOutputs && notebookEditable && notebookEditorFocused && !inputFocus,
· args: {"command":"notebook.cell.clearOutputs"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: accessibleViewIsShown && kb-macro.active && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal',
· args: {"command":"workbench.action.terminal.accessibleBufferGoToNextCommand"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: editorHoverFocused && kb-macro.active,
· args: {"command":"editor.action.pageDownHover"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: editorPartModal && editorPartModalNavigation && kb-macro.active,
· args: {"command":"workbench.action.navigateModalEditorNext"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: editorTextFocus && kb-macro.active && !editorReadonly,
· args: {"command":"editor.action.moveLinesDownAction"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: historyNavigationForwardsEnabled && historyNavigationWidgetFocus && kb-macro.active && !isComposing && !suggestWidgetVisible,
· args: {"command":"history.showNext"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.nextSeparatorWithQuickAccessFallback"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused,
· args: {"command":"list.focusAnyDown"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: kb-macro.active && notebookEditorFocused && !inputFocus,
· args: {"command":"notebook.cell.moveDown"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: kb-macro.active && scmRepository,
· args: {"command":"scm.forceViewNextCommit"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalSplitPaneActive || kb-macro.active && terminalFocus && terminalProcessSupported && terminalSplitPaneActive,
· args: {"command":"workbench.action.terminal.focusNextPane"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: kb-macro.active && terminalFocus,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[1;5B"}},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+end alt+end,
· when: isCompositeNotebook && kb-macro.active && mostRecentReplEditor || kb-macro.active && mostRecentReplEditor && !notebookCellListFocused,
· args: {"command":"repl.focusLastItemExecuted"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+end,
· when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused,
· args: {"command":"list.focusAnyLast"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: breakpointsFocused && kb-macro.active,
· args: {"command":"debug.openBreakpointToSide"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: chatInputHasText && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest != 's' || chatInputHasText && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest != 'q' && chatEditingSentRequest != 's' && chatEditingSentRequest != 'st' && config.chat.requestQueuing.defaultAction != 'steer',
· args: {"command":"workbench.action.chat.steerWithMessage"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: chatInputHasText && inChatInput && kb-macro.active && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && config.chat.requestQueuing.defaultAction == 'steer' && chatEditingSentRequest != 'q' && chatEditingSentRequest != 's' && chatEditingSentRequest != 'st',
· args: {"command":"workbench.action.chat.queueMessage"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: chatIsEnabled && kb-macro.active && terminalChatResponseContainsCodeBlock && terminalHasBeenCreated && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks || chatIsEnabled && kb-macro.active && terminalChatResponseContainsCodeBlock && terminalProcessSupported && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks,
· args: {"command":"workbench.action.terminal.chat.insertCommand"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: chatIsEnabled && kb-macro.active && terminalChatResponseContainsMultipleCodeBlocks && terminalHasBeenCreated && !terminalChatActiveRequest || chatIsEnabled && kb-macro.active && terminalChatResponseContainsMultipleCodeBlocks && terminalProcessSupported && !terminalChatActiveRequest,
· args: {"command":"workbench.action.terminal.chat.insertFirstCommand"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: editorFocus && findWidgetVisible && kb-macro.active,
· args: {"command":"editor.action.selectAllMatches"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: hasSearchResult && kb-macro.active && searchViewletFocus,
· args: {"command":"search.action.openInEditor"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget',
· args: {"command":"quickInput.accept"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: kb-macro.active && focusedView == 'workbench.view.testing',
· args: {"command":"testing.editFocusedTest"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: kb-macro.active && notebookCellListFocused && notebookCellType == 'markup' || kb-macro.active && notebookCellListFocused && notebookMissingKernelExtension && !notebookCellExecuting && notebookCellType == 'code' || kb-macro.active && notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelCount > 0 || kb-macro.active && notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelSourceCount > 0,
· args: {"command":"notebook.cell.executeAndInsertBelow"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+escape,
· when: false,
· args: {"command":"editor.action.triggerSuggest","record":"side-effect"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+escape,
· when: inQuickInput && kb-macro.active,
· args: {"command":"quickInput.hide"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f1,
· when: kb-macro.active && !accessibilityHelpIsShown,
· args: {"command":"editor.action.accessibilityHelp"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f2,
· when: accessibilityModeEnabled && kb-macro.active && terminalFocus && terminalHasBeenCreated || accessibilityModeEnabled && kb-macro.active && terminalFocus && terminalProcessSupported,
· args: {"command":"workbench.action.terminal.focusAccessibleBuffer"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f2,
· when: kb-macro.active,
· args: {"command":"editor.action.accessibleView"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f3,
· when: editorTextFocus && kb-macro.active && !textCompareEditorActive,
· args: {"command":"editor.action.dirtydiff.next"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f3,
· when: kb-macro.active && activeEditor == 'workbench.editor.notebookTextDiffEditor',
· args: {"command":"notebook.diff.action.next"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f4,
· when: kb-macro.active,
· args: {"command":"workbench.action.closeWindow"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f5,
· when: chatEdits.hasEditorModifications && chatIsEnabled && editorFocus && kb-macro.active || chatEdits.hasEditorModifications && chatIsEnabled && kb-macro.active && notebookCellListFocused,
· args: {"command":"chatEditor.action.navigateNext"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f5,
· when: editorTextFocus && kb-macro.active && !textCompareEditorActive && quickDiffDecorationCount != '0',
· args: {"command":"workbench.action.editor.nextChange"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f5,
· when: kb-macro.active && activeEditor == 'multiDiffEditor',
· args: {"command":"multiDiffEditor.goToNextChange"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f5,
· when: kb-macro.active && textCompareEditorVisible,
· args: {"command":"workbench.action.compareEditor.nextChange"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f6,
· when: accessibilityHelpIsShown && accessibleViewVerbosityEnabled && kb-macro.active || accessibleViewIsShown && accessibleViewVerbosityEnabled && kb-macro.active,
· args: {"command":"editor.action.accessibleViewDisableHint"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f8,
· when: editorFocus && kb-macro.active && testing.isPeekVisible,
· args: {"command":"testing.goToNextMessage"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f8,
· when: editorFocus && kb-macro.active,
· args: {"command":"editor.action.marker.next"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f9,
· when: activeEditor && kb-macro.active && testing.hasCoverageInFile,
· args: {"command":"testing.coverage.goToNextMissedLine"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f9,
· when: kb-macro.active,
· args: {"command":"editor.action.nextCommentThreadAction"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f10,
· when: activeEditorHasCommentingRange && kb-macro.active,
· args: {"command":"editor.action.nextCommentedRangeAction"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f12,
· when: editorHasDefinitionProvider && editorTextFocus && kb-macro.active && !inReferenceSearchEditor && !isInEmbeddedEditor,
· args: {"command":"editor.action.peekDefinition"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+h,
· when: accessibilityHelpIsShown && kb-macro.active,
· args: {"command":"editor.action.accessibilityHelpOpenHelpLink"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+h,
· when: kb-macro.active && testing.isPeekVisible,
· args: {"command":"testing.toggleTestingPeekHistory"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+home alt+home,
· when: kb-macro.active && mostRecentReplEditor,
· args: {"command":"repl.input.focus"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+home,
· when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused,
· args: {"command":"list.focusAnyFirst"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+k,
· when: accessibilityHelpIsShown && accessibleViewHasUnassignedKeybindings && kb-macro.active,
· args: {"command":"editor.action.accessibilityHelpConfigureKeybindings"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+k,
· when: inKeybindings && inKeybindingsSearch && kb-macro.active,
· args: {"command":"keybindings.editor.recordSearchKeys"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+l,
· when: editorFocus && kb-macro.active,
· args: {"command":"toggleFindInSelection"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+l,
· when: inSearchEditor && kb-macro.active,
· args: {"command":"toggleSearchEditorContextLines"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: browserCanGoBack && kb-macro.active && activeEditor == 'workbench.editor.browser',
· args: {"command":"workbench.action.browser.goBack"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: canNavigateBack && kb-macro.active,
· args: {"command":"workbench.action.navigateBack"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: false,
· args: {"command":"breadcrumbs.focusPrevious"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: false,
· args: {"command":"breadcrumbs.focusPreviousWithPicker"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: false,
· args: {"command":"cursorWordLeft"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: false,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001bb"}},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: inQuickOpen && kb-macro.active,
· args: {"command":"workbench.action.quickInputBack"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalSplitPaneActive || kb-macro.active && terminalFocus && terminalProcessSupported && terminalSplitPaneActive,
· args: {"command":"workbench.action.terminal.focusPreviousPane"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: kb-macro.active && terminalFocus,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[1;5D"}},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+n,
· when: chatHasQuestionCarousel && inChat && inChatQuestionCarousel && kb-macro.active,
· args: {"command":"workbench.action.chat.nextQuestion"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+p,
· when: chatHasQuestionCarousel && inChat && inChatQuestionCarousel && kb-macro.active,
· args: {"command":"workbench.action.chat.previousQuestion"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+p,
· when: editorFocus && kb-macro.active,
· args: {"command":"togglePreserveCase"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+p,
· when: inKeybindings && kb-macro.active,
· args: {"command":"keybindings.editor.toggleSortByPrecedence"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+p,
· when: kb-macro.active && searchViewletFocus,
· args: {"command":"toggleSearchPreserveCase"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+pagedown,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.pageNext"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+pagedown,
· when: kb-macro.active && textInputFocus,
· args: {"command":"scrollPageDown"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+pageup,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.pagePrevious"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+pageup,
· when: kb-macro.active && textInputFocus,
· args: {"command":"scrollPageUp"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+r,
· when: editorFocus && kb-macro.active,
· args: {"command":"toggleFindRegex"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+r,
· when: inSearchEditor && kb-macro.active && searchInputBoxFocus,
· args: {"command":"toggleSearchEditorRegex"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+r,
· when: kb-macro.active && searchViewletFocus,
· args: {"command":"toggleSearchRegex"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+r,
· when: kb-macro.active && terminalFindVisible && terminalHasBeenCreated || kb-macro.active && terminalFindVisible && terminalProcessSupported,
· args: {"command":"workbench.action.terminal.toggleFindRegex"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: browserCanGoForward && kb-macro.active && activeEditor == 'workbench.editor.browser',
· args: {"command":"workbench.action.browser.goForward"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: canNavigateForward && kb-macro.active,
· args: {"command":"workbench.action.navigateForward"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: cursorAtEndOfQuickInputBox && inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickPick',
· args: {"command":"quickInput.acceptInBackground"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: false,
· args: {"command":"breadcrumbs.focusNext"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: false,
· args: {"command":"breadcrumbs.focusNextWithPicker"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: false,
· args: {"command":"cursorWordEndRight"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: false,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001bf"}},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalSplitPaneActive || kb-macro.active && terminalFocus && terminalProcessSupported && terminalSplitPaneActive,
· args: {"command":"workbench.action.terminal.focusNextPane"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: kb-macro.active && terminalFocus,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[1;5C"}},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+space,
· when: config.terminal.integrated.enableWin32InputMode && kb-macro.active && terminalFocus && terminalShellIntegrationEnabled && !accessibilityModeEnabled && terminalShellType == 'pwsh',
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[24~b"}},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+t,
· when: accessibleViewIsShown && chatIsEnabled && kb-macro.active && accessibleViewCurrentProviderId == 'panelChat',
· args: {"command":"workbench.action.chat.toggleThinkingContentAccessibleView"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal',
· args: {"command":"workbench.action.terminal.accessibleBufferGoToPreviousCommand"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: editorHoverFocused && kb-macro.active,
· args: {"command":"editor.action.pageUpHover"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: editorPartModal && editorPartModalNavigation && kb-macro.active,
· args: {"command":"workbench.action.navigateModalEditorPrevious"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: editorTextFocus && kb-macro.active && !editorReadonly,
· args: {"command":"editor.action.moveLinesUpAction"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: historyNavigationBackwardsEnabled && historyNavigationWidgetFocus && kb-macro.active && !isComposing && !suggestWidgetVisible,
· args: {"command":"history.showPrevious"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.previousSeparatorWithQuickAccessFallback"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused,
· args: {"command":"list.focusAnyUp"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: kb-macro.active && notebookEditorFocused && !inputFocus,
· args: {"command":"notebook.cell.moveUp"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: kb-macro.active && scmRepository,
· args: {"command":"scm.forceViewPreviousCommit"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalSplitPaneActive || kb-macro.active && terminalFocus && terminalProcessSupported && terminalSplitPaneActive,
· args: {"command":"workbench.action.terminal.focusPreviousPane"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: kb-macro.active && terminalFocus,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[1;5A"}},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+w,
· when: editorFocus && kb-macro.active,
· args: {"command":"toggleFindWholeWord"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+w,
· when: inSearchEditor && kb-macro.active && searchInputBoxFocus,
· args: {"command":"toggleSearchEditorWholeWord"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+w,
· when: kb-macro.active && searchViewletFocus,
· args: {"command":"toggleSearchWholeWord"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+w,
· when: kb-macro.active && terminalFindVisible && terminalHasBeenCreated || kb-macro.active && terminalFindVisible && terminalProcessSupported,
· args: {"command":"workbench.action.terminal.toggleFindWholeWord"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+/,
· when: chatIsEnabled && editorTextFocus && kb-macro.active && resourceSet && resourceLangId == 'prompt',
· args: {"command":"workbench.action.chat.run.prompt.current"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+/,
· when: chatIsEnabled && editorTextFocus && kb-macro.active && resourceSet && resourceLangId == 'prompt',
· args: {"command":"workbench.action.chat.run.prompt.current"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+/,
· when: chatIsEnabled && kb-macro.active,
· args: {"command":"workbench.action.chat.run.prompt"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+/,
· when: chatIsEnabled && kb-macro.active,
· args: {"command":"workbench.action.chat.run.prompt"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+backspace,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"editor.action.removeBrackets"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+c,
· when: fileMatchOrFolderMatchWithResourceFocus && kb-macro.active,
· args: {"command":"search.action.copyPath"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+c,
· when: kb-macro.active && !editorFocus,
· args: {"command":"copyFilePath"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+c,
· when: kb-macro.active && searchViewletFocus && !fileMatchOrFolderMatchFocus,
· args: {"command":"toggleSearchCaseSensitive"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+c,
· when: kb-macro.active && watchExpressionsExist && !expressionSelected && focusedView == 'workbench.debug.watchExpressionsView',
· args: {"command":"debug.copyWatchExpression"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+down,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"editor.action.insertCursorBelow"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+down,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.nextSeparator"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+enter,
· when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget',
· args: {"command":"quickInput.accept"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+escape,
· when: inQuickInput && kb-macro.active,
· args: {"command":"quickInput.hide"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+j,
· when: kb-macro.active && notebookEditorFocused,
· args: {"command":"notebook.cell.joinBelow"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+j,
· when: kb-macro.active && notebookEditorFocused,
· args: {"command":"notebook.cell.joinBelow"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+left,
· when: kb-macro.active,
· args: {"command":"workbench.action.previousEditor"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+pagedown,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.pageNext"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+pagedown,
· when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive,
· args: {"command":"workbench.action.terminal.scrollDown"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+pageup,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.pagePrevious"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+pageup,
· when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive,
· args: {"command":"workbench.action.terminal.scrollUp"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+r,
· when: kb-macro.active && !editorFocus,
· args: {"command":"revealFileInOS"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+right,
· when: cursorAtEndOfQuickInputBox && inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickPick',
· args: {"command":"quickInput.acceptInBackground"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+right,
· when: kb-macro.active,
· args: {"command":"workbench.action.nextEditor"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+s,
· when: kb-macro.active,
· args: {"command":"saveAll"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+t,
· when: kb-macro.active,
· args: {"command":"workbench.action.closeOtherEditors"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+up,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"editor.action.insertCursorAbove"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+up,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.previousSeparator"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+z,
· when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalIsOpen || kb-macro.active && terminalFocus && terminalIsOpen && terminalProcessSupported,
· args: {"command":"workbench.action.terminal.sizeToContentWidth"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+z,
· when: kb-macro.active,
· args: {"command":"editor.action.toggleWordWrap"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: backspace,
· when: config.notebook.multiCursor.enabled && isNotebookMultiSelect && kb-macro.active && activeEditor == 'workbench.editor.notebook' && notebookMultiSelectCursorState == '1' || config.notebook.multiCursor.enabled && isNotebookMultiSelect && kb-macro.active && activeEditor == 'workbench.editor.notebook' && notebookMultiSelectCursorState == '2',
· args: {"command":"noteMultiCursor.deleteLeft"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: backspace,
· when: kb-macro.active && textInputFocus,
· args: {"command":"deleteLeft"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: browserback,
· when: browserCanGoBack && kb-macro.active && activeEditor == 'workbench.editor.browser',
· args: {"command":"workbench.action.browser.goBack"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: browserback,
· when: canNavigateBack && kb-macro.active,
· args: {"command":"workbench.action.navigateBack"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: browserforward,
· when: browserCanGoForward && kb-macro.active && activeEditor == 'workbench.editor.browser',
· args: {"command":"workbench.action.browser.goForward"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: browserforward,
· when: canNavigateForward && kb-macro.active,
· args: {"command":"workbench.action.navigateForward"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+,,
· when: kb-macro.active,
· args: {"command":"workbench.action.openSettings"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+-,
· when: browserFocused && browserHasUrl && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser',
· args: {"command":"workbench.action.browser.zoomOut"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+-,
· when: false,
· args: {"command":"workbench.action.navigateBack"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+-,
· when: false,
· args: {"command":"workbench.action.quickInputBack"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+-,
· when: kb-macro.active,
· args: {"command":"workbench.action.zoomOut"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+.,
· when: chatIsEnabled && inChatInput && kb-macro.active && chatLocation == 'panel',
· args: {"command":"workbench.action.chat.openModePicker"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+.,
· when: dropWidgetVisible && kb-macro.active,
· args: {"command":"editor.changeDropType"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+.,
· when: kb-macro.active && notebookCellFocused && notebookCellHasErrorDiagnostics && !notebookCellEditorFocused,
· args: {"command":"notebook.cell.openFailureActions"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+.,
· when: kb-macro.active && pasteWidgetVisible,
· args: {"command":"editor.changePasteType"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+.,
· when: kb-macro.active && problemFocus,
· args: {"command":"problems.action.showQuickFixes"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+.,
· when: kb-macro.active && terminalFocus,
· args: {"command":"workbench.action.terminal.showQuickFixes"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+/,
· when: accessibleViewIsShown && kb-macro.active && accessibleViewCurrentProviderId == 'inlineCompletions',
· args: {"command":"editor.action.accessibleViewAcceptInlineCompletion"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+/,
· when: editorTextFocus && kb-macro.active && !editorReadonly,
· args: {"command":"editor.action.commentLine"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+/,
· when: inChatInput && kb-macro.active && chatLocation == 'panel',
· args: {"command":"workbench.action.chat.attachContext"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+/,
· when: kb-macro.active && notebookEditable && notebookEditorFocused && !inputFocus,
· args: {"command":"notebook.commentSelectedCells"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+/,
· when: kb-macro.active && suggestWidgetVisible,
· args: {"command":"toggleExplainMode","record":"side-effect"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+/,
· when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || kb-macro.active && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible,
· args: {"command":"terminalSuggestToggleExplainMode"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+0,
· when: kb-macro.active,
· args: {"command":"workbench.action.focusSideBar"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+1,
· when: kb-macro.active,
· args: {"command":"workbench.action.focusFirstEditorGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+2,
· when: kb-macro.active,
· args: {"command":"workbench.action.focusSecondEditorGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+3,
· when: kb-macro.active,
· args: {"command":"workbench.action.focusThirdEditorGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+4,
· when: kb-macro.active,
· args: {"command":"workbench.action.focusFourthEditorGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+5,
· when: kb-macro.active,
· args: {"command":"workbench.action.focusFifthEditorGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+6,
· when: kb-macro.active,
· args: {"command":"workbench.action.focusSixthEditorGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+7,
· when: kb-macro.active,
· args: {"command":"workbench.action.focusSeventhEditorGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+8,
· when: kb-macro.active,
· args: {"command":"workbench.action.focusEighthEditorGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+9,
· when: kb-macro.active,
· args: {"command":"workbench.action.lastEditorInGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; a,
· when: kb-macro.active,
· args: {"command":"testing.runAll"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; c,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"testing.runAtCursor"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+a,
· when: kb-macro.active,
· args: {"command":"testing.debugAll"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+c,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"testing.debugAtCursor"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+e,
· when: kb-macro.active,
· args: {"command":"testing.debugFailTests"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+f,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"testing.debugCurrentFile"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+i,
· when: kb-macro.active,
· args: {"command":"testing.toggleInlineTestOutput"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+l,
· when: kb-macro.active,
· args: {"command":"testing.debugLastRun"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+m,
· when: kb-macro.active,
· args: {"command":"testing.openOutputPeek"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+o,
· when: kb-macro.active && testing.hasAnyResults,
· args: {"command":"testing.showMostRecentOutput"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+r,
· when: kb-macro.active && testing.canRefresh,
· args: {"command":"testing.refreshTests"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+shift+a,
· when: kb-macro.active,
· args: {"command":"testing.coverageAll"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+shift+c,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"testing.coverageAtCursor"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+shift+f,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"testing.coverageCurrentFile"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+shift+i,
· when: kb-macro.active,
· args: {"command":"testing.toggleInlineCoverage"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+shift+l,
· when: kb-macro.active,
· args: {"command":"testing.coverageLastRun"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; ctrl+x,
· when: kb-macro.active,
· args: {"command":"testing.cancelRun"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; e,
· when: kb-macro.active,
· args: {"command":"testing.reRunFailTests"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; f,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"testing.runCurrentFile"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+; l,
· when: kb-macro.active,
· args: {"command":"testing.reRunLastRun"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+=,
· when: browserFocused && browserHasUrl && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser',
· args: {"command":"workbench.action.browser.zoomIn"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+=,
· when: kb-macro.active,
· args: {"command":"workbench.action.zoomIn"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+[,
· when: editorTextFocus && kb-macro.active && !editorReadonly,
· args: {"command":"editor.action.outdentLines"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+\\,
· when: kb-macro.active,
· args: {"command":"workbench.action.splitEditor"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+],
· when: editorTextFocus && kb-macro.active && !editorReadonly,
· args: {"command":"editor.action.indentLines"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+`,
· when: kb-macro.active && terminal.active,
· args: {"command":"workbench.action.terminal.toggleTerminal"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+a,
· when: false,
· args: {"command":"cursorLineStart"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+a,
· when: kb-macro.active && listFocus && listSupportsMultiselect && !inputFocus && !treestickyScrollFocused,
· args: {"command":"list.selectAll"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+a,
· when: kb-macro.active && notebookEditorFocused && notebookOutputFocused,
· args: {"command":"notebook.cell.output.selectAll"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+a,
· when: kb-macro.active,
· args: {"command":"editor.action.selectAll"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+-,
· when: false,
· args: {"command":"workbench.action.navigateBack"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+-,
· when: false,
· args: {"command":"workbench.action.quickInputBack"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+.,
· when: chatIsEnabled && inChatInput && kb-macro.active,
· args: {"command":"workbench.action.chat.openModelPicker"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+/,
· when: false,
· args: {"command":"workbench.action.chat.run.prompt"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+/,
· when: false,
· args: {"command":"workbench.action.chat.run.prompt.current"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+b,
· when: kb-macro.active,
· args: {"command":"workbench.action.toggleAuxiliaryBar"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+backspace,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"editor.action.removeBrackets"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+backspace,
· when: false,
· args: {"command":"deleteWordPartLeft"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+c,
· when: false,
· args: {"command":"copyFilePath"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+c,
· when: false,
· args: {"command":"search.action.copyPath"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+c,
· when: kb-macro.active && watchExpressionsExist && !expressionSelected && focusedView == 'workbench.debug.watchExpressionsView',
· args: {"command":"debug.copyWatchExpression"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+delete,
· when: false,
· args: {"command":"deleteWordPartRight"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+down,
· when: chatIsEnabled && inChat && kb-macro.active,
· args: {"command":"workbench.action.chat.nextUserPrompt"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+down,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"editor.action.insertCursorBelow"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+down,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.nextSeparator"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+end,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.last"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+enter,
· when: accessibleViewInCodeBlock && chatIsEnabled && kb-macro.active || chatIsEnabled && inChat && kb-macro.active,
· args: {"command":"workbench.action.chat.runInTerminal"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+enter,
· when: agentSessionsViewerFocused && kb-macro.active && !isSessionsWindow,
· args: {"command":"workbench.action.chat.openSessionInNewEditorGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+enter,
· when: chatHasToolConfirmation && inChat && kb-macro.active,
· args: {"command":"workbench.action.chat.skipTool"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+enter,
· when: chatIsEnabled && kb-macro.active && terminalChatResponseContainsCodeBlock && terminalHasBeenCreated && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks || chatIsEnabled && kb-macro.active && terminalChatResponseContainsCodeBlock && terminalProcessSupported && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks,
· args: {"command":"workbench.action.terminal.chat.insertCommand"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+enter,
· when: chatIsEnabled && kb-macro.active && terminalChatResponseContainsMultipleCodeBlocks && terminalHasBeenCreated && !terminalChatActiveRequest || chatIsEnabled && kb-macro.active && terminalChatResponseContainsMultipleCodeBlocks && terminalProcessSupported && !terminalChatActiveRequest,
· args: {"command":"workbench.action.terminal.chat.insertFirstCommand"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+enter,
· when: editorFocus && findWidgetVisible && kb-macro.active,
· args: {"command":"editor.action.replaceAll"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+enter,
· when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget',
· args: {"command":"quickInput.accept"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+enter,
· when: inputFocus && kb-macro.active && notebookEditorFocused && !inlineChatFocused && notebookCellType == 'markup',
· args: {"command":"notebook.cell.quitEdit"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+enter,
· when: kb-macro.active && notebookCellListFocused && notebookMissingKernelExtension && !notebookCellExecuting && notebookCellType == 'code' || kb-macro.active && notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelCount > 0 || kb-macro.active && notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelSourceCount > 0,
· args: {"command":"notebook.cell.execute"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+enter,
· when: kb-macro.active && replaceActive && searchViewletVisible && !findWidgetVisible,
· args: {"command":"search.action.replaceAll"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+escape,
· when: inQuickInput && kb-macro.active,
· args: {"command":"quickInput.hide"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+f,
· when: inDebugRepl && kb-macro.active || inDebugRepl && kb-macro.active && focusedView == 'workbench.panel.repl.view',
· args: {"command":"repl.action.find"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+f,
· when: kb-macro.active && listFocus && listSupportsFind,
· args: {"command":"list.find"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+f,
· when: kb-macro.active && view == 'workbench.panel.repl.view',
· args: {"command":"list.find.replInputFocus"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+g,
· when: kb-macro.active && terminalFocus,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u0007"}},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+home,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.first"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+i,
· when: kb-macro.active && !chatSetupDisabled && !chatSetupHidden,
· args: {"command":"workbench.action.chat.open"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+i,
· when: kb-macro.active && workbench.panel.chat.view.copilot.active,
· args: {"command":"workbench.panel.chat"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+j,
· when: false,
· args: {"command":"notebook.cell.joinBelow"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+left,
· when: false,
· args: {"command":"cursorWordPartLeft"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+left,
· when: kb-macro.active,
· args: {"command":"workbench.action.moveEditorToPreviousGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+n,
· when: false,
· args: {"command":"list.focusAnyDown"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+o,
· when: kb-macro.active,
· args: {"command":"workbench.action.remote.showMenu"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+p,
· when: false,
· args: {"command":"list.focusAnyUp"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+pagedown,
· when: accessibleViewContainsCodeBlocks && kb-macro.active && accessibleViewCurrentProviderId == 'inlineChat' || accessibleViewContainsCodeBlocks && kb-macro.active && accessibleViewCurrentProviderId == 'panelChat' || accessibleViewContainsCodeBlocks && kb-macro.active && accessibleViewCurrentProviderId == 'quickChat',
· args: {"command":"editor.action.accessibleViewNextCodeBlock"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+pagedown,
· when: chatIsEnabled && inChat && kb-macro.active,
· args: {"command":"workbench.action.chat.nextCodeBlock"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+pagedown,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.pageNext"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+pagedown,
· when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive,
· args: {"command":"workbench.action.terminal.scrollDown"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+pageup,
· when: accessibleViewContainsCodeBlocks && kb-macro.active && accessibleViewCurrentProviderId == 'inlineChat' || accessibleViewContainsCodeBlocks && kb-macro.active && accessibleViewCurrentProviderId == 'panelChat' || accessibleViewContainsCodeBlocks && kb-macro.active && accessibleViewCurrentProviderId == 'quickChat',
· args: {"command":"editor.action.accessibleViewPreviousCodeBlock"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+pageup,
· when: chatIsEnabled && inChat && kb-macro.active,
· args: {"command":"workbench.action.chat.previousCodeBlock"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+pageup,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.pagePrevious"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+pageup,
· when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive,
· args: {"command":"workbench.action.terminal.scrollUp"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+r,
· when: accessibilityModeEnabled && kb-macro.active && terminalFocus,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u0012"}},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+r,
· when: false,
· args: {"command":"revealFileInOS"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+r,
· when: kb-macro.active && terminalFocus && terminalHasBeenCreated && !accessibilityModeEnabled || kb-macro.active && terminalFocus && terminalProcessSupported && !accessibilityModeEnabled,
· args: {"command":"workbench.action.terminal.runRecentCommand"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+right,
· when: cursorAtEndOfQuickInputBox && inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickPick',
· args: {"command":"quickInput.acceptInBackground"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+right,
· when: false,
· args: {"command":"cursorWordPartRight"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+right,
· when: kb-macro.active,
· args: {"command":"workbench.action.moveEditorToNextGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+space,
· when: kb-macro.active && !textInputFocus,
· args: {"command":"workbench.action.terminal.suggestToggleDetailsFocus"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+space,
· when: kb-macro.active && suggestWidgetVisible && textInputFocus,
· args: {"command":"toggleSuggestionFocus","record":"side-effect"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+up,
· when: chatIsEnabled && inChat && kb-macro.active,
· args: {"command":"workbench.action.chat.previousUserPrompt"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+up,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"editor.action.insertCursorAbove"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+up,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.previousSeparator"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+v,
· when: hasSpeechProvider && kb-macro.active && !editorReadonly && !speechToTextInProgress,
· args: {"command":"workbench.action.editorDictation.start"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+win+/,
· when: chatIsEnabled && editorTextFocus && kb-macro.active && resourceSet && resourceLangId == 'prompt',
· args: {"command":"workbench.action.chat.run-in-new-chat.prompt.current"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+win+/,
· when: chatIsEnabled && editorTextFocus && kb-macro.active && resourceSet && resourceLangId == 'prompt',
· args: {"command":"workbench.action.chat.run-in-new-chat.prompt.current"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+win+/,
· when: chatIsEnabled && editorTextFocus && kb-macro.active && resourceSet && resourceLangId == 'prompt',
· args: {"command":"workbench.action.chat.run-in-new-chat.prompt.current"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+win+end,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.last"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+win+enter,
· when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget',
· args: {"command":"quickInput.accept"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+win+escape,
· when: inQuickInput && kb-macro.active,
· args: {"command":"quickInput.hide"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+win+home,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.first"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+win+n,
· when: kb-macro.active,
· args: {"command":"welcome.showNewFileEntries"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+win+n,
· when: kb-macro.active,
· args: {"command":"welcome.showNewFileEntries"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+win+n,
· when: kb-macro.active,
· args: {"command":"welcome.showNewFileEntries"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+win+pagedown,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.pageNext"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+win+pageup,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.pagePrevious"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+win+right,
· when: cursorAtEndOfQuickInputBox && inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickPick',
· args: {"command":"quickInput.acceptInBackground"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+alt+y,
· when: chatEdits.hasEditorModifications && editorFocus && kb-macro.active && !chatEdits.isCurrentlyBeingModified || chatEdits.hasEditorModifications && kb-macro.active && notebookEditorFocused && !chatEdits.isCurrentlyBeingModified,
· args: {"command":"chatEditor.action.acceptAllEdits"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+b,
· when: false,
· args: {"command":"cursorLeft"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+b,
· when: kb-macro.active,
· args: {"command":"workbench.action.toggleSidebarVisibility"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+backspace,
· when: false,
· args: {"command":"deleteLeft"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+backspace,
· when: hasUndecidedChatEditingResource && inChatInput && kb-macro.active && !chatInputHasText,
· args: {"command":"chatEditing.discardAllFiles"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+backspace,
· when: kb-macro.active && terminalFocus && terminalShellType == 'cmd',
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\b"}},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+backspace,
· when: kb-macro.active && terminalFocus,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u0017"}},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+backspace,
· when: kb-macro.active && textInputFocus && !editorReadonly,
· args: {"command":"deleteWordLeft"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+c,
· when: chatAttachmentResource && kb-macro.active,
· args: {"command":"chat.inlineResourceAnchor.copyResource"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+c,
· when: fileMatchOrMatchFocus && kb-macro.active,
· args: {"command":"search.action.copyMatch"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+c,
· when: filesExplorerFocus && foldersViewVisible && kb-macro.active && !explorerResourceIsRoot && !inputFocus,
· args: {"command":"filesExplorer.copy"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+c,
· when: inKeybindings && kb-macro.active && keybindingFocus && !whenFocus,
· args: {"command":"keybindings.editor.copyKeybindingEntry"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+c,
· when: kb-macro.active && !expressionSelected && focusedView == 'workbench.debug.variablesView' || kb-macro.active && !expressionSelected && focusedView == 'workbench.debug.watchExpressionsView',
· args: {"command":"workbench.debug.viewlet.action.copyValue"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+c,
· when: kb-macro.active && problemsVisibility && !relatedInformationFocus && focusedView == 'workbench.panel.markers.view',
· args: {"command":"problems.action.copy"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+c,
· when: kb-macro.active && suggestWidgetDetailsFocused,
· args: {"command":"suggestWidgetCopy"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+c,
· when: kb-macro.active && terminalTextSelectedInFocused || kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalTextSelected || kb-macro.active && terminalFocus && terminalProcessSupported && terminalTextSelected || kb-macro.active && terminalFocus && terminalTextSelected && terminalTextSelectedInFocused || kb-macro.active && terminalHasBeenCreated && terminalTextSelected && terminalTextSelectedInFocused || kb-macro.active && terminalProcessSupported && terminalTextSelected && terminalTextSelectedInFocused,
· args: {"command":"workbench.action.terminal.copyAndClearSelection"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+c,
· when: kb-macro.active && tunnelViewFocus && tunnelType == 'Detected' && tunnelViewMultiSelection == 'undefined' || kb-macro.active && tunnelViewFocus && tunnelType == 'Forwarded' && tunnelViewMultiSelection == 'undefined',
· args: {"command":"remote.tunnel.copyAddressInline"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+c,
· when: kb-macro.active,
· args: {"command":"editor.action.clipboardCopyAction","await":"clipboard"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+d,
· when: config.notebook.multiCursor.enabled && kb-macro.active && notebookCellEditorFocused && activeEditor == 'workbench.editor.notebook',
· args: {"command":"notebook.addFindMatchToSelection"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+d,
· when: editorFocus && kb-macro.active,
· args: {"command":"editor.action.addSelectionToNextFindMatch"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+d,
· when: false,
· args: {"command":"deleteRight"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+delete,
· when: false,
· args: {"command":"deleteRight"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+delete,
· when: kb-macro.active && terminalFocus,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001bd"}},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+delete,
· when: kb-macro.active && textInputFocus && !editorReadonly,
· args: {"command":"deleteWordRight"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: accessibilityModeEnabled && accessibleViewOnLastLine && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibilityModeEnabled && accessibleViewOnLastLine && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal',
· args: {"command":"workbench.action.terminal.focus"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: commentsFilterFocus && kb-macro.active,
· args: {"command":"commentsFocusViewFromFilter"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: editorHoverFocused && kb-macro.active,
· args: {"command":"editor.action.goToBottomHover"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: editorTextFocus && inlineChatVisible && kb-macro.active && !accessibilityModeEnabled && !inlineChatFocused && !isEmbeddedDiffEditor && inlineChatOuterCursorPosition == 'above',
· args: {"command":"inlineChat.focus"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: inChat && inChatInput && kb-macro.active && quickChatHasFocus,
· args: {"command":"chat.action.focus"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: inChat && kb-macro.active && !inChatInput && !quickChatHasFocus,
· args: {"command":"workbench.action.chat.focusInput"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: inKeybindings && inKeybindingsSearch && kb-macro.active,
· args: {"command":"keybindings.editor.focusKeybindings"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.next"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: inSearchEditor && inputBoxFocus && kb-macro.active || inputBoxFocus && kb-macro.active && searchViewletVisible,
· args: {"command":"search.focus.nextInputBox"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: inputFocus && kb-macro.active && navigableContainerFocused || kb-macro.active && navigableContainerFocused && treestickyScrollFocused || kb-macro.active && navigableContainerFocused && !listFocus || kb-macro.active && navigableContainerFocused && listScrollAtBoundary == 'both' || kb-macro.active && navigableContainerFocused && listScrollAtBoundary == 'bottom',
· args: {"command":"widgetNavigation.focusNext"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: isCompositeNotebook && kb-macro.active && notebookEditorFocused,
· args: {"command":"repl.input.focus"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused && listScrollAtBoundary != 'both' && listScrollAtBoundary != 'bottom',
· args: {"command":"list.scrollDown"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: kb-macro.active && notebookCellHasOutputs && !isCompositeNotebook && activeEditor == 'workbench.editor.interactive' || kb-macro.active && notebookCellHasOutputs && !isCompositeNotebook && activeEditor == 'workbench.editor.notebook' || kb-macro.active && notebookCellHasOutputs && !isCompositeNotebook && activeEditor == 'workbench.editor.repl',
· args: {"command":"notebook.cell.focusInOutput"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: kb-macro.active && notebookEditorFocused && notebookOutputFocused,
· args: {"command":"notebook.focusNextEditor"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: kb-macro.active && problemsFilterFocus,
· args: {"command":"problems.action.focusProblemsFromFilter"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: kb-macro.active && suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
· args: {"command":"selectNextSuggestion","record":"side-effect"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: kb-macro.active && terminalFocus && terminalHasBeenCreated && !accessibilityModeEnabled || kb-macro.active && terminalFocus && terminalProcessSupported && !accessibilityModeEnabled,
· args: {"command":"workbench.action.terminal.scrollToNextCommand"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+down,
· when: kb-macro.active && textInputFocus,
· args: {"command":"scrollLineDown"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+e,
· when: accessibilityHelpIsShown && kb-macro.active,
· args: {"command":"editor.action.toggleScreenReaderAccessibilityMode"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+e,
· when: false,
· args: {"command":"cursorLineEnd"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+e,
· when: inFilesPicker && inQuickOpen && kb-macro.active,
· args: {"command":"workbench.action.quickOpenNavigateNextInFilePicker"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+e,
· when: kb-macro.active,
· args: {"command":"workbench.action.quickOpen"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+end,
· when: accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal',
· args: {"command":"workbench.action.terminal.scrollToBottomAccessibleView"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+end,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.last"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+end,
· when: kb-macro.active && activeEditor == 'workbench.editor.interactive',
· args: {"command":"interactive.scrollToBottom"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+end,
· when: kb-macro.active && notebookEditorFocused && !inputFocus,
· args: {"command":"notebook.focusBottom"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+end,
· when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive,
· args: {"command":"workbench.action.terminal.scrollToBottom"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+end,
· when: kb-macro.active && textInputFocus,
· args: {"command":"cursorBottom"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: accessibleViewInCodeBlock && chatIsEnabled && kb-macro.active || chatIsEnabled && inChat && kb-macro.active && !inChatInput,
· args: {"command":"workbench.action.chat.applyInEditor"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: accessibleViewInCodeBlock && chatIsEnabled && kb-macro.active || chatIsEnabled && inChat && kb-macro.active && !inChatInput,
· args: {"command":"workbench.action.chat.insertCodeBlock"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: agentSessionsViewerFocused && kb-macro.active && !isSessionsWindow,
· args: {"command":"workbench.action.chat.openSessionInEditorGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused,
· args: {"command":"breadcrumbs.revealFocusedFromTreeAside"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active,
· args: {"command":"breadcrumbs.revealFocused"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: breakpointsFocused && kb-macro.active,
· args: {"command":"debug.openBreakpointToSide"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: browserElementSelectionActive && browserFocused && kb-macro.active,
· args: {"command":"workbench.action.browser.addFocusedElementToChat"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: chatAttachmentResource && kb-macro.active,
· args: {"command":"chat.inlineResourceAnchor.openToSide"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: chatEdits.hasEditorModifications && inlineChatHasEditsAgent && inlineChatVisible && kb-macro.active && !chatEdits.isRequestInProgress || chatEdits.hasEditorModifications && inlineChatHasNotebookAgent && inlineChatVisible && kb-macro.active && !chatEdits.isRequestInProgress && activeEditor == 'workbench.editor.notebook',
· args: {"command":"inlineChat2.keep"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: chatHasElicitationRequest && inChat && kb-macro.active,
· args: {"command":"workbench.action.chat.acceptElicitation"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: chatHasToolConfirmation && inChat && kb-macro.active,
· args: {"command":"workbench.action.chat.acceptTool"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: chatInputHasText && inChatInput && kb-macro.active && !chatSessionRequestInProgress,
· args: {"command":"workbench.action.chat.submitWithCodebase"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: chatIsEnabled && kb-macro.active && terminalChatResponseContainsCodeBlock && terminalHasBeenCreated && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks || chatIsEnabled && kb-macro.active && terminalChatResponseContainsCodeBlock && terminalProcessSupported && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks,
· args: {"command":"workbench.action.terminal.chat.runCommand"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: chatIsEnabled && kb-macro.active && terminalChatResponseContainsMultipleCodeBlocks && terminalHasBeenCreated && !terminalChatActiveRequest || chatIsEnabled && kb-macro.active && terminalChatResponseContainsMultipleCodeBlocks && terminalProcessSupported && !terminalChatActiveRequest,
· args: {"command":"workbench.action.terminal.chat.runFirstCommand"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: commentEditorFocused && kb-macro.active,
· args: {"command":"editor.action.submitComment"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: config.editor.rename.enablePreview && editorFocus && kb-macro.active && renameInputVisible && !isComposing,
· args: {"command":"acceptRenameInputWithPreview"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: editorTextFocus && kb-macro.active && !editorReadonly,
· args: {"command":"editor.action.insertLineAfter"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: explorerViewletFocus && foldersViewVisible && kb-macro.active && !inputFocus,
· args: {"command":"explorer.openToSide"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: false,
· args: {"command":"notebook.cell.execute"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: false,
· args: {"command":"notebook.cell.quitEdit"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: fileMatchOrMatchFocus && kb-macro.active && searchViewletVisible,
· args: {"command":"search.action.openResultToSide"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: hasUndecidedChatEditingResource && inChatInput && kb-macro.active,
· args: {"command":"chatEditing.acceptAllFiles"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget',
· args: {"command":"quickInput.accept"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: isCompositeNotebook && kb-macro.active && !notebookCellListFocused && activeEditor == 'workbench.editor.repl',
· args: {"command":"repl.execute"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: isCompositeNotebook && kb-macro.active && activeEditor == 'workbench.editor.interactive',
· args: {"command":"interactive.execute"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: isMergeEditor && kb-macro.active,
· args: {"command":"mergeEditor.acceptMerge"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: kb-macro.active && listFocus && referenceSearchVisible && !inputFocus && !treeElementCanCollapse && !treeElementCanExpand && !treestickyScrollFocused,
· args: {"command":"openReferenceToSide"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: kb-macro.active && notebookCellListFocused && !inputFocus,
· args: {"command":"notebook.cell.insertCodeCellBelow"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: kb-macro.active && problemFocus,
· args: {"command":"problems.action.openToSide"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: kb-macro.active && refactorPreview.enabled && refactorPreview.hasCheckedChanges && focusedView == 'refactorPreview',
· args: {"command":"refactorPreview.apply"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+enter,
· when: kb-macro.active && scmRepository,
· args: {"command":"scm.acceptInput"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+escape,
· when: false,
· args: {"command":"workbench.action.chat.cancel"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+escape,
· when: false,
· args: {"command":"workbench.action.hideComment"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+escape,
· when: inQuickInput && kb-macro.active,
· args: {"command":"quickInput.hide"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f,
· when: browserHasUrl && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser',
· args: {"command":"workbench.action.browser.showFind"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f,
· when: editorFocus && kb-macro.active || editorIsOpen && kb-macro.active,
· args: {"command":"actions.find"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f,
· when: false,
· args: {"command":"cursorRight"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f,
· when: inDebugRepl && kb-macro.active && textInputFocus,
· args: {"command":"repl.action.filter"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f,
· when: inKeybindings && kb-macro.active,
· args: {"command":"keybindings.editor.searchKeybindings"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f,
· when: inSettingsEditor && kb-macro.active,
· args: {"command":"settings.action.search"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f,
· when: kb-macro.active && !editorFocus && activeEditor == 'workbench.editor.extension',
· args: {"command":"editor.action.extensioneditor.showfind"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f,
· when: kb-macro.active && focusedView == 'workbench.panel.comments',
· args: {"command":"commentsFocusFilter"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f,
· when: kb-macro.active && focusedView == 'workbench.panel.markers.view',
· args: {"command":"problems.action.focusFilter"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f,
· when: kb-macro.active && notebookEditorFocused && !editorFocus && activeEditor == 'workbench.editor.interactive' || kb-macro.active && notebookEditorFocused && !editorFocus && activeEditor == 'workbench.editor.notebook',
· args: {"command":"notebook.find"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f,
· when: kb-macro.active && terminalFindFocused && terminalHasBeenCreated || kb-macro.active && terminalFindFocused && terminalProcessSupported || kb-macro.active && terminalFocusInAny && terminalHasBeenCreated || kb-macro.active && terminalFocusInAny && terminalProcessSupported,
· args: {"command":"workbench.action.terminal.focusFind"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f,
· when: kb-macro.active && webviewFindWidgetEnabled && !editorFocus && activeEditor == 'WebviewEditor',
· args: {"command":"editor.action.webvieweditor.showFind"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f2,
· when: editorTextFocus && kb-macro.active && !editorReadonly,
· args: {"command":"editor.action.changeAll"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f3,
· when: editorFocus && kb-macro.active,
· args: {"command":"editor.action.nextSelectionMatchFindAction"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f4,
· when: activeEditorGroupEmpty && kb-macro.active && multipleEditorGroups,
· args: {"command":"workbench.action.closeGroup"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f4,
· when: auxiliaryBarMaximized && kb-macro.active,
· args: {"command":"workbench.action.restoreAuxiliaryBar"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f4,
· when: kb-macro.active && terminalEditorFocus && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalEditorFocus && terminalFocus && terminalProcessSupported,
· args: {"command":"workbench.action.terminal.killEditor"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f4,
· when: kb-macro.active,
· args: {"command":"workbench.action.closeActiveEditor"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f5,
· when: browserFocused && kb-macro.active && activeEditor == 'workbench.editor.browser',
· args: {"command":"workbench.action.browser.hardReload"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f5,
· when: debuggersAvailable && kb-macro.active && debugState != 'initializing',
· args: {"command":"workbench.action.debug.run"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f5,
· when: kb-macro.active && !debuggersAvailable,
· args: {"command":"debug.openView"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f9,
· when: chatIsEnabled && inChat && kb-macro.active,
· args: {"command":"workbench.action.chat.nextFileTree"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f11,
· when: inDebugMode && kb-macro.active && stepIntoTargetsSupported && debugState == 'stopped',
· args: {"command":"workbench.action.debug.stepIntoTarget"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f12,
· when: editorHasImplementationProvider && editorTextFocus && kb-macro.active,
· args: {"command":"editor.action.goToImplementation"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+f12,
· when: false,
· args: {"command":"editor.action.revealDefinition"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+g,
· when: kb-macro.active && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalFocus && terminalProcessSupported,
· args: {"command":"workbench.action.terminal.goToRecentDirectory"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+g,
· when: kb-macro.active,
· args: {"command":"workbench.action.gotoLine"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+h,
· when: editorFocus && kb-macro.active || editorIsOpen && kb-macro.active,
· args: {"command":"editor.action.startFindReplaceAction"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+h,
· when: false,
· args: {"command":"deleteLeft"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+home,
· when: accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal',
· args: {"command":"workbench.action.terminal.scrollToTopAccessibleView"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+home,
· when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree',
· args: {"command":"quickInput.first"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+home,
· when: kb-macro.active && activeEditor == 'workbench.editor.interactive',
· args: {"command":"interactive.scrollToTop"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+home,
· when: kb-macro.active && notebookEditorFocused && !inputFocus,
· args: {"command":"notebook.focusTop"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+home,
· when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive,
· args: {"command":"workbench.action.terminal.scrollToTop"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+home,
· when: kb-macro.active && textInputFocus,
· args: {"command":"cursorTop"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+i,
· when: aiSettingResultsAvailable && inSettingsEditor && kb-macro.active,
· args: {"command":"settings.action.toggleAiSearch"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+i,
· when: chatIsEnabled && hasSpeechProvider && inChatInput && kb-macro.active && !editorFocus && !notebookEditorFocused && !scopedVoiceChatGettingReady && !speechToTextInProgress || chatIsEnabled && hasSpeechProvider && inlineChatFocused && kb-macro.active && !editorFocus && !notebookEditorFocused && !scopedVoiceChatGettingReady && !speechToTextInProgress,
· args: {"command":"workbench.action.chat.startVoiceChat"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+i,
· when: chatIsEnabled && hasSpeechProvider && kb-macro.active && !chatSessionRequestInProgress && !editorFocus && !inChatInput && !inSettingsEditor && !inlineChatFocused && !notebookEditorFocused && !searchViewletFocus,
· args: {"command":"workbench.action.chat.holdToVoiceChatInChatView"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+i,
· when: chatIsEnabled && kb-macro.active && terminalChatAgentRegistered && terminalFocusInAny && terminalHasBeenCreated || chatIsEnabled && kb-macro.active && terminalChatAgentRegistered && terminalFocusInAny && terminalProcessSupported,
· args: {"command":"workbench.action.terminal.chat.start"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+i,
· when: config.inlineChat.askInChat && editorFocus && inlineChatFileBelongsToChat && inlineChatHasEditsAgent && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput || config.inlineChat.askInChat && editorFocus && inlineChatFileBelongsToChat && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || config.inlineChat.askInChat && editorFocus && inlineChatFileBelongsToChat && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook',
· args: {"command":"inlineChat.askInChat"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+i,
· when: config.notebook.experimental.cellChat && kb-macro.active && notebookChatAgentRegistered && notebookEditable && notebookEditorFocused && !inputFocus || config.notebook.experimental.generate && kb-macro.active && notebookChatAgentRegistered && notebookEditable && notebookEditorFocused && !inputFocus,
· args: {"command":"notebook.cell.chat.start"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+i,
· when: editorFocus && inlineChatHasEditsAgent && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput || editorFocus && inlineChatHasEditsAgent && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat || editorFocus && inlineChatHasEditsAgent && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat || editorFocus && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook',
· args: {"command":"inlineChat.start"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+i,
· when: editorHasCompletionItemProvider && kb-macro.active && textInputFocus && !editorReadonly && !suggestWidgetVisible,
· args: {"command":"editor.action.triggerSuggest","record":"side-effect"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+i,
· when: hasAIResultProviderKey && kb-macro.active && searchViewletFocus,
· args: {"command":"search.action.searchWithAI"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+i,
· when: inChatInput && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'editor' || inChatInput && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'inline' || inChatInput && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'quick' || inChatInput && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'view' || inlineChatFocused && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'editor' || inlineChatFocused && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'inline' || inlineChatFocused && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'quick' || inlineChatFocused && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'view',
· args: {"command":"workbench.action.chat.stopListeningAndSubmit"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+i,
· when: kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible,
· args: {"command":"workbench.action.terminal.suggestToggleDetails"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+i,
· when: kb-macro.active && suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus,
· args: {"command":"toggleSuggestionDetails","record":"side-effect"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+i,
· when: kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
· args: {"command":"focusSuggestion","record":"side-effect"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+insert,
· when: kb-macro.active && suggestWidgetDetailsFocused,
· args: {"command":"suggestWidgetCopy"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+insert,
· when: kb-macro.active,
· args: {"command":"editor.action.clipboardCopyAction","await":"clipboard"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+j,
· when: false,
· args: {"command":"editor.action.joinLines"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+j,
· when: kb-macro.active,
· args: {"command":"workbench.action.togglePanel"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+k c,
· when: kb-macro.active,
· args: {"command":"workbench.files.action.compareWithClipboard"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+k ctrl+,,
· when: editorTextFocus && foldingEnabled && kb-macro.active,
· args: {"command":"editor.createFoldingRangeFromSelection"},
* McsEngl.Vsccmnd.kb-macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: ctrl+k ctrl+-,
· when: editorTextFocus && foldingEnabled && kb-macro.active,
· args: {"command":"editor.foldAllExcept"},
* McsEngl.Vsccmnd.kb-macro.wrap,