overview of Vsccmdi

description::
× Mcsh-creation: {2026-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::
* McshEngl.VSCode-command-ID!⇒Vsccmdi,
* McshEngl.Vsccmdi!=VSCode-command-ID,
* McshEngl.Vsccmdi!@McshTchInf000042,
* McshEngl.McshTchInf000042.last.html//dirTchInf//dirMcsh!⇒Vsccmdi,
* McshEngl.dirTchInf/McshTchInf000042.last.html!⇒Vsccmdi,
* McshEngl.Vscdcmnd'ID!⇒Vsccmdi,

attribute::
* Vsccmdi'attribute,
===
* Vsccmdi:generic,
===
* Vsccmdi.specific,
===
* Vsccmdi//whole,
===
* Vsccmdi/part,
===
* Vsccmdi;;parent,
===
* Vsccmdi;child,

info-resource of Vsccmdi

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Vsccmdi'info_resource,

WHOLE-PART-TREE of Vsccmdi

description::
× Mcsh-creation: {2026-09-29}

name::
* McshEngl.Vsccmdi'whole_part_tree,

whole-tree::
* McshEngl.Vsccmdi//whole,
===
* Visual-Studio-Code,
* ...sympan//whole,

part-tree::
* McshEngl.Vsccmdi/part,
===

GENERIC-SPECIFIC-TREE of Vsccmdi

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Vsccmdi'generic_specific_tree,

generic-tree::
* McshEngl.Vsccmdi:generic,
===
* ...entity:generic,

specific-tree::
* McshEngl.Vsccmdi.specific,
===

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

===
* McshEngl.Vscdcmnd.runCommands,

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

===
* McshEngl.Vscdcmnd.type,

Vsccmdi.@azure.askAgentAboutResource,
===
* McshEngl.Vscdcmnd.@azure.askAgentAboutResource,

Vsccmdi.@azure.installAzureSkillsGlobally,
===
* McshEngl.Vscdcmnd.@azure.installAzureSkillsGlobally,

Vsccmdi.@azure.installAzureSkillsLocally,
===
* McshEngl.Vscdcmnd.@azure.installAzureSkillsLocally,

Vsccmdi.@azure.openBugReport,
===
* McshEngl.Vscdcmnd.@azure.openBugReport,

Vsccmdi.@azure.openFeatureRequest,
===
* McshEngl.Vscdcmnd.@azure.openFeatureRequest,

Vsccmdi.@azure.setGlobalStat,
===
* McshEngl.Vscdcmnd.@azure.setGlobalState,

Vsccmdi.@azure.showOutputChannel,
===
* McshEngl.Vscdcmnd.@azure.showOutputChannel,

Vsccmdi.@azure.uninstallAzureSkillsGlobally,
===
* McshEngl.Vscdcmnd.@azure.uninstallAzureSkillsGlobally,

Vsccmdi.@azure.viewGlobalState,
===
* McshEngl.Vscdcmnd.@azure.viewGlobalState,

Vsccmdi.acceptAlternativeSelectedSuggestion,
· key: shift+enter,
· when: suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus,
===
* McshEngl.Vscdcmnd.acceptAlternativeSelectedSuggestion,

Vsccmdi.acceptAlternativeSelectedSuggestion,
· key: shift+tab,
· when: suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus,
===
* McshEngl.Vscdcmnd.acceptAlternativeSelectedSuggestion,

Vsccmdi.acceptRenameInput,
· key: enter,
· when: editorFocus && renameInputVisible && !isComposing,
===
* McshEngl.Vscdcmnd.acceptRenameInput,

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

Vsccmdi.acceptSelectedCodeAction,
· key: ctrl+.,
· when: codeActionMenuVisible && kb-macro.active,
===
* McshEngl.Vscdcmnd.acceptSelectedCodeAction,

Vsccmdi.acceptSelectedCodeAction,
· key: ctrl+.,
· when: codeActionMenuVisible,
===
* McshEngl.Vscdcmnd.acceptSelectedCodeAction,

Vsccmdi.acceptSelectedCodeAction,
· key: enter,
· when: codeActionMenuVisible && kb-macro.active,
===
* McshEngl.Vscdcmnd.acceptSelectedCodeAction,

Vsccmdi.acceptSelectedCodeAction,
· key: enter,
· when: codeActionMenuVisible,
===
* McshEngl.Vscdcmnd.acceptSelectedCodeAction,

Vsccmdi.acceptSelectedSuggestion,
· key: enter,
· when: acceptSuggestionOnEnter && suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && suggestionMakesTextEdit && textInputFocus,
===
* McshEngl.Vscdcmnd.acceptSelectedSuggestion,

Vsccmdi.acceptSelectedSuggestion,
· key: tab,
· when: suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus,
===
* McshEngl.Vscdcmnd.acceptSelectedSuggestion,

Vsccmdi.acceptSelectedSuggestionOnEnter,
===
* McshEngl.Vscdcmnd.acceptSelectedSuggestionOnEnter,

Vsccmdi.acceptSnippet,
===
* McshEngl.Vscdcmnd.acceptSnippet,

Vsccmdi.accessibility.announcement.help,
===
* McshEngl.Vscdcmnd.accessibility.announcement.help,

Vsccmdi.actions.find,
· key: ctrl+f,
· when: editorFocus || editorIsOpen,
===
* McshEngl.Vscdcmnd.actions.find,

Vsccmdi.actions.findWithSelection,
===
* McshEngl.Vscdcmnd.actions.findWithSelection,

Vsccmdi.addCursorsAtSearchResults,
· key: ctrl+shift+l,
· when: fileMatchOrMatchFocus && searchViewletVisible,
===
* McshEngl.Vscdcmnd.addCursorsAtSearchResults,

Vsccmdi.addRootFolder,
===
* McshEngl.Vscdcmnd.addRootFolder,

Vsccmdi.agentSession.archive,
· key: delete,
· when: agentSessionsViewerFocused && !agentSessionIsArchived,
===
* McshEngl.Vscdcmnd.agentSession.archive,

Vsccmdi.agentSession.delete,
===
* McshEngl.Vscdcmnd.agentSession.delete,

Vsccmdi.agentSession.enterAgentSessionProjection,
===
* McshEngl.Vscdcmnd.agentSession.enterAgentSessionProjection,

Vsccmdi.agentSession.exitAgentSessionProjection,
· key: escape,
· when: chatInAgentSessionProjection && chatIsEnabled,
===
* McshEngl.Vscdcmnd.agentSession.exitAgentSessionProjection,

Vsccmdi.agentSession.markRead,
===
* McshEngl.Vscdcmnd.agentSession.markRead,

Vsccmdi.agentSession.markUnread,
===
* McshEngl.Vscdcmnd.agentSession.markUnread,

Vsccmdi.agentSession.pin,
===
* McshEngl.Vscdcmnd.agentSession.pin,

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

Vsccmdi.agentSession.unarchive,
· key: shift+delete,
· when: agentSessionIsArchived && agentSessionsViewerFocused,
===
* McshEngl.Vscdcmnd.agentSession.unarchive,

Vsccmdi.agentSession.unpin,
===
* McshEngl.Vscdcmnd.agentSession.unpin,

Vsccmdi.agentSessionSection.archive,
===
* McshEngl.Vscdcmnd.agentSessionSection.archive,

Vsccmdi.agentSessionSection.collapseAll,
===
* McshEngl.Vscdcmnd.agentSessionSection.collapseAll,

Vsccmdi.agentSessionSection.markRead,
===
* McshEngl.Vscdcmnd.agentSessionSection.markRead,

Vsccmdi.agentSessionSection.unarchive,
===
* McshEngl.Vscdcmnd.agentSessionSection.unarchive,

Vsccmdi.agentSessions.hideAgentSessionsSidebar,
===
* McshEngl.Vscdcmnd.agentSessions.hideAgentSessionsSidebar,

Vsccmdi.agentSessions.showAgentSessionsSidebar,
===
* McshEngl.Vscdcmnd.agentSessions.showAgentSessionsSidebar,

Vsccmdi.agentSessions.toggleAgentSessionsSidebar,
===
* McshEngl.Vscdcmnd.agentSessions.toggleAgentSessionsSidebar,

Vsccmdi.agentSessionsViewer.find,
===
* McshEngl.Vscdcmnd.agentSessionsViewer.find,

Vsccmdi.agentSessionsViewer.refresh,
===
* McshEngl.Vscdcmnd.agentSessionsViewer.refresh,

Vsccmdi.ai-mlstudio.addRemoteInferenceEndpoint,
===
* McshEngl.Vscdcmnd.ai_mlstudio.addRemoteInferenceEndpoint,

Vsccmdi.ai-mlstudio.agent-ghcp.add-eval,
===
* McshEngl.Vscdcmnd.ai_mlstudio.agent_ghcp.add_eval,

Vsccmdi.ai-mlstudio.agent-ghcp.create-agent,
===
* McshEngl.Vscdcmnd.ai_mlstudio.agent_ghcp.create_agent,

Vsccmdi.ai-mlstudio.agent-ghcp.enable-tracing,
===
* McshEngl.Vscdcmnd.ai_mlstudio.agent_ghcp.enable_tracing,

Vsccmdi.ai-mlstudio.agent-ghcp.new-workflow,
===
* McshEngl.Vscdcmnd.ai_mlstudio.agent_ghcp.new_workflow,

Vsccmdi.ai-mlstudio.agent-ghcp.orchestrate-foundry-agents,
===
* McshEngl.Vscdcmnd.ai_mlstudio.agent_ghcp.orchestrate_foundry_agents,

Vsccmdi.ai-mlstudio.agentBuilder,
===
* McshEngl.Vscdcmnd.ai_mlstudio.agentBuilder,

Vsccmdi.ai-mlstudio.command.submitEvaluation,
===
* McshEngl.Vscdcmnd.ai_mlstudio.command.submitEvaluation,

Vsccmdi.ai-mlstudio.commandPalette.addRemoteInferenceEndpoint,
===
* McshEngl.Vscdcmnd.ai_mlstudio.commandPalette.addRemoteInferenceEndpoint,

Vsccmdi.ai-mlstudio.copyGHAccessToken,
===
* McshEngl.Vscdcmnd.ai_mlstudio.copyGHAccessToken,

Vsccmdi.ai-mlstudio.createMcpToolConnection,
===
* McshEngl.Vscdcmnd.ai_mlstudio.createMcpToolConnection,

Vsccmdi.ai-mlstudio.createNewAgent,
===
* McshEngl.Vscdcmnd.ai_mlstudio.createNewAgent,

Vsccmdi.ai-mlstudio.deleteInferenceModel,
===
* McshEngl.Vscdcmnd.ai_mlstudio.deleteInferenceModel,

Vsccmdi.ai-mlstudio.deployHostedAgent,
===
* McshEngl.Vscdcmnd.ai_mlstudio.deployHostedAgent,

Vsccmdi.ai-mlstudio.deployInference,
===
* McshEngl.Vscdcmnd.ai_mlstudio.deployInference,

Vsccmdi.ai-mlstudio.documentation,
===
* McshEngl.Vscdcmnd.ai_mlstudio.documentation,

Vsccmdi.ai-mlstudio.downloadInferenceModel,
===
* McshEngl.Vscdcmnd.ai_mlstudio.downloadInferenceModel,

Vsccmdi.ai-mlstudio.editSecret,
===
* McshEngl.Vscdcmnd.ai_mlstudio.editSecret,

Vsccmdi.ai-mlstudio.encryptCustomModelValue,
===
* McshEngl.Vscdcmnd.ai_mlstudio.encryptCustomModelValue,

Vsccmdi.ai-mlstudio.evaluation.addCustomEvaluator,
===
* McshEngl.Vscdcmnd.ai_mlstudio.evaluation.addCustomEvaluator,

Vsccmdi.ai-mlstudio.evaluation.analyzeResults,
===
* McshEngl.Vscdcmnd.ai_mlstudio.evaluation.analyzeResults,

Vsccmdi.ai-mlstudio.evaluation.downloadRemoteResult,
===
* McshEngl.Vscdcmnd.ai_mlstudio.evaluation.downloadRemoteResult,

Vsccmdi.ai-mlstudio.evaluation.generateTestCases,
===
* McshEngl.Vscdcmnd.ai_mlstudio.evaluation.generateTestCases,

Vsccmdi.ai-mlstudio.evaluation.openDataset,
===
* McshEngl.Vscdcmnd.ai_mlstudio.evaluation.openDataset,

Vsccmdi.ai-mlstudio.evaluation.refreshAgentEvals,
===
* McshEngl.Vscdcmnd.ai_mlstudio.evaluation.refreshAgentEvals,

Vsccmdi.ai-mlstudio.evaluation.refreshRemoteResults,
===
* McshEngl.Vscdcmnd.ai_mlstudio.evaluation.refreshRemoteResults,

Vsccmdi.ai-mlstudio.evaluation.updateCustomEvaluator,
===
* McshEngl.Vscdcmnd.ai_mlstudio.evaluation.updateCustomEvaluator,

Vsccmdi.ai-mlstudio.generateProject,
===
* McshEngl.Vscdcmnd.ai_mlstudio.generateProject,

Vsccmdi.ai-mlstudio.generateProjectAndRefreshVSCodeWindow,
===
* McshEngl.Vscdcmnd.ai_mlstudio.generateProjectAndRefreshVSCodeWindow,

Vsccmdi.ai-mlstudio.getProjectSettings,
===
* McshEngl.Vscdcmnd.ai_mlstudio.getProjectSettings,

Vsccmdi.ai-mlstudio.installCondaWslLinux,
===
* McshEngl.Vscdcmnd.ai_mlstudio.installCondaWslLinux,

Vsccmdi.ai-mlstudio.installCudaWslLinux,
===
* McshEngl.Vscdcmnd.ai_mlstudio.installCudaWslLinux,

Vsccmdi.ai-mlstudio.installFoundrySkill,
===
* McshEngl.Vscdcmnd.ai_mlstudio.installFoundrySkill,

Vsccmdi.ai-mlstudio.internal.GHModelsDoc,
===
* McshEngl.Vscdcmnd.ai_mlstudio.internal.GHModelsDoc,

Vsccmdi.ai-mlstudio.joinCommunity,
===
* McshEngl.Vscdcmnd.ai_mlstudio.joinCommunity,

Vsccmdi.ai-mlstudio.mcp.addHttpServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.addHttpServer,

Vsccmdi.ai-mlstudio.mcp.addServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.addServer,

Vsccmdi.ai-mlstudio.mcp.addStdioServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.addStdioServer,

Vsccmdi.ai-mlstudio.mcp.cancelServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.cancelServer,

Vsccmdi.ai-mlstudio.mcp.configureFoundryServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.configureFoundryServer,

Vsccmdi.ai-mlstudio.mcp.connectToAgent,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.connectToAgent,

Vsccmdi.ai-mlstudio.mcp.createNewServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.createNewServer,

Vsccmdi.ai-mlstudio.mcp.editConfiguration,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.editConfiguration,

Vsccmdi.ai-mlstudio.mcp.editFoundryServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.editFoundryServer,

Vsccmdi.ai-mlstudio.mcp.openDocumentation,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.openDocumentation,

Vsccmdi.ai-mlstudio.mcp.refreshServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.refreshServer,

Vsccmdi.ai-mlstudio.mcp.removeAzureAISearchConnection,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.removeAzureAISearchConnection,

Vsccmdi.ai-mlstudio.mcp.removeBingConnection,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.removeBingConnection,

Vsccmdi.ai-mlstudio.mcp.removeFoundryServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.removeFoundryServer,

Vsccmdi.ai-mlstudio.mcp.removeServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.removeServer,

Vsccmdi.ai-mlstudio.mcp.startServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.startServer,

Vsccmdi.ai-mlstudio.mcp.stopServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.mcp.stopServer,

Vsccmdi.ai-mlstudio.modelComparison,
===
* McshEngl.Vscdcmnd.ai_mlstudio.modelComparison,

Vsccmdi.ai-mlstudio.modelLab.createFinetuningWorkspace,
===
* McshEngl.Vscdcmnd.ai_mlstudio.modelLab.createFinetuningWorkspace,

Vsccmdi.ai-mlstudio.modelLab.createWorkspace,
===
* McshEngl.Vscdcmnd.ai_mlstudio.modelLab.createWorkspace,

Vsccmdi.ai-mlstudio.modelLab.finetuningFirstEnterNewProj,
===
* McshEngl.Vscdcmnd.ai_mlstudio.modelLab.finetuningFirstEnterNewProj,

Vsccmdi.ai-mlstudio.modelLab.firstEnterNewProj,
===
* McshEngl.Vscdcmnd.ai_mlstudio.modelLab.firstEnterNewProj,

Vsccmdi.ai-mlstudio.modelLab.generationCompleted,
===
* McshEngl.Vscdcmnd.ai_mlstudio.modelLab.generationCompleted,

Vsccmdi.ai-mlstudio.modelLab.openFinetuningMetricsPage,
===
* McshEngl.Vscdcmnd.ai_mlstudio.modelLab.openFinetuningMetricsPage,

Vsccmdi.ai-mlstudio.modelLab.openFinetuningOverview,
===
* McshEngl.Vscdcmnd.ai_mlstudio.modelLab.openFinetuningOverview,

Vsccmdi.ai-mlstudio.modelLab.openProfiling,
===
* McshEngl.Vscdcmnd.ai_mlstudio.modelLab.openProfiling,

Vsccmdi.ai-mlstudio.modelLab.openWorkflow,
===
* McshEngl.Vscdcmnd.ai_mlstudio.modelLab.openWorkflow,

Vsccmdi.ai-mlstudio.modelPlayground,
===
* McshEngl.Vscdcmnd.ai_mlstudio.modelPlayground,

Vsccmdi.ai-mlstudio.models,
===
* McshEngl.Vscdcmnd.ai_mlstudio.models,

Vsccmdi.ai-mlstudio.openConversationHistory,
===
* McshEngl.Vscdcmnd.ai_mlstudio.openConversationHistory,

Vsccmdi.ai-mlstudio.openDataViewer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.openDataViewer,

Vsccmdi.ai-mlstudio.openDataset,
===
* McshEngl.Vscdcmnd.ai_mlstudio.openDataset,

Vsccmdi.ai-mlstudio.openEvaluationOverview,
===
* McshEngl.Vscdcmnd.ai_mlstudio.openEvaluationOverview,

Vsccmdi.ai-mlstudio.openFinetuningOverview,
===
* McshEngl.Vscdcmnd.ai_mlstudio.openFinetuningOverview,

Vsccmdi.ai-mlstudio.openHostedAgentPlayground,
===
* McshEngl.Vscdcmnd.ai_mlstudio.openHostedAgentPlayground,

Vsccmdi.ai-mlstudio.openModelCardMarkdown,
===
* McshEngl.Vscdcmnd.ai_mlstudio.openModelCardMarkdown,

Vsccmdi.ai-mlstudio.openModelLicense,
===
* McshEngl.Vscdcmnd.ai_mlstudio.openModelLicense,

Vsccmdi.ai-mlstudio.openTestTool,
===
* McshEngl.Vscdcmnd.ai_mlstudio.openTestTool,

Vsccmdi.ai-mlstudio.openTutorial,
===
* McshEngl.Vscdcmnd.ai_mlstudio.openTutorial,

Vsccmdi.ai-mlstudio.prepareEnvironment,
===
* McshEngl.Vscdcmnd.ai_mlstudio.prepareEnvironment,

Vsccmdi.ai-mlstudio.promptBuilder,
===
* McshEngl.Vscdcmnd.ai_mlstudio.promptBuilder,

Vsccmdi.ai-mlstudio.promptConsole,
===
* McshEngl.Vscdcmnd.ai_mlstudio.promptConsole,

Vsccmdi.ai-mlstudio.provision,
===
* McshEngl.Vscdcmnd.ai_mlstudio.provision,

Vsccmdi.ai-mlstudio.provisionInference,
===
* McshEngl.Vscdcmnd.ai_mlstudio.provisionInference,

Vsccmdi.ai-mlstudio.recentAgents.createInCode,
===
* McshEngl.Vscdcmnd.ai_mlstudio.recentAgents.createInCode,

Vsccmdi.ai-mlstudio.recentAgents.designWithBuilder,
===
* McshEngl.Vscdcmnd.ai_mlstudio.recentAgents.designWithBuilder,

Vsccmdi.ai-mlstudio.refreshVSCodeWindow,
===
* McshEngl.Vscdcmnd.ai_mlstudio.refreshVSCodeWindow,

Vsccmdi.ai-mlstudio.reportIssue,
===
* McshEngl.Vscdcmnd.ai_mlstudio.reportIssue,

Vsccmdi.ai-mlstudio.resetAllTokens,
===
* McshEngl.Vscdcmnd.ai_mlstudio.resetAllTokens,

Vsccmdi.ai-mlstudio.run,
===
* McshEngl.Vscdcmnd.ai_mlstudio.run,

Vsccmdi.ai-mlstudio.setGHAccessToken,
===
* McshEngl.Vscdcmnd.ai_mlstudio.setGHAccessToken,

Vsccmdi.ai-mlstudio.setHFAccessToken,
===
* McshEngl.Vscdcmnd.ai_mlstudio.setHFAccessToken,

Vsccmdi.ai-mlstudio.setTreeViewMode,
===
* McshEngl.Vscdcmnd.ai_mlstudio.setTreeViewMode,

Vsccmdi.ai-mlstudio.setupAIModel,
===
* McshEngl.Vscdcmnd.ai_mlstudio.setupAIModel,

Vsccmdi.ai-mlstudio.setupDatasetFlow,
===
* McshEngl.Vscdcmnd.ai_mlstudio.setupDatasetFlow,

Vsccmdi.ai-mlstudio.showJobOutputChannel,
===
* McshEngl.Vscdcmnd.ai_mlstudio.showJobOutputChannel,

Vsccmdi.ai-mlstudio.showOutputChannel,
===
* McshEngl.Vscdcmnd.ai_mlstudio.showOutputChannel,

Vsccmdi.ai-mlstudio.showWhatsNew,
===
* McshEngl.Vscdcmnd.ai_mlstudio.showWhatsNew,

Vsccmdi.ai-mlstudio.shutdownInferenceAgent,
===
* McshEngl.Vscdcmnd.ai_mlstudio.shutdownInferenceAgent,

Vsccmdi.ai-mlstudio.streamingLog,
===
* McshEngl.Vscdcmnd.ai_mlstudio.streamingLog,

Vsccmdi.ai-mlstudio.switchToFunctionalMode,
===
* McshEngl.Vscdcmnd.ai_mlstudio.switchToFunctionalMode,

Vsccmdi.ai-mlstudio.switchToFunctionalMode.active,
===
* McshEngl.Vscdcmnd.ai_mlstudio.switchToFunctionalMode.active,

Vsccmdi.ai-mlstudio.switchToLifecycleMode,
===
* McshEngl.Vscdcmnd.ai_mlstudio.switchToLifecycleMode,

Vsccmdi.ai-mlstudio.switchToLifecycleMode.active,
===
* McshEngl.Vscdcmnd.ai_mlstudio.switchToLifecycleMode.active,

Vsccmdi.ai-mlstudio.switchTreeViewMode,
===
* McshEngl.Vscdcmnd.ai_mlstudio.switchTreeViewMode,

Vsccmdi.ai-mlstudio.test.happyPath,
===
* McshEngl.Vscdcmnd.ai_mlstudio.test.happyPath,

Vsccmdi.ai-mlstudio.toolCatalog,
===
* McshEngl.Vscdcmnd.ai_mlstudio.toolCatalog,

Vsccmdi.ai-mlstudio.tracing.open,
===
* McshEngl.Vscdcmnd.ai_mlstudio.tracing.open,

Vsccmdi.ai-mlstudio.tracing.openFoundryTrace,
===
* McshEngl.Vscdcmnd.ai_mlstudio.tracing.openFoundryTrace,

Vsccmdi.ai-mlstudio.tracing.showStatus,
===
* McshEngl.Vscdcmnd.ai_mlstudio.tracing.showStatus,

Vsccmdi.ai-mlstudio.tracing.startCollector,
===
* McshEngl.Vscdcmnd.ai_mlstudio.tracing.startCollector,

Vsccmdi.ai-mlstudio.tracing.stopCollector,
===
* McshEngl.Vscdcmnd.ai_mlstudio.tracing.stopCollector,

Vsccmdi.ai-mlstudio.tracingViewer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.tracingViewer,

Vsccmdi.ai-mlstudio.treeView.agents.deleteAgent,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.agents.deleteAgent,

Vsccmdi.ai-mlstudio.treeView.agents.deleteAgentVersion,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.agents.deleteAgentVersion,

Vsccmdi.ai-mlstudio.treeView.agents.designWithBuilder,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.agents.designWithBuilder,

Vsccmdi.ai-mlstudio.treeView.agents.refreshFoundryAgents,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.agents.refreshFoundryAgents,

Vsccmdi.ai-mlstudio.treeView.agents.refreshLocalAgents,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.agents.refreshLocalAgents,

Vsccmdi.ai-mlstudio.treeView.agents.renameAgent,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.agents.renameAgent,

Vsccmdi.ai-mlstudio.treeView.agents.renameAgentVersion,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.agents.renameAgentVersion,

Vsccmdi.ai-mlstudio.treeView.evaluation.openInDataViewer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.evaluation.openInDataViewer,

Vsccmdi.ai-mlstudio.treeView.models.about,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.about,

Vsccmdi.ai-mlstudio.treeView.models.addRemoteInferenceEndpoint,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.addRemoteInferenceEndpoint,

Vsccmdi.ai-mlstudio.treeView.models.cancelDownloading,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.cancelDownloading,

Vsccmdi.ai-mlstudio.treeView.models.click,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.click,

Vsccmdi.ai-mlstudio.treeView.models.copyEndpoint,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.copyEndpoint,

Vsccmdi.ai-mlstudio.treeView.models.copyModelName,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.copyModelName,

Vsccmdi.ai-mlstudio.treeView.models.createFineTuneProject,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.createFineTuneProject,

Vsccmdi.ai-mlstudio.treeView.models.delete,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.delete,

Vsccmdi.ai-mlstudio.treeView.models.edit,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.edit,

Vsccmdi.ai-mlstudio.treeView.models.foundry.selectProject,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.foundry.selectProject,

Vsccmdi.ai-mlstudio.treeView.models.loadInAgentBuilder,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.loadInAgentBuilder,

Vsccmdi.ai-mlstudio.treeView.models.loadInPlayground,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.loadInPlayground,

Vsccmdi.ai-mlstudio.treeView.models.refresh,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.refresh,

Vsccmdi.ai-mlstudio.treeView.models.remoteInferenceInPlaygroundDocs,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.remoteInferenceInPlaygroundDocs,

Vsccmdi.ai-mlstudio.treeView.models.startServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.startServer,

Vsccmdi.ai-mlstudio.treeView.models.stopServer,
===
* McshEngl.Vscdcmnd.ai_mlstudio.treeView.models.stopServer,

Vsccmdi.ai-mlstudio.triggerFoundryModelDeployment,
===
* McshEngl.Vscdcmnd.ai_mlstudio.triggerFoundryModelDeployment,

Vsccmdi.ai-mlstudio.tutorials,
===
* McshEngl.Vscdcmnd.ai_mlstudio.tutorials,

Vsccmdi.ai-mlstudio.unloadInferenceModel,
===
* McshEngl.Vscdcmnd.ai_mlstudio.unloadInferenceModel,

Vsccmdi.ai-mlstudio.view.evaluation.focus,
===
* McshEngl.Vscdcmnd.ai_mlstudio.view.evaluation.focus,

Vsccmdi.ai-mlstudio.view.evaluation.removeView,
===
* McshEngl.Vscdcmnd.ai_mlstudio.view.evaluation.removeView,

Vsccmdi.ai-mlstudio.view.evaluation.resetViewLocation,
===
* McshEngl.Vscdcmnd.ai_mlstudio.view.evaluation.resetViewLocation,

Vsccmdi.ai-mlstudio.view.evaluation.toggleVisibility,
===
* McshEngl.Vscdcmnd.ai_mlstudio.view.evaluation.toggleVisibility,

Vsccmdi.ai-mlstudio.viewPrompts,
===
* McshEngl.Vscdcmnd.ai_mlstudio.viewPrompts,

Vsccmdi.ai-mlstudio.walkthrough.installCopilotChat,
===
* McshEngl.Vscdcmnd.ai_mlstudio.walkthrough.installCopilotChat,

Vsccmdi.ai-mlstudio.walkthrough.openGetStartedPage,
===
* McshEngl.Vscdcmnd.ai_mlstudio.walkthrough.openGetStartedPage,

Vsccmdi.ai-mlstudio.walkthrough.showAllCommands,
===
* McshEngl.Vscdcmnd.ai_mlstudio.walkthrough.showAllCommands,

Vsccmdi.ai-mlstudio.walkthrough.signInFoundry,
===
* McshEngl.Vscdcmnd.ai_mlstudio.walkthrough.signInFoundry,

Vsccmdi.ai-mlstudio.walkthrough.tryRemoteModel,
===
* McshEngl.Vscdcmnd.ai_mlstudio.walkthrough.tryRemoteModel,

Vsccmdi.aiCustomization.openManagementEditor,
===
* McshEngl.Vscdcmnd.aiCustomization.openManagementEditor,

Vsccmdi.aiCustomizationManagement.copyPath,
===
* McshEngl.Vscdcmnd.aiCustomizationManagement.copyPath,

Vsccmdi.aiCustomizationManagement.delete,
===
* McshEngl.Vscdcmnd.aiCustomizationManagement.delete,

Vsccmdi.aiCustomizationManagement.disableItem,
===
* McshEngl.Vscdcmnd.aiCustomizationManagement.disableItem,

Vsccmdi.aiCustomizationManagement.enableItem,
===
* McshEngl.Vscdcmnd.aiCustomizationManagement.enableItem,

Vsccmdi.aiCustomizationManagement.openFile,
===
* McshEngl.Vscdcmnd.aiCustomizationManagement.openFile,

Vsccmdi.aiCustomizationManagement.revealInOS,
===
* McshEngl.Vscdcmnd.aiCustomizationManagement.revealInOS,

Vsccmdi.aiCustomizationManagement.runPrompt,
===
* McshEngl.Vscdcmnd.aiCustomizationManagement.runPrompt,

Vsccmdi.aiCustomizationManagement.showPlugin,
===
* McshEngl.Vscdcmnd.aiCustomizationManagement.showPlugin,

Vsccmdi.aiCustomizationManagement.uninstallPlugin,
===
* McshEngl.Vscdcmnd.aiCustomizationManagement.uninstallPlugin,

Vsccmdi.aiToolkitHelpAndFeedback.focus,
===
* McshEngl.Vscdcmnd.aiToolkitHelpAndFeedback.focus,

Vsccmdi.aiToolkitHelpAndFeedback.removeView,
===
* McshEngl.Vscdcmnd.aiToolkitHelpAndFeedback.removeView,

Vsccmdi.aiToolkitHelpAndFeedback.resetViewLocation,
===
* McshEngl.Vscdcmnd.aiToolkitHelpAndFeedback.resetViewLocation,

Vsccmdi.aiToolkitHelpAndFeedback.toggleVisibility,
===
* McshEngl.Vscdcmnd.aiToolkitHelpAndFeedback.toggleVisibility,

Vsccmdi.aiToolkitRemoteResources.focus,
===
* McshEngl.Vscdcmnd.aiToolkitRemoteResources.focus,

Vsccmdi.aiToolkitRemoteResources.removeView,
===
* McshEngl.Vscdcmnd.aiToolkitRemoteResources.removeView,

Vsccmdi.aiToolkitRemoteResources.resetViewLocation,
===
* McshEngl.Vscdcmnd.aiToolkitRemoteResources.resetViewLocation,

Vsccmdi.aiToolkitRemoteResources.toggleVisibility,
===
* McshEngl.Vscdcmnd.aiToolkitRemoteResources.toggleVisibility,

Vsccmdi.aiToolkitUserTools.focus,
===
* McshEngl.Vscdcmnd.aiToolkitUserTools.focus,

Vsccmdi.aiToolkitUserTools.removeView,
===
* McshEngl.Vscdcmnd.aiToolkitUserTools.removeView,

Vsccmdi.aiToolkitUserTools.resetViewLocation,
===
* McshEngl.Vscdcmnd.aiToolkitUserTools.resetViewLocation,

Vsccmdi.aiToolkitUserTools.toggleVisibility,
===
* McshEngl.Vscdcmnd.aiToolkitUserTools.toggleVisibility,

Vsccmdi.azure-ai-foundry.commandPalette.clearDefault,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.clearDefault,

Vsccmdi.azure-ai-foundry.commandPalette.createMultiAgentWorkflow,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.createMultiAgentWorkflow,

Vsccmdi.azure-ai-foundry.commandPalette.createProject,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.createProject,

Vsccmdi.azure-ai-foundry.commandPalette.deleteThread,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.deleteThread,

Vsccmdi.azure-ai-foundry.commandPalette.deployWorkflow,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.deployWorkflow,

Vsccmdi.azure-ai-foundry.commandPalette.llmDeploy,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.llmDeploy,

Vsccmdi.azure-ai-foundry.commandPalette.model.copyApiKey,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.model.copyApiKey,

Vsccmdi.azure-ai-foundry.commandPalette.model.copyEndpoint,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.model.copyEndpoint,

Vsccmdi.azure-ai-foundry.commandPalette.model.delete,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.model.delete,

Vsccmdi.azure-ai-foundry.commandPalette.model.edit,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.model.edit,

Vsccmdi.azure-ai-foundry.commandPalette.openAgentCodeFile,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.openAgentCodeFile,

Vsccmdi.azure-ai-foundry.commandPalette.openCatalog,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.openCatalog,

Vsccmdi.azure-ai-foundry.commandPalette.openConversationHistory,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.openConversationHistory,

Vsccmdi.azure-ai-foundry.commandPalette.openModelCodeFile,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.openModelCodeFile,

Vsccmdi.azure-ai-foundry.commandPalette.project.copyApiKey,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.project.copyApiKey,

Vsccmdi.azure-ai-foundry.commandPalette.project.copyEndpoint,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.project.copyEndpoint,

Vsccmdi.azure-ai-foundry.commandPalette.runAgent,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.runAgent,

Vsccmdi.azure-ai-foundry.commandPalette.runInContainerAgentPlayground,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.runInContainerAgentPlayground,

Vsccmdi.azure-ai-foundry.commandPalette.setDefault,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.setDefault,

Vsccmdi.azure-ai-foundry.commandPalette.stopMultiAgentVisualizer,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.stopMultiAgentVisualizer,

Vsccmdi.azure-ai-foundry.commandPalette.visualizeWorkflow,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.commandPalette.visualizeWorkflow,

Vsccmdi.azure-ai-foundry.editorTitle.deployPromptAgent,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.editorTitle.deployPromptAgent,

Vsccmdi.azure-ai-foundry.editorTitle.deployYamlWorkflow,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.editorTitle.deployYamlWorkflow,

Vsccmdi.azure-ai-foundry.editorTitle.openAgentDesigner,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.editorTitle.openAgentDesigner,

Vsccmdi.azure-ai-foundry.explorerContext.openAgentDesigner,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.explorerContext.openAgentDesigner,

Vsccmdi.azure-ai-foundry.listModels,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.listModels,

Vsccmdi.azure-ai-foundry.openAIFoundry,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.openAIFoundry,

Vsccmdi.azure-ai-foundry.openBingConnectionDetails,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.openBingConnectionDetails,

Vsccmdi.azure-ai-foundry.openExternalLink,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.openExternalLink,

Vsccmdi.azure-ai-foundry.openFoundryProject,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.openFoundryProject,

Vsccmdi.azure-ai-foundry.openInVSCodeAzure,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.openInVSCodeAzure,

Vsccmdi.azure-ai-foundry.openVectorStoreDetails,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.openVectorStoreDetails,

Vsccmdi.azure-ai-foundry.reportIssue,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.reportIssue,

Vsccmdi.azure-ai-foundry.viewContext.agent.copyConnectionString,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.agent.copyConnectionString,

Vsccmdi.azure-ai-foundry.viewContext.agent.copyEndpoint,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.agent.copyEndpoint,

Vsccmdi.azure-ai-foundry.viewContext.agent.copyId,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.agent.copyId,

Vsccmdi.azure-ai-foundry.viewContext.agent.delete,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.agent.delete,

Vsccmdi.azure-ai-foundry.viewContext.createAgent,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.createAgent,

Vsccmdi.azure-ai-foundry.viewContext.createBingConnection,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.createBingConnection,

Vsccmdi.azure-ai-foundry.viewContext.createMultiAgentWorkflow,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.createMultiAgentWorkflow,

Vsccmdi.azure-ai-foundry.viewContext.createPromptAgent,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.createPromptAgent,

Vsccmdi.azure-ai-foundry.viewContext.createVectorStore,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.createVectorStore,

Vsccmdi.azure-ai-foundry.viewContext.deleteProject,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.deleteProject,

Vsccmdi.azure-ai-foundry.viewContext.deletePromptAgent,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.deletePromptAgent,

Vsccmdi.azure-ai-foundry.viewContext.deletePromptAgentVersion,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.deletePromptAgentVersion,

Vsccmdi.azure-ai-foundry.viewContext.deleteTool,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.deleteTool,

Vsccmdi.azure-ai-foundry.viewContext.deleteYamlWorkflow,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.deleteYamlWorkflow,

Vsccmdi.azure-ai-foundry.viewContext.deleteYamlWorkflowVersion,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.deleteYamlWorkflowVersion,

Vsccmdi.azure-ai-foundry.viewContext.llmDeploy,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.llmDeploy,

Vsccmdi.azure-ai-foundry.viewContext.loadMoreThreads,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.loadMoreThreads,

Vsccmdi.azure-ai-foundry.viewContext.model.copyApiKey,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.model.copyApiKey,

Vsccmdi.azure-ai-foundry.viewContext.model.copyEndpoint,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.model.copyEndpoint,

Vsccmdi.azure-ai-foundry.viewContext.model.delete,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.model.delete,

Vsccmdi.azure-ai-foundry.viewContext.model.openInPlayground,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.model.openInPlayground,

Vsccmdi.azure-ai-foundry.viewContext.openAgentCodeFile,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.openAgentCodeFile,

Vsccmdi.azure-ai-foundry.viewContext.openAgentDesigner,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.openAgentDesigner,

Vsccmdi.azure-ai-foundry.viewContext.openContainerPlayground,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.openContainerPlayground,

Vsccmdi.azure-ai-foundry.viewContext.openHostedAgentCodeFile,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.openHostedAgentCodeFile,

Vsccmdi.azure-ai-foundry.viewContext.openInFoundryView,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.openInFoundryView,

Vsccmdi.azure-ai-foundry.viewContext.openMCPServerToolCatalog,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.openMCPServerToolCatalog,

Vsccmdi.azure-ai-foundry.viewContext.openModelCodeFile,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.openModelCodeFile,

Vsccmdi.azure-ai-foundry.viewContext.openPromptAgentCodeFile,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.openPromptAgentCodeFile,

Vsccmdi.azure-ai-foundry.viewContext.openPromptAgentPlayground,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.openPromptAgentPlayground,

Vsccmdi.azure-ai-foundry.viewContext.openYamlBasedWorkflowCodeFile,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.openYamlBasedWorkflowCodeFile,

Vsccmdi.azure-ai-foundry.viewContext.openYamlWorkflowPlayground,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.openYamlWorkflowPlayground,

Vsccmdi.azure-ai-foundry.viewContext.project.copyApiKey,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.project.copyApiKey,

Vsccmdi.azure-ai-foundry.viewContext.refreshNode,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.refreshNode,

Vsccmdi.azure-ai-foundry.viewContext.refreshResources,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.refreshResources,

Vsccmdi.azure-ai-foundry.viewContext.runRemotePlayground,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.runRemotePlayground,

Vsccmdi.azure-ai-foundry.viewContext.searchProjectResources.aiToolkitView,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.searchProjectResources.aiToolkitView,

Vsccmdi.azure-ai-foundry.viewContext.searchProjectResources.explorerView,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.searchProjectResources.explorerView,

Vsccmdi.azure-ai-foundry.viewContext.searchProjectResources.resourcesView,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.searchProjectResources.resourcesView,

Vsccmdi.azure-ai-foundry.viewContext.switchDefaultProject,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.switchDefaultProject,

Vsccmdi.azure-ai-foundry.viewContext.viewModel,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.viewModel,

Vsccmdi.azure-ai-foundry.viewContext.viewThreadDetails,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.viewThreadDetails,

Vsccmdi.azure-ai-foundry.viewContext.viewWorkflowContainer,
===
* McshEngl.Vscdcmnd.azure_ai_foundry.viewContext.viewWorkflowContainer,

Vsccmdi.azureActivityLog.focus,
===
* McshEngl.Vscdcmnd.azureActivityLog.focus,

Vsccmdi.azureActivityLog.removeView,
===
* McshEngl.Vscdcmnd.azureActivityLog.removeView,

Vsccmdi.azureActivityLog.resetViewLocation,
===
* McshEngl.Vscdcmnd.azureActivityLog.resetViewLocation,

Vsccmdi.azureActivityLog.toggleVisibility,
===
* McshEngl.Vscdcmnd.azureActivityLog.toggleVisibility,

Vsccmdi.azureActivityLogView.refresh,
===
* McshEngl.Vscdcmnd.azureActivityLogView.refresh,

Vsccmdi.azureFocusView.focus,
===
* McshEngl.Vscdcmnd.azureFocusView.focus,

Vsccmdi.azureFocusView.refresh,
===
* McshEngl.Vscdcmnd.azureFocusView.refresh,

Vsccmdi.azureFocusView.refreshTree,
===
* McshEngl.Vscdcmnd.azureFocusView.refreshTree,

Vsccmdi.azureFocusView.resetViewLocation,
===
* McshEngl.Vscdcmnd.azureFocusView.resetViewLocation,

Vsccmdi.azureResourceGroups.askAgentAboutActivityLog,
===
* McshEngl.Vscdcmnd.azureResourceGroups.askAgentAboutActivityLog,

Vsccmdi.azureResourceGroups.askAgentAboutActivityLogItem,
===
* McshEngl.Vscdcmnd.azureResourceGroups.askAgentAboutActivityLogItem,

Vsccmdi.azureResourceGroups.askAgentAboutResource,
===
* McshEngl.Vscdcmnd.azureResourceGroups.askAgentAboutResource,

Vsccmdi.azureResourceGroups.askAzure,
===
* McshEngl.Vscdcmnd.azureResourceGroups.askAzure,

Vsccmdi.azureResourceGroups.clearActivities,
===
* McshEngl.Vscdcmnd.azureResourceGroups.clearActivities,

Vsccmdi.azureResourceGroups.createResource,
===
* McshEngl.Vscdcmnd.azureResourceGroups.createResource,

Vsccmdi.azureResourceGroups.createResourceGroup,
===
* McshEngl.Vscdcmnd.azureResourceGroups.createResourceGroup,

Vsccmdi.azureResourceGroups.deleteResourceGroupV2,
===
* McshEngl.Vscdcmnd.azureResourceGroups.deleteResourceGroupV2,

Vsccmdi.azureResourceGroups.editTags,
===
* McshEngl.Vscdcmnd.azureResourceGroups.editTags,

Vsccmdi.azureResourceGroups.focus,
===
* McshEngl.Vscdcmnd.azureResourceGroups.focus,

Vsccmdi.azureResourceGroups.focusGroup,
===
* McshEngl.Vscdcmnd.azureResourceGroups.focusGroup,

Vsccmdi.azureResourceGroups.groupBy.armTag,
===
* McshEngl.Vscdcmnd.azureResourceGroups.groupBy.armTag,

Vsccmdi.azureResourceGroups.groupBy.location,
===
* McshEngl.Vscdcmnd.azureResourceGroups.groupBy.location,

Vsccmdi.azureResourceGroups.groupBy.resourceGroup,
===
* McshEngl.Vscdcmnd.azureResourceGroups.groupBy.resourceGroup,

Vsccmdi.azureResourceGroups.groupBy.resourceType,
===
* McshEngl.Vscdcmnd.azureResourceGroups.groupBy.resourceType,

Vsccmdi.azureResourceGroups.installExtension,
===
* McshEngl.Vscdcmnd.azureResourceGroups.installExtension,

Vsccmdi.azureResourceGroups.loadAllSubscriptionRoleAssignments,
===
* McshEngl.Vscdcmnd.azureResourceGroups.loadAllSubscriptionRoleAssignments,

Vsccmdi.azureResourceGroups.loadMore,
===
* McshEngl.Vscdcmnd.azureResourceGroups.loadMore,

Vsccmdi.azureResourceGroups.logIn,
===
* McshEngl.Vscdcmnd.azureResourceGroups.logIn,

Vsccmdi.azureResourceGroups.openInPortal,
===
* McshEngl.Vscdcmnd.azureResourceGroups.openInPortal,

Vsccmdi.azureResourceGroups.openUrl,
===
* McshEngl.Vscdcmnd.azureResourceGroups.openUrl,

Vsccmdi.azureResourceGroups.refresh,
===
* McshEngl.Vscdcmnd.azureResourceGroups.refresh,

Vsccmdi.azureResourceGroups.refreshTree,
===
* McshEngl.Vscdcmnd.azureResourceGroups.refreshTree,

Vsccmdi.azureResourceGroups.removeView,
===
* McshEngl.Vscdcmnd.azureResourceGroups.removeView,

Vsccmdi.azureResourceGroups.reportIssue,
===
* McshEngl.Vscdcmnd.azureResourceGroups.reportIssue,

Vsccmdi.azureResourceGroups.resetViewLocation,
===
* McshEngl.Vscdcmnd.azureResourceGroups.resetViewLocation,

Vsccmdi.azureResourceGroups.revealResource,
===
* McshEngl.Vscdcmnd.azureResourceGroups.revealResource,

Vsccmdi.azureResourceGroups.selectSubscriptions,
===
* McshEngl.Vscdcmnd.azureResourceGroups.selectSubscriptions,

Vsccmdi.azureResourceGroups.showGroupOptions,
===
* McshEngl.Vscdcmnd.azureResourceGroups.showGroupOptions,

Vsccmdi.azureResourceGroups.signInToTenant,
===
* McshEngl.Vscdcmnd.azureResourceGroups.signInToTenant,

Vsccmdi.azureResourceGroups.toggleVisibility,
===
* McshEngl.Vscdcmnd.azureResourceGroups.toggleVisibility,

Vsccmdi.azureResourceGroups.unfocusGroup,
===
* McshEngl.Vscdcmnd.azureResourceGroups.unfocusGroup,

Vsccmdi.azureResourceGroups.uploadFileCloudConsole,
===
* McshEngl.Vscdcmnd.azureResourceGroups.uploadFileCloudConsole,

Vsccmdi.azureResourceGroups.viewProperties,
===
* McshEngl.Vscdcmnd.azureResourceGroups.viewProperties,

Vsccmdi.azureTenantsView.addAccount,
===
* McshEngl.Vscdcmnd.azureTenantsView.addAccount,

Vsccmdi.azureTenantsView.configureSovereignCloud,
===
* McshEngl.Vscdcmnd.azureTenantsView.configureSovereignCloud,

Vsccmdi.azureTenantsView.focus,
===
* McshEngl.Vscdcmnd.azureTenantsView.focus,

Vsccmdi.azureTenantsView.refresh,
===
* McshEngl.Vscdcmnd.azureTenantsView.refresh,

Vsccmdi.azureTenantsView.refreshTree,
===
* McshEngl.Vscdcmnd.azureTenantsView.refreshTree,

Vsccmdi.azureTenantsView.removeView,
===
* McshEngl.Vscdcmnd.azureTenantsView.removeView,

Vsccmdi.azureTenantsView.resetViewLocation,
===
* McshEngl.Vscdcmnd.azureTenantsView.resetViewLocation,

Vsccmdi.azureTenantsView.signInToTenant,
===
* McshEngl.Vscdcmnd.azureTenantsView.signInToTenant,

Vsccmdi.azureTenantsView.toggleVisibility,
===
* McshEngl.Vscdcmnd.azureTenantsView.toggleVisibility,

Vsccmdi.azureWorkspace.focus,
===
* McshEngl.Vscdcmnd.azureWorkspace.focus,

Vsccmdi.azureWorkspace.loadMore,
===
* McshEngl.Vscdcmnd.azureWorkspace.loadMore,

Vsccmdi.azureWorkspace.refresh,
===
* McshEngl.Vscdcmnd.azureWorkspace.refresh,

Vsccmdi.azureWorkspace.refreshTree,
===
* McshEngl.Vscdcmnd.azureWorkspace.refreshTree,

Vsccmdi.azureWorkspace.removeView,
===
* McshEngl.Vscdcmnd.azureWorkspace.removeView,

Vsccmdi.azureWorkspace.resetViewLocation,
===
* McshEngl.Vscdcmnd.azureWorkspace.resetViewLocation,

Vsccmdi.azureWorkspace.toggleVisibility,
===
* McshEngl.Vscdcmnd.azureWorkspace.toggleVisibility,

Vsccmdi.breadcrumbs.copyPath,
===
* McshEngl.Vscdcmnd.breadcrumbs.copyPath,

Vsccmdi.breadcrumbs.focus,
· key: ctrl+shift+;,
· when: breadcrumbsPossible && breadcrumbsVisible,
===
* McshEngl.Vscdcmnd.breadcrumbs.focus,

Vsccmdi.breadcrumbs.focusAndSelect,
· key: ctrl+shift+.,
· when: breadcrumbsPossible && breadcrumbsVisible,
===
* McshEngl.Vscdcmnd.breadcrumbs.focusAndSelect,

Vsccmdi.breadcrumbs.focusNext,
· key: ctrl+right,
· when: breadcrumbsActive && breadcrumbsVisible,
===
* McshEngl.Vscdcmnd.breadcrumbs.focusNext,

Vsccmdi.breadcrumbs.focusNext,
· key: right,
· when: breadcrumbsActive && breadcrumbsVisible,
===
* McshEngl.Vscdcmnd.breadcrumbs.focusNext,

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

Vsccmdi.breadcrumbs.focusPrevious,
· key: ctrl+left,
· when: breadcrumbsActive && breadcrumbsVisible,
===
* McshEngl.Vscdcmnd.breadcrumbs.focusPrevious,

Vsccmdi.breadcrumbs.focusPrevious,
· key: left,
· when: breadcrumbsActive && breadcrumbsVisible,
===
* McshEngl.Vscdcmnd.breadcrumbs.focusPrevious,

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

Vsccmdi.breadcrumbs.revealFocused,
· key: ctrl+enter,
· when: breadcrumbsActive && breadcrumbsVisible,
===
* McshEngl.Vscdcmnd.breadcrumbs.revealFocused,

Vsccmdi.breadcrumbs.revealFocused,
· key: space,
· when: breadcrumbsActive && breadcrumbsVisible,
===
* McshEngl.Vscdcmnd.breadcrumbs.revealFocused,

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

Vsccmdi.breadcrumbs.selectEditor,
· key: escape,
· when: breadcrumbsActive && breadcrumbsVisible,
===
* McshEngl.Vscdcmnd.breadcrumbs.selectEditor,

Vsccmdi.breadcrumbs.selectFocused,
· key: down,
· when: breadcrumbsActive && breadcrumbsVisible,
===
* McshEngl.Vscdcmnd.breadcrumbs.selectFocused,

Vsccmdi.breadcrumbs.selectFocused,
· key: enter,
· when: breadcrumbsActive && breadcrumbsVisible,
===
* McshEngl.Vscdcmnd.breadcrumbs.selectFocused,

Vsccmdi.breadcrumbs.toggle,
===
* McshEngl.Vscdcmnd.breadcrumbs.toggle,

Vsccmdi.breadcrumbs.toggleFromEditorTitle,
===
* McshEngl.Vscdcmnd.breadcrumbs.toggleFromEditorTitle,

Vsccmdi.breadcrumbs.toggleToOn,
· key: ctrl+shift+.,
· when: !config.breadcrumbs.enabled,
===
* McshEngl.Vscdcmnd.breadcrumbs.toggleToOn,

Vsccmdi.breakpointWidget.action.acceptInput,
· key: enter,
· when: breakpointWidgetVisible && inBreakpointWidget,
===
* McshEngl.Vscdcmnd.breakpointWidget.action.acceptInput,

Vsccmdi.callStack.collapse,
===
* McshEngl.Vscdcmnd.callStack.collapse,

Vsccmdi.callStackWidget.goToFile,
===
* McshEngl.Vscdcmnd.callStackWidget.goToFile,

Vsccmdi.cancelLinkedEditingInput,
· key: escape,
· when: LinkedEditingInputVisible && editorTextFocus,
===
* McshEngl.Vscdcmnd.cancelLinkedEditingInput,

Vsccmdi.cancelLinkedEditingInput,
· key: shift+escape,
· when: LinkedEditingInputVisible && editorTextFocus,
===
* McshEngl.Vscdcmnd.cancelLinkedEditingInput,

Vsccmdi.cancelRenameInput,
· key: escape,
· when: editorFocus && renameInputVisible,
===
* McshEngl.Vscdcmnd.cancelRenameInput,

Vsccmdi.cancelRenameInput,
· key: shift+escape,
· when: editorFocus && renameInputVisible,
===
* McshEngl.Vscdcmnd.cancelRenameInput,

Vsccmdi.cancelSelection,
· key: escape,
· when: editorHasSelection && textInputFocus,
===
* McshEngl.Vscdcmnd.cancelSelection,

Vsccmdi.cancelSelection,
· key: shift+escape,
· when: editorHasSelection && textInputFocus,
===
* McshEngl.Vscdcmnd.cancelSelection,

Vsccmdi.changeEditorIndentation1,
===
* McshEngl.Vscdcmnd.changeEditorIndentation1,

Vsccmdi.chat.action.focus,
· key: ctrl+down,
· when: inChat && inChatInput && quickChatHasFocus,
===
* McshEngl.Vscdcmnd.chat.action.focus,

Vsccmdi.chat.action.focus,
· key: ctrl+up,
· when: chatCursorAtTop && inChatInput && !quickChatHasFocus,
===
* McshEngl.Vscdcmnd.chat.action.focus,

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

Vsccmdi.chat.configureToolSets,
===
* McshEngl.Vscdcmnd.chat.configureToolSets,

Vsccmdi.chat.enablePremiumOverages,
===
* McshEngl.Vscdcmnd.chat.enablePremiumOverages,

Vsccmdi.chat.inlineResourceAnchor.addFileToChat,
===
* McshEngl.Vscdcmnd.chat.inlineResourceAnchor.addFileToChat,

Vsccmdi.chat.inlineResourceAnchor.copyResource,
· key: ctrl+c,
· when: chatAttachmentResource,
===
* McshEngl.Vscdcmnd.chat.inlineResourceAnchor.copyResource,

Vsccmdi.chat.inlineResourceAnchor.openToSide,
· key: ctrl+enter,
· when: chatAttachmentResource,
===
* McshEngl.Vscdcmnd.chat.inlineResourceAnchor.openToSide,

Vsccmdi.chat.inlineSymbolAnchor.goToDefinition,
===
* McshEngl.Vscdcmnd.chat.inlineSymbolAnchor.goToDefinition,

Vsccmdi.chat.inlineSymbolAnchor.goToImplementations,
===
* McshEngl.Vscdcmnd.chat.inlineSymbolAnchor.goToImplementations,

Vsccmdi.chat.inlineSymbolAnchor.goToReferences,
===
* McshEngl.Vscdcmnd.chat.inlineSymbolAnchor.goToReferences,

Vsccmdi.chat.inlineSymbolAnchor.goToTypeDefinitions,
===
* McshEngl.Vscdcmnd.chat.inlineSymbolAnchor.goToTypeDefinitions,

Vsccmdi.chat.installRecommendation.github.copilot-chat.cli,
===
* McshEngl.Vscdcmnd.chat.installRecommendation.github.copilot_chat.cli,

Vsccmdi.chat.installRecommendation.github.copilot-chat.cloud,
===
* McshEngl.Vscdcmnd.chat.installRecommendation.github.copilot_chat.cloud,

Vsccmdi.chat.installRecommendation.openai.chatgpt.codex,
===
* McshEngl.Vscdcmnd.chat.installRecommendation.openai.chatgpt.codex,

Vsccmdi.chat.internal.codeReview.run,
===
* McshEngl.Vscdcmnd.chat.internal.codeReview.run,

Vsccmdi.chat.internal.explain,
===
* McshEngl.Vscdcmnd.chat.internal.explain,

Vsccmdi.chat.internal.fix,
===
* McshEngl.Vscdcmnd.chat.internal.fix,

Vsccmdi.chat.internal.review,
===
* McshEngl.Vscdcmnd.chat.internal.review,

Vsccmdi.chat.models.action.clearSearchResults,
===
* McshEngl.Vscdcmnd.chat.models.action.clearSearchResults,

Vsccmdi.chat.openFileSnapshot,
===
* McshEngl.Vscdcmnd.chat.openFileSnapshot,

Vsccmdi.chat.openFileUpdatedBySnapshot,
===
* McshEngl.Vscdcmnd.chat.openFileUpdatedBySnapshot,

Vsccmdi.chat.toolOutput.save,
===
* McshEngl.Vscdcmnd.chat.toolOutput.save,

Vsccmdi.chatEditing.acceptAllFiles,
· key: ctrl+enter,
· when: hasUndecidedChatEditingResource && inChatInput,
===
* McshEngl.Vscdcmnd.chatEditing.acceptAllFiles,

Vsccmdi.chatEditing.acceptFile,
===
* McshEngl.Vscdcmnd.chatEditing.acceptFile,

Vsccmdi.chatEditing.discardAllFiles,
· key: ctrl+backspace,
· when: hasUndecidedChatEditingResource && inChatInput && !chatInputHasText,
===
* McshEngl.Vscdcmnd.chatEditing.discardAllFiles,

Vsccmdi.chatEditing.discardFile,
===
* McshEngl.Vscdcmnd.chatEditing.discardFile,

Vsccmdi.chatEditing.multidiff.acceptAllFiles,
===
* McshEngl.Vscdcmnd.chatEditing.multidiff.acceptAllFiles,

Vsccmdi.chatEditing.multidiff.discardAllFiles,
===
* McshEngl.Vscdcmnd.chatEditing.multidiff.discardAllFiles,

Vsccmdi.chatEditing.multidiff.explain,
===
* McshEngl.Vscdcmnd.chatEditing.multidiff.explain,

Vsccmdi.chatEditing.openFileInDiff,
===
* McshEngl.Vscdcmnd.chatEditing.openFileInDiff,

Vsccmdi.chatEditing.toggleExplanationWidget,
===
* McshEngl.Vscdcmnd.chatEditing.toggleExplanationWidget,

Vsccmdi.chatEditing.viewAllSessionChanges,
===
* McshEngl.Vscdcmnd.chatEditing.viewAllSessionChanges,

Vsccmdi.chatEditing.viewChanges,
===
* McshEngl.Vscdcmnd.chatEditing.viewChanges,

Vsccmdi.chatEditing.viewPreviousEdits,
===
* McshEngl.Vscdcmnd.chatEditing.viewPreviousEdits,

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

Vsccmdi.chatEditor.action.acceptAllEdits,
· key: ctrl+alt+y,
· when: chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified || chatEdits.hasEditorModifications && notebookEditorFocused && !chatEdits.isCurrentlyBeingModified,
===
* McshEngl.Vscdcmnd.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,
===
* McshEngl.Vscdcmnd.chatEditor.action.acceptHunk,

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

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

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

Vsccmdi.chatEditor.action.reviewChanges,
===
* McshEngl.Vscdcmnd.chatEditor.action.reviewChanges,

Vsccmdi.chatEditor.action.showAccessibleDiffView,
· key: f7,
· when: accessibilityModeEnabled && chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified,
===
* McshEngl.Vscdcmnd.chatEditor.action.showAccessibleDiffView,

Vsccmdi.chatEditor.action.toggleDiff,
· key: shift+alt+f7,
· when: chatEdits.hasEditorModifications && editorFocus,
===
* McshEngl.Vscdcmnd.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,
===
* McshEngl.Vscdcmnd.chatEditor.action.undoHunk,

Vsccmdi.cleanSearchEditorState,
===
* McshEngl.Vscdcmnd.cleanSearchEditorState,

Vsccmdi.clearFilterCodeActionWidget,
· key: escape,
· when: codeActionMenuFilterFocused && codeActionMenuVisible,
===
* McshEngl.Vscdcmnd.clearFilterCodeActionWidget,

Vsccmdi.closeBreakpointWidget,
· key: escape,
· when: breakpointWidgetVisible && textInputFocus,
===
* McshEngl.Vscdcmnd.closeBreakpointWidget,

Vsccmdi.closeBreakpointWidget,
· key: shift+escape,
· when: breakpointWidgetVisible && textInputFocus,
===
* McshEngl.Vscdcmnd.closeBreakpointWidget,

Vsccmdi.closeFindWidget,
· key: escape,
· when: editorFocus && findWidgetVisible && !isComposing,
===
* McshEngl.Vscdcmnd.closeFindWidget,

Vsccmdi.closeFindWidget,
· key: shift+escape,
· when: editorFocus && findWidgetVisible && !isComposing,
===
* McshEngl.Vscdcmnd.closeFindWidget,

Vsccmdi.closeMarkersNavigation,
· key: escape,
· when: editorFocus && markersNavigationVisible,
===
* McshEngl.Vscdcmnd.closeMarkersNavigation,

Vsccmdi.closeMarkersNavigation,
· key: shift+escape,
· when: editorFocus && markersNavigationVisible,
===
* McshEngl.Vscdcmnd.closeMarkersNavigation,

Vsccmdi.closeParameterHints,
· key: escape,
· when: editorFocus && parameterHintsVisible,
===
* McshEngl.Vscdcmnd.closeParameterHints,

Vsccmdi.closeParameterHints,
· key: shift+escape,
· when: editorFocus && parameterHintsVisible,
===
* McshEngl.Vscdcmnd.closeParameterHints,

Vsccmdi.closeQuickDiff,
· key: escape,
· when: dirtyDiffVisible,
===
* McshEngl.Vscdcmnd.closeQuickDiff,

Vsccmdi.closeQuickDiff,
· key: shift+escape,
· when: dirtyDiffVisible,
===
* McshEngl.Vscdcmnd.closeQuickDiff,

Vsccmdi.closeReferenceSearch,
· key: escape,
· when: editorTextFocus && referenceSearchVisible && !config.editor.stablePeek || referenceSearchVisible && !config.editor.stablePeek && !inputFocus,
===
* McshEngl.Vscdcmnd.closeReferenceSearch,

Vsccmdi.closeReferenceSearch,
· key: escape,
· when: inReferenceSearchEditor && !config.editor.stablePeek,
===
* McshEngl.Vscdcmnd.closeReferenceSearch,

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

Vsccmdi.closeReferenceSearch,
· key: shift+escape,
· when: inReferenceSearchEditor && !config.editor.stablePeek,
===
* McshEngl.Vscdcmnd.closeReferenceSearch,

Vsccmdi.closeReferenceSearchEditor,
===
* McshEngl.Vscdcmnd.closeReferenceSearchEditor,

Vsccmdi.closeReplaceInFilesWidget,
· key: escape,
· when: replaceInputBoxFocus && searchViewletVisible,
===
* McshEngl.Vscdcmnd.closeReplaceInFilesWidget,

Vsccmdi.codelens.showLensesInCurrentLine,
===
* McshEngl.Vscdcmnd.codelens.showLensesInCurrentLine,

Vsccmdi.codepoint.describe,
===
* McshEngl.Vscdcmnd.codepoint.describe,

Vsccmdi.codereferencing.showOutputPane2,
===
* McshEngl.Vscdcmnd.codereferencing.showOutputPane2,

Vsccmdi.collapseSectionCodeAction,
· key: left,
· when: codeActionMenuVisible && !codeActionMenuFilterFocused,
===
* McshEngl.Vscdcmnd.collapseSectionCodeAction,

Vsccmdi.columnSelect,
===
* McshEngl.Vscdcmnd.columnSelect,

Vsccmdi.comments.collapse,
===
* McshEngl.Vscdcmnd.comments.collapse,

Vsccmdi.comments.expand,
===
* McshEngl.Vscdcmnd.comments.expand,

Vsccmdi.comments.reply,
===
* McshEngl.Vscdcmnd.comments.reply,

Vsccmdi.commentsClearFilterText,
· key: escape,
· when: commentsFilterFocus,
===
* McshEngl.Vscdcmnd.commentsClearFilterText,

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

Vsccmdi.commentsFocusViewFromFilter,
· key: ctrl+down,
· when: commentsFilterFocus,
===
* McshEngl.Vscdcmnd.commentsFocusViewFromFilter,

Vsccmdi.compareFiles,
===
* McshEngl.Vscdcmnd.compareFiles,

Vsccmdi.compareSelected,
===
* McshEngl.Vscdcmnd.compareSelected,

Vsccmdi.compositionEnd,
===
* McshEngl.Vscdcmnd.compositionEnd,

Vsccmdi.compositionStart,
===
* McshEngl.Vscdcmnd.compositionStart,

Vsccmdi.compositionType,
===
* McshEngl.Vscdcmnd.compositionType,

Vsccmdi.context-inspector.focus,
===
* McshEngl.Vscdcmnd.context_inspector.focus,

Vsccmdi.context-inspector.resetViewLocation,
===
* McshEngl.Vscdcmnd.context_inspector.resetViewLocation,

Vsccmdi.copilot-chat.focus,
===
* McshEngl.Vscdcmnd.copilot_chat.focus,

Vsccmdi.copilot-chat.resetViewLocation,
===
* McshEngl.Vscdcmnd.copilot_chat.resetViewLocation,

Vsccmdi.copilot.claude.agents,
===
* McshEngl.Vscdcmnd.copilot.claude.agents,

Vsccmdi.copilot.claude.hooks,
===
* McshEngl.Vscdcmnd.copilot.claude.hooks,

Vsccmdi.copilot.claude.memory,
===
* McshEngl.Vscdcmnd.copilot.claude.memory,

Vsccmdi.copyFilePath,
· key: shift+alt+c,
· when: !editorFocus,
===
* McshEngl.Vscdcmnd.copyFilePath,

Vsccmdi.copyFilePath,
· key: shift+alt+c,
· when: editorFocus,
===
* McshEngl.Vscdcmnd.copyFilePath,

Vsccmdi.copyRelativeFilePath,
· key: ctrl+k ctrl+shift+c,
· when: !editorFocus,
===
* McshEngl.Vscdcmnd.copyRelativeFilePath,

Vsccmdi.copyRelativeFilePath,
· key: ctrl+k ctrl+shift+c,
· when: editorFocus,
===
* McshEngl.Vscdcmnd.copyRelativeFilePath,

Vsccmdi.createCursor,
===
* McshEngl.Vscdcmnd.createCursor,

Vsccmdi.cursorBottom,
· key: ctrl+end,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorBottom,

Vsccmdi.cursorBottomSelect,
· key: ctrl+shift+end,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorBottomSelect,

Vsccmdi.cursorColumnSelectDown,
· key: ctrl+shift+alt+down,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorColumnSelectDown,

Vsccmdi.cursorColumnSelectDown,
· key: shift+down,
· when: editorColumnSelection && textInputFocus,
===
* McshEngl.Vscdcmnd.cursorColumnSelectDown,

Vsccmdi.cursorColumnSelectLeft,
· key: ctrl+shift+alt+left,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorColumnSelectLeft,

Vsccmdi.cursorColumnSelectLeft,
· key: shift+left,
· when: editorColumnSelection && textInputFocus,
===
* McshEngl.Vscdcmnd.cursorColumnSelectLeft,

Vsccmdi.cursorColumnSelectPageDown,
· key: ctrl+shift+alt+pagedown,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorColumnSelectPageDown,

Vsccmdi.cursorColumnSelectPageDown,
· key: shift+pagedown,
· when: editorColumnSelection && textInputFocus,
===
* McshEngl.Vscdcmnd.cursorColumnSelectPageDown,

Vsccmdi.cursorColumnSelectPageUp,
· key: ctrl+shift+alt+pageup,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorColumnSelectPageUp,

Vsccmdi.cursorColumnSelectPageUp,
· key: shift+pageup,
· when: editorColumnSelection && textInputFocus,
===
* McshEngl.Vscdcmnd.cursorColumnSelectPageUp,

Vsccmdi.cursorColumnSelectRight,
· key: ctrl+shift+alt+right,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorColumnSelectRight,

Vsccmdi.cursorColumnSelectRight,
· key: shift+right,
· when: editorColumnSelection && textInputFocus,
===
* McshEngl.Vscdcmnd.cursorColumnSelectRight,

Vsccmdi.cursorColumnSelectUp,
· key: ctrl+shift+alt+up,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorColumnSelectUp,

Vsccmdi.cursorColumnSelectUp,
· key: shift+up,
· when: editorColumnSelection && textInputFocus,
===
* McshEngl.Vscdcmnd.cursorColumnSelectUp,

Vsccmdi.cursorDown,
· key: down,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorDown,

Vsccmdi.cursorDownSelect,
· key: ctrl+shift+down,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorDownSelect,

Vsccmdi.cursorDownSelect,
· key: shift+down,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorDownSelect,

Vsccmdi.cursorEnd,
· key: end,
· when: textInputFocus,
· args: {"sticky":false},
===
* McshEngl.Vscdcmnd.cursorEnd,

Vsccmdi.cursorEndSelect,
· key: shift+end,
· when: textInputFocus,
· args: {"sticky":false},
===
* McshEngl.Vscdcmnd.cursorEndSelect,

Vsccmdi.cursorHome,
· key: home,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorHome,

Vsccmdi.cursorHomeSelect,
· key: shift+home,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorHomeSelect,

Vsccmdi.cursorLeft,
· key: left,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorLeft,

Vsccmdi.cursorLeftSelect,
· key: shift+left,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorLeftSelect,

Vsccmdi.cursorLineEnd,
===
* McshEngl.Vscdcmnd.cursorLineEnd,

Vsccmdi.cursorLineEndSelect,
===
* McshEngl.Vscdcmnd.cursorLineEndSelect,

Vsccmdi.cursorLineStart,
===
* McshEngl.Vscdcmnd.cursorLineStart,

Vsccmdi.cursorLineStartSelect,
===
* McshEngl.Vscdcmnd.cursorLineStartSelect,

Vsccmdi.cursorPageDown,
· key: pagedown,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorPageDown,

Vsccmdi.cursorPageDownSelect,
· key: shift+pagedown,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorPageDownSelect,

Vsccmdi.cursorPageUp,
· key: pageup,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorPageUp,

Vsccmdi.cursorPageUpSelect,
· key: shift+pageup,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorPageUpSelect,

Vsccmdi.cursorRedo,
===
* McshEngl.Vscdcmnd.cursorRedo,

Vsccmdi.cursorRight,
· key: right,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorRight,

Vsccmdi.cursorRightSelect,
· key: shift+right,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorRightSelect,

Vsccmdi.cursorTop,
· key: ctrl+home,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorTop,

Vsccmdi.cursorTopSelect,
· key: ctrl+shift+home,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorTopSelect,

Vsccmdi.cursorUndo,
· key: ctrl+u,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorUndo,

Vsccmdi.cursorUp,
· key: up,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorUp,

Vsccmdi.cursorUpSelect,
· key: ctrl+shift+up,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorUpSelect,

Vsccmdi.cursorUpSelect,
· key: shift+up,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.cursorUpSelect,

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

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

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

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

Vsccmdi.cursorWordEndLeft,
===
* McshEngl.Vscdcmnd.cursorWordEndLeft,

Vsccmdi.cursorWordEndLeftSelect,
===
* McshEngl.Vscdcmnd.cursorWordEndLeftSelect,

Vsccmdi.cursorWordEndRight,
· key: ctrl+right,
· when: textInputFocus && !accessibilityModeEnabled,
===
* McshEngl.Vscdcmnd.cursorWordEndRight,

Vsccmdi.cursorWordEndRightSelect,
· key: ctrl+shift+right,
· when: textInputFocus && !accessibilityModeEnabled,
===
* McshEngl.Vscdcmnd.cursorWordEndRightSelect,

Vsccmdi.cursorWordLeft,
· key: ctrl+left,
· when: textInputFocus && !accessibilityModeEnabled,
===
* McshEngl.Vscdcmnd.cursorWordLeft,

Vsccmdi.cursorWordLeftSelect,
· key: ctrl+shift+left,
· when: textInputFocus && !accessibilityModeEnabled,
===
* McshEngl.Vscdcmnd.cursorWordLeftSelect,

Vsccmdi.cursorWordPartLeft,
===
* McshEngl.Vscdcmnd.cursorWordPartLeft,

Vsccmdi.cursorWordPartLeftSelect,
===
* McshEngl.Vscdcmnd.cursorWordPartLeftSelect,

Vsccmdi.cursorWordPartRight,
===
* McshEngl.Vscdcmnd.cursorWordPartRight,

Vsccmdi.cursorWordPartRightSelect,
===
* McshEngl.Vscdcmnd.cursorWordPartRightSelect,

Vsccmdi.cursorWordPartStartLeft,
===
* McshEngl.Vscdcmnd.cursorWordPartStartLeft,

Vsccmdi.cursorWordPartStartLeftSelect,
===
* McshEngl.Vscdcmnd.cursorWordPartStartLeftSelect,

Vsccmdi.cursorWordRight,
===
* McshEngl.Vscdcmnd.cursorWordRight,

Vsccmdi.cursorWordRightSelect,
===
* McshEngl.Vscdcmnd.cursorWordRightSelect,

Vsccmdi.cursorWordStartLeft,
===
* McshEngl.Vscdcmnd.cursorWordStartLeft,

Vsccmdi.cursorWordStartLeftSelect,
===
* McshEngl.Vscdcmnd.cursorWordStartLeftSelect,

Vsccmdi.cursorWordStartRight,
===
* McshEngl.Vscdcmnd.cursorWordStartRight,

Vsccmdi.cursorWordStartRightSelect,
===
* McshEngl.Vscdcmnd.cursorWordStartRightSelect,

Vsccmdi.cut,
===
* McshEngl.Vscdcmnd.cut,

Vsccmdi.debug.action.openDisassemblyView,
===
* McshEngl.Vscdcmnd.debug.action.openDisassemblyView,

Vsccmdi.debug.action.toggleDisassemblyViewSourceCode,
===
* McshEngl.Vscdcmnd.debug.action.toggleDisassemblyViewSourceCode,

Vsccmdi.debug.addConfiguration,
===
* McshEngl.Vscdcmnd.debug.addConfiguration,

Vsccmdi.debug.addToWatchExpressions,
===
* McshEngl.Vscdcmnd.debug.addToWatchExpressions,

Vsccmdi.debug.attachToCurrentCodeRenderer,
===
* McshEngl.Vscdcmnd.debug.attachToCurrentCodeRenderer,

Vsccmdi.debug.breakWhenValueChanges,
===
* McshEngl.Vscdcmnd.debug.breakWhenValueChanges,

Vsccmdi.debug.breakWhenValueIsAccessed,
===
* McshEngl.Vscdcmnd.debug.breakWhenValueIsAccessed,

Vsccmdi.debug.breakWhenValueIsRead,
===
* McshEngl.Vscdcmnd.debug.breakWhenValueIsRead,

Vsccmdi.debug.collapseRepl,
===
* McshEngl.Vscdcmnd.debug.collapseRepl,

Vsccmdi.debug.copyEvaluatePath,
===
* McshEngl.Vscdcmnd.debug.copyEvaluatePath,

Vsccmdi.debug.copyStackTrace,
===
* McshEngl.Vscdcmnd.debug.copyStackTrace,

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

Vsccmdi.debug.editBreakpoint,
===
* McshEngl.Vscdcmnd.debug.editBreakpoint,

Vsccmdi.debug.editBreakpointMode,
===
* McshEngl.Vscdcmnd.debug.editBreakpointMode,

Vsccmdi.debug.editFunctionBreakpoint,
===
* McshEngl.Vscdcmnd.debug.editFunctionBreakpoint,

Vsccmdi.debug.editFunctionBreakpointHitCount,
===
* McshEngl.Vscdcmnd.debug.editFunctionBreakpointHitCount,

Vsccmdi.debug.enableOrDisableBreakpoint,
===
* McshEngl.Vscdcmnd.debug.enableOrDisableBreakpoint,

Vsccmdi.debug.installAdditionalDebuggers,
===
* McshEngl.Vscdcmnd.debug.installAdditionalDebuggers,

Vsccmdi.debug.jumpToCursor,
===
* McshEngl.Vscdcmnd.debug.jumpToCursor,

Vsccmdi.debug.openBreakpointToSide,
· key: alt+enter,
· when: breakpointsFocused,
===
* McshEngl.Vscdcmnd.debug.openBreakpointToSide,

Vsccmdi.debug.openBreakpointToSide,
· key: ctrl+enter,
· when: breakpointsFocused,
===
* McshEngl.Vscdcmnd.debug.openBreakpointToSide,

Vsccmdi.debug.openView,
· key: ctrl+f5,
· when: !debuggersAvailable,
===
* McshEngl.Vscdcmnd.debug.openView,

Vsccmdi.debug.openView,
· key: f5,
· when: !debuggersAvailable,
===
* McshEngl.Vscdcmnd.debug.openView,

Vsccmdi.debug.removeBreakpoint,
· key: delete,
· when: breakpointsFocused && !breakpointInputFocused,
===
* McshEngl.Vscdcmnd.debug.removeBreakpoint,

Vsccmdi.debug.removeWatchExpression,
· key: delete,
· when: watchExpressionsFocused && !expressionSelected,
===
* McshEngl.Vscdcmnd.debug.removeWatchExpression,

Vsccmdi.debug.renameWatchExpression,
· key: f2,
· when: watchExpressionsFocused,
===
* McshEngl.Vscdcmnd.debug.renameWatchExpression,

Vsccmdi.debug.replCopy,
===
* McshEngl.Vscdcmnd.debug.replCopy,

Vsccmdi.debug.replPaste,
===
* McshEngl.Vscdcmnd.debug.replPaste,

Vsccmdi.debug.setVariable,
· key: f2,
· when: variablesFocused,
===
* McshEngl.Vscdcmnd.debug.setVariable,

Vsccmdi.debug.setWatchExpression,
===
* McshEngl.Vscdcmnd.debug.setWatchExpression,

Vsccmdi.debug.startFromConfig,
===
* McshEngl.Vscdcmnd.debug.startFromConfig,

Vsccmdi.debug.toggleBreakpoint,
· key: space,
· when: breakpointsFocused && !inputFocus,
===
* McshEngl.Vscdcmnd.debug.toggleBreakpoint,

Vsccmdi.debug.toggleExceptionBreakpoints,
===
* McshEngl.Vscdcmnd.debug.toggleExceptionBreakpoints,

Vsccmdi.debug.toggleReplIgnoreFocus,
===
* McshEngl.Vscdcmnd.debug.toggleReplIgnoreFocus,

Vsccmdi.decreaseSearchEditorContextLines,
· key: alt+-,
· when: inSearchEditor,
===
* McshEngl.Vscdcmnd.decreaseSearchEditorContextLines,

Vsccmdi.default:compositionEnd,
===
* McshEngl.Vscdcmnd.default:compositionEnd,

Vsccmdi.default:compositionStart,
===
* McshEngl.Vscdcmnd.default:compositionStart,

Vsccmdi.default:compositionType,
===
* McshEngl.Vscdcmnd.default:compositionType,

Vsccmdi.default:cut,
===
* McshEngl.Vscdcmnd.default:cut,

Vsccmdi.default:paste,
===
* McshEngl.Vscdcmnd.default:paste,

Vsccmdi.default:redo,
===
* McshEngl.Vscdcmnd.default:redo,

Vsccmdi.default:replacePreviousChar,
===
* McshEngl.Vscdcmnd.default:replacePreviousChar,

Vsccmdi.default:type,
===
* McshEngl.Vscdcmnd.default:type,

Vsccmdi.default:undo,
===
* McshEngl.Vscdcmnd.default:undo,

Vsccmdi.deleteAllLeft,
===
* McshEngl.Vscdcmnd.deleteAllLeft,

Vsccmdi.deleteAllRight,
===
* McshEngl.Vscdcmnd.deleteAllRight,

Vsccmdi.deleteFile,
· key: delete,
· when: filesExplorerFocus && foldersViewVisible && !explorerResourceMoveableToTrash && !inputFocus,
===
* McshEngl.Vscdcmnd.deleteFile,

Vsccmdi.deleteFile,
· key: shift+delete,
· when: filesExplorerFocus && foldersViewVisible && !inputFocus,
===
* McshEngl.Vscdcmnd.deleteFile,

Vsccmdi.deleteInsideWord,
===
* McshEngl.Vscdcmnd.deleteInsideWord,

Vsccmdi.deleteLeft,
· key: backspace,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.deleteLeft,

Vsccmdi.deleteLeft,
· key: shift+backspace,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.deleteLeft,

Vsccmdi.deleteRight,
· key: delete,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.deleteRight,

Vsccmdi.deleteWordEndLeft,
===
* McshEngl.Vscdcmnd.deleteWordEndLeft,

Vsccmdi.deleteWordEndRight,
===
* McshEngl.Vscdcmnd.deleteWordEndRight,

Vsccmdi.deleteWordLeft,
· key: ctrl+backspace,
· when: textInputFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.deleteWordLeft,

Vsccmdi.deleteWordPartLeft,
===
* McshEngl.Vscdcmnd.deleteWordPartLeft,

Vsccmdi.deleteWordPartRight,
===
* McshEngl.Vscdcmnd.deleteWordPartRight,

Vsccmdi.deleteWordRight,
· key: ctrl+delete,
· when: textInputFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.deleteWordRight,

Vsccmdi.deleteWordStartLeft,
===
* McshEngl.Vscdcmnd.deleteWordStartLeft,

Vsccmdi.deleteWordStartRight,
===
* McshEngl.Vscdcmnd.deleteWordStartRight,

Vsccmdi.developer.showCurrentFileAsReleaseNotes,
===
* McshEngl.Vscdcmnd.developer.showCurrentFileAsReleaseNotes,

Vsccmdi.diffEditor.collapseAllUnchangedRegions,
===
* McshEngl.Vscdcmnd.diffEditor.collapseAllUnchangedRegions,

Vsccmdi.diffEditor.exitCompareMove,
· key: escape,
· when: comparingMovedCode" },
===
* McshEngl.Vscdcmnd.diffEditor.exitCompareMove,

Vsccmdi.diffEditor.revert,
===
* McshEngl.Vscdcmnd.diffEditor.revert,

Vsccmdi.diffEditor.showAllUnchangedRegions,
===
* McshEngl.Vscdcmnd.diffEditor.showAllUnchangedRegions,

Vsccmdi.diffEditor.switchSide,
===
* McshEngl.Vscdcmnd.diffEditor.switchSide,

Vsccmdi.diffEditor.toggleCollapseUnchangedRegions,
===
* McshEngl.Vscdcmnd.diffEditor.toggleCollapseUnchangedRegions,

Vsccmdi.diffEditor.toggleShowMovedCodeBlocks,
===
* McshEngl.Vscdcmnd.diffEditor.toggleShowMovedCodeBlocks,

Vsccmdi.diffEditor.toggleUseInlineViewWhenSpaceIsLimited,
===
* McshEngl.Vscdcmnd.diffEditor.toggleUseInlineViewWhenSpaceIsLimited,

Vsccmdi.editor.action.accessibilityHelp,
· key: alt+f1,
· when: !accessibilityHelpIsShown,
===
* McshEngl.Vscdcmnd.editor.action.accessibilityHelp,

Vsccmdi.editor.action.accessibilityHelpConfigureAssignedKeybindings,
· key: alt+a,
· when: accessibilityHelpIsShown && accessibleViewHasAssignedKeybindings,
===
* McshEngl.Vscdcmnd.editor.action.accessibilityHelpConfigureAssignedKeybindings,

Vsccmdi.editor.action.accessibilityHelpConfigureKeybindings,
· key: alt+k,
· when: accessibilityHelpIsShown && accessibleViewHasUnassignedKeybindings,
===
* McshEngl.Vscdcmnd.editor.action.accessibilityHelpConfigureKeybindings,

Vsccmdi.editor.action.accessibilityHelpOpenHelpLink,
· key: alt+h,
· when: accessibilityHelpIsShown,
===
* McshEngl.Vscdcmnd.editor.action.accessibilityHelpOpenHelpLink,

Vsccmdi.editor.action.accessibleDiffViewer.next,
· key: f7,
· when: isInDiffEditor,
===
* McshEngl.Vscdcmnd.editor.action.accessibleDiffViewer.next,

Vsccmdi.editor.action.accessibleDiffViewer.prev,
· key: shift+f7,
· when: isInDiffEditor,
===
* McshEngl.Vscdcmnd.editor.action.accessibleDiffViewer.prev,

Vsccmdi.editor.action.accessibleView,
· key: alt+f2,
===
* McshEngl.Vscdcmnd.editor.action.accessibleView,

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

Vsccmdi.editor.action.accessibleViewDisableHint,
· key: alt+f6,
· when: accessibilityHelpIsShown && accessibleViewVerbosityEnabled || accessibleViewIsShown && accessibleViewVerbosityEnabled,
===
* McshEngl.Vscdcmnd.editor.action.accessibleViewDisableHint,

Vsccmdi.editor.action.accessibleViewGoToSymbol,
· key: ctrl+shift+.,
· when: accessibilityHelpIsShown && accessibleViewGoToSymbolSupported || accessibleViewGoToSymbolSupported && accessibleViewIsShown,
===
* McshEngl.Vscdcmnd.editor.action.accessibleViewGoToSymbol,

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

Vsccmdi.editor.action.accessibleViewNext,
· key: alt+],
· when: accessibleViewIsShown && accessibleViewSupportsNavigation,
===
* McshEngl.Vscdcmnd.editor.action.accessibleViewNext,

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

Vsccmdi.editor.action.accessibleViewPrevious,
· key: alt+[,
· when: accessibleViewIsShown && accessibleViewSupportsNavigation,
===
* McshEngl.Vscdcmnd.editor.action.accessibleViewPrevious,

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

Vsccmdi.editor.action.addCommentLine,
· key: ctrl+k ctrl+c,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.addCommentLine,

Vsccmdi.editor.action.addCursorsToBottom,
===
* McshEngl.Vscdcmnd.editor.action.addCursorsToBottom,

Vsccmdi.editor.action.addCursorsToTop,
===
* McshEngl.Vscdcmnd.editor.action.addCursorsToTop,

Vsccmdi.editor.action.addSelectionToNextFindMatch,
· key: ctrl+d,
· when: editorFocus,
===
* McshEngl.Vscdcmnd.editor.action.addSelectionToNextFindMatch,

Vsccmdi.editor.action.addSelectionToPreviousFindMatch,
===
* McshEngl.Vscdcmnd.editor.action.addSelectionToPreviousFindMatch,

Vsccmdi.editor.action.announceCursorPosition,
· key: ctrl+shift+alt+g,
· when: accessibilityModeEnabled && editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.action.announceCursorPosition,

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

Vsccmdi.editor.action.blockComment,
· key: shift+alt+a,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.blockComment,

Vsccmdi.editor.action.cancelSelectionAnchor,
· key: escape,
· when: editorTextFocus && selectionAnchorSet,
===
* McshEngl.Vscdcmnd.editor.action.cancelSelectionAnchor,

Vsccmdi.editor.action.changeAll,
· key: ctrl+f2,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.changeAll,

Vsccmdi.editor.action.changeTabDisplaySize,
===
* McshEngl.Vscdcmnd.editor.action.changeTabDisplaySize,

Vsccmdi.editor.action.clipboardCopyAction,
· key: ctrl+c,
===
* McshEngl.Vscdcmnd.editor.action.clipboardCopyAction,

Vsccmdi.editor.action.clipboardCopyAction,
· key: ctrl+insert,
===
* McshEngl.Vscdcmnd.editor.action.clipboardCopyAction,

Vsccmdi.editor.action.clipboardCopyWithSyntaxHighlightingAction,
===
* McshEngl.Vscdcmnd.editor.action.clipboardCopyWithSyntaxHighlightingAction,

Vsccmdi.editor.action.clipboardCutAction,
· key: ctrl+x,
===
* McshEngl.Vscdcmnd.editor.action.clipboardCutAction,

Vsccmdi.editor.action.clipboardCutAction,
· key: shift+delete,
===
* McshEngl.Vscdcmnd.editor.action.clipboardCutAction,

Vsccmdi.editor.action.clipboardPasteAction,
· key: ctrl+v,
===
* McshEngl.Vscdcmnd.editor.action.clipboardPasteAction,

Vsccmdi.editor.action.clipboardPasteAction,
· key: shift+insert,
===
* McshEngl.Vscdcmnd.editor.action.clipboardPasteAction,

Vsccmdi.editor.action.commentLine,
· key: ctrl+/,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.commentLine,

Vsccmdi.editor.action.copyLinesDownAction,
· key: shift+alt+down,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.copyLinesDownAction,

Vsccmdi.editor.action.copyLinesUpAction,
· key: shift+alt+up,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.copyLinesUpAction,

Vsccmdi.editor.action.debugEditorGpuRenderer,
===
* McshEngl.Vscdcmnd.editor.action.debugEditorGpuRenderer,

Vsccmdi.editor.action.decreaseHoverVerbosityLevel,
===
* McshEngl.Vscdcmnd.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',
===
* McshEngl.Vscdcmnd.editor.action.defineKeybinding,

Vsccmdi.editor.action.deleteLines,
· key: ctrl+shift+k,
· when: textInputFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.deleteLines,

Vsccmdi.editor.action.detectIndentation,
===
* McshEngl.Vscdcmnd.editor.action.detectIndentation,

Vsccmdi.editor.action.diffReview.next,
===
* McshEngl.Vscdcmnd.editor.action.diffReview.next,

Vsccmdi.editor.action.diffReview.prev,
===
* McshEngl.Vscdcmnd.editor.action.diffReview.prev,

Vsccmdi.editor.action.dirtydiff.next,
· key: alt+f3,
· when: editorTextFocus && !textCompareEditorActive,
===
* McshEngl.Vscdcmnd.editor.action.dirtydiff.next,

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

Vsccmdi.editor.action.duplicateSelection,
===
* McshEngl.Vscdcmnd.editor.action.duplicateSelection,

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

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

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

Vsccmdi.editor.action.findReferences,
===
* McshEngl.Vscdcmnd.editor.action.findReferences,

Vsccmdi.editor.action.fixAll,
===
* McshEngl.Vscdcmnd.editor.action.fixAll,

Vsccmdi.editor.action.focusNextCursor,
===
* McshEngl.Vscdcmnd.editor.action.focusNextCursor,

Vsccmdi.editor.action.focusPreviousCursor,
===
* McshEngl.Vscdcmnd.editor.action.focusPreviousCursor,

Vsccmdi.editor.action.focusStickyScroll,
===
* McshEngl.Vscdcmnd.editor.action.focusStickyScroll,

Vsccmdi.editor.action.fontZoomIn,
===
* McshEngl.Vscdcmnd.editor.action.fontZoomIn,

Vsccmdi.editor.action.fontZoomOut,
===
* McshEngl.Vscdcmnd.editor.action.fontZoomOut,

Vsccmdi.editor.action.fontZoomReset,
===
* McshEngl.Vscdcmnd.editor.action.fontZoomReset,

Vsccmdi.editor.action.forceRetokenize,
===
* McshEngl.Vscdcmnd.editor.action.forceRetokenize,

Vsccmdi.editor.action.format,
===
* McshEngl.Vscdcmnd.editor.action.format,

Vsccmdi.editor.action.formatChanges,
===
* McshEngl.Vscdcmnd.editor.action.formatChanges,

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

Vsccmdi.editor.action.formatDocument.multiple,
===
* McshEngl.Vscdcmnd.editor.action.formatDocument.multiple,

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

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

Vsccmdi.editor.action.formatSelection.multiple,
===
* McshEngl.Vscdcmnd.editor.action.formatSelection.multiple,

Vsccmdi.editor.action.goToBottomHover,
· key: ctrl+down,
· when: editorHoverFocused,
===
* McshEngl.Vscdcmnd.editor.action.goToBottomHover,

Vsccmdi.editor.action.goToBottomHover,
· key: end,
· when: editorHoverFocused,
===
* McshEngl.Vscdcmnd.editor.action.goToBottomHover,

Vsccmdi.editor.action.goToDeclaration,
===
* McshEngl.Vscdcmnd.editor.action.goToDeclaration,

Vsccmdi.editor.action.goToFocusedStickyScrollLine,
· key: enter,
· when: stickyScrollFocused,
===
* McshEngl.Vscdcmnd.editor.action.goToFocusedStickyScrollLine,

Vsccmdi.editor.action.goToImplementation,
· key: ctrl+f12,
· when: editorHasImplementationProvider && editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.action.goToImplementation,

Vsccmdi.editor.action.goToMatchFindAction,
===
* McshEngl.Vscdcmnd.editor.action.goToMatchFindAction,

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

Vsccmdi.editor.action.goToSelectionAnchor,
===
* McshEngl.Vscdcmnd.editor.action.goToSelectionAnchor,

Vsccmdi.editor.action.goToTopHover,
· key: ctrl+up,
· when: editorHoverFocused,
===
* McshEngl.Vscdcmnd.editor.action.goToTopHover,

Vsccmdi.editor.action.goToTopHover,
· key: home,
· when: editorHoverFocused,
===
* McshEngl.Vscdcmnd.editor.action.goToTopHover,

Vsccmdi.editor.action.goToTypeDefinition,
===
* McshEngl.Vscdcmnd.editor.action.goToTypeDefinition,

Vsccmdi.editor.action.hideColorPicker,
· key: escape,
· when: standaloneColorPickerVisible,
===
* McshEngl.Vscdcmnd.editor.action.hideColorPicker,

Vsccmdi.editor.action.hideHover,
===
* McshEngl.Vscdcmnd.editor.action.hideHover,

Vsccmdi.editor.action.hideLongLineWarningHover,
===
* McshEngl.Vscdcmnd.editor.action.hideLongLineWarningHover,

Vsccmdi.editor.action.inPlaceReplace.down,
· key: ctrl+shift+.,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.inPlaceReplace.down,

Vsccmdi.editor.action.inPlaceReplace.up,
· key: ctrl+shift+,,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.inPlaceReplace.up,

Vsccmdi.editor.action.increaseHoverVerbosityLevel,
===
* McshEngl.Vscdcmnd.editor.action.increaseHoverVerbosityLevel,

Vsccmdi.editor.action.indentLines,
· key: ctrl+],
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.indentLines,

Vsccmdi.editor.action.indentUsingSpaces,
===
* McshEngl.Vscdcmnd.editor.action.indentUsingSpaces,

Vsccmdi.editor.action.indentUsingTabs,
===
* McshEngl.Vscdcmnd.editor.action.indentUsingTabs,

Vsccmdi.editor.action.indentationToSpaces,
===
* McshEngl.Vscdcmnd.editor.action.indentationToSpaces,

Vsccmdi.editor.action.indentationToTabs,
===
* McshEngl.Vscdcmnd.editor.action.indentationToTabs,

Vsccmdi.editor.action.inlineSuggest.acceptNextLine,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.acceptNextLine,

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

Vsccmdi.editor.action.inlineSuggest.cancelSnooze,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.cancelSnooze,

Vsccmdi.editor.action.inlineSuggest.commit,
· key: tab,
· when: inInlineEditsPreviewEditor,
===
* McshEngl.Vscdcmnd.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,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.commit,

Vsccmdi.editor.action.inlineSuggest.commitAlternativeAction,
· key: shift+tab,
· when: inInlineEditsPreviewEditor,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.commitAlternativeAction,

Vsccmdi.editor.action.inlineSuggest.commitAlternativeAction,
· key: shift+tab,
· when: inlineEditIsVisible && inlineSuggestionAlternativeActionVisible,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.commitAlternativeAction,

Vsccmdi.editor.action.inlineSuggest.dev.extractRepro,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.dev.extractRepro,

Vsccmdi.editor.action.inlineSuggest.hide,
· key: escape,
· when: inInlineEditsPreviewEditor,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.hide,

Vsccmdi.editor.action.inlineSuggest.hide,
· key: escape,
· when: inlineEditIsVisible || inlineSuggestionVisible,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.hide,

Vsccmdi.editor.action.inlineSuggest.hide,
· key: shift+escape,
· when: inInlineEditsPreviewEditor,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.hide,

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

Vsccmdi.editor.action.inlineSuggest.showNext,
· key: alt+],
· when: inlineSuggestionVisible && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.showNext,

Vsccmdi.editor.action.inlineSuggest.showPrevious,
· key: alt+[,
· when: inlineSuggestionVisible && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.showPrevious,

Vsccmdi.editor.action.inlineSuggest.snooze,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.snooze,

Vsccmdi.editor.action.inlineSuggest.toggleAlwaysShowToolbar,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.toggleAlwaysShowToolbar,

Vsccmdi.editor.action.inlineSuggest.toggleShowCollapsed,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.toggleShowCollapsed,

Vsccmdi.editor.action.inlineSuggest.trigger,
===
* McshEngl.Vscdcmnd.editor.action.inlineSuggest.trigger,

Vsccmdi.editor.action.insertColorWithStandaloneColorPicker,
· key: enter,
· when: standaloneColorPickerFocused,
===
* McshEngl.Vscdcmnd.editor.action.insertColorWithStandaloneColorPicker,

Vsccmdi.editor.action.insertCursorAbove,
· key: ctrl+alt+up,
· when: editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.action.insertCursorAbove,

Vsccmdi.editor.action.insertCursorAtEndOfEachLineSelected,
· key: shift+alt+i,
· when: editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.action.insertCursorAtEndOfEachLineSelected,

Vsccmdi.editor.action.insertCursorBelow,
· key: ctrl+alt+down,
· when: editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.action.insertCursorBelow,

Vsccmdi.editor.action.insertFinalNewLine,
===
* McshEngl.Vscdcmnd.editor.action.insertFinalNewLine,

Vsccmdi.editor.action.insertLineAfter,
· key: ctrl+enter,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.insertLineAfter,

Vsccmdi.editor.action.insertLineBefore,
· key: ctrl+shift+enter,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.insertLineBefore,

Vsccmdi.editor.action.insertSnippet,
===
* McshEngl.Vscdcmnd.editor.action.insertSnippet,

Vsccmdi.editor.action.inspectTMScopes,
===
* McshEngl.Vscdcmnd.editor.action.inspectTMScopes,

Vsccmdi.editor.action.joinLines,
===
* McshEngl.Vscdcmnd.editor.action.joinLines,

Vsccmdi.editor.action.jumpToBracket,
· key: ctrl+shift+\\,
· when: editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.action.jumpToBracket,

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

Vsccmdi.editor.action.marker.next,
· key: alt+f8,
· when: editorFocus,
===
* McshEngl.Vscdcmnd.editor.action.marker.next,

Vsccmdi.editor.action.marker.nextInFiles,
· key: f8,
· when: editorFocus,
===
* McshEngl.Vscdcmnd.editor.action.marker.nextInFiles,

Vsccmdi.editor.action.marker.prev,
· key: shift+alt+f8,
· when: editorFocus,
===
* McshEngl.Vscdcmnd.editor.action.marker.prev,

Vsccmdi.editor.action.marker.prevInFiles,
· key: shift+f8,
· when: editorFocus,
===
* McshEngl.Vscdcmnd.editor.action.marker.prevInFiles,

Vsccmdi.editor.action.measureExtHostLatency,
===
* McshEngl.Vscdcmnd.editor.action.measureExtHostLatency,

Vsccmdi.editor.action.moveCarretLeftAction,
===
* McshEngl.Vscdcmnd.editor.action.moveCarretLeftAction,

Vsccmdi.editor.action.moveCarretRightAction,
===
* McshEngl.Vscdcmnd.editor.action.moveCarretRightAction,

Vsccmdi.editor.action.moveLinesDownAction,
· key: alt+down,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.moveLinesDownAction,

Vsccmdi.editor.action.moveLinesUpAction,
· key: alt+up,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.moveLinesUpAction,

Vsccmdi.editor.action.moveSelectionToNextFindMatch,
· key: ctrl+k ctrl+d,
· when: editorFocus,
===
* McshEngl.Vscdcmnd.editor.action.moveSelectionToNextFindMatch,

Vsccmdi.editor.action.moveSelectionToPreviousFindMatch,
===
* McshEngl.Vscdcmnd.editor.action.moveSelectionToPreviousFindMatch,

Vsccmdi.editor.action.nextCommentThreadAction,
· key: alt+f9,
===
* McshEngl.Vscdcmnd.editor.action.nextCommentThreadAction,

Vsccmdi.editor.action.nextCommentedRangeAction,
· key: alt+f10,
· when: activeEditorHasCommentingRange,
===
* McshEngl.Vscdcmnd.editor.action.nextCommentedRangeAction,

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

Vsccmdi.editor.action.nextMatchFindAction,
· key: enter,
· when: editorFocus && findInputFocussed,
===
* McshEngl.Vscdcmnd.editor.action.nextMatchFindAction,

Vsccmdi.editor.action.nextMatchFindAction,
· key: f3,
· when: editorFocus,
===
* McshEngl.Vscdcmnd.editor.action.nextMatchFindAction,

Vsccmdi.editor.action.nextSelectionMatchFindAction,
· key: ctrl+f3,
· when: editorFocus,
===
* McshEngl.Vscdcmnd.editor.action.nextSelectionMatchFindAction,

Vsccmdi.editor.action.openDeclarationToTheSide,
===
* McshEngl.Vscdcmnd.editor.action.openDeclarationToTheSide,

Vsccmdi.editor.action.openLink,
===
* McshEngl.Vscdcmnd.editor.action.openLink,

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

Vsccmdi.editor.action.outdentLines,
· key: ctrl+[,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.outdentLines,

Vsccmdi.editor.action.pageDownHover,
· key: alt+down,
· when: editorHoverFocused,
===
* McshEngl.Vscdcmnd.editor.action.pageDownHover,

Vsccmdi.editor.action.pageDownHover,
· key: pagedown,
· when: editorHoverFocused,
===
* McshEngl.Vscdcmnd.editor.action.pageDownHover,

Vsccmdi.editor.action.pageUpHover,
· key: alt+up,
· when: editorHoverFocused,
===
* McshEngl.Vscdcmnd.editor.action.pageUpHover,

Vsccmdi.editor.action.pageUpHover,
· key: pageup,
· when: editorHoverFocused,
===
* McshEngl.Vscdcmnd.editor.action.pageUpHover,

Vsccmdi.editor.action.pasteAs,
===
* McshEngl.Vscdcmnd.editor.action.pasteAs,

Vsccmdi.editor.action.pasteAsText,
===
* McshEngl.Vscdcmnd.editor.action.pasteAsText,

Vsccmdi.editor.action.peekDeclaration,
===
* McshEngl.Vscdcmnd.editor.action.peekDeclaration,

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

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

Vsccmdi.editor.action.peekTypeDefinition,
===
* McshEngl.Vscdcmnd.editor.action.peekTypeDefinition,

Vsccmdi.editor.action.previewDeclaration,
===
* McshEngl.Vscdcmnd.editor.action.previewDeclaration,

Vsccmdi.editor.action.previousCommentThreadAction,
· key: shift+alt+f9,
===
* McshEngl.Vscdcmnd.editor.action.previousCommentThreadAction,

Vsccmdi.editor.action.previousCommentedRangeAction,
· key: shift+alt+f10,
· when: activeEditorHasCommentingRange,
===
* McshEngl.Vscdcmnd.editor.action.previousCommentedRangeAction,

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

Vsccmdi.editor.action.previousMatchFindAction,
· key: shift+enter,
· when: editorFocus && findInputFocussed,
===
* McshEngl.Vscdcmnd.editor.action.previousMatchFindAction,

Vsccmdi.editor.action.previousMatchFindAction,
· key: shift+f3,
· when: editorFocus,
===
* McshEngl.Vscdcmnd.editor.action.previousMatchFindAction,

Vsccmdi.editor.action.previousSelectionMatchFindAction,
· key: ctrl+shift+f3,
· when: editorFocus,
===
* McshEngl.Vscdcmnd.editor.action.previousSelectionMatchFindAction,

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

Vsccmdi.editor.action.quickFix,
· key: ctrl+.,
· when: editorHasCodeActionsProvider && textInputFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.quickFix,

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

Vsccmdi.editor.action.referenceSearch.trigger,
===
* McshEngl.Vscdcmnd.editor.action.referenceSearch.trigger,

Vsccmdi.editor.action.reindentlines,
===
* McshEngl.Vscdcmnd.editor.action.reindentlines,

Vsccmdi.editor.action.reindentselectedlines,
===
* McshEngl.Vscdcmnd.editor.action.reindentselectedlines,

Vsccmdi.editor.action.removeBrackets,
· key: ctrl+alt+backspace,
· when: editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.action.removeBrackets,

Vsccmdi.editor.action.removeCommentLine,
· key: ctrl+k ctrl+u,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.removeCommentLine,

Vsccmdi.editor.action.removeDuplicateLines,
===
* McshEngl.Vscdcmnd.editor.action.removeDuplicateLines,

Vsccmdi.editor.action.rename,
· key: f2,
· when: editorHasRenameProvider && editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.rename,

Vsccmdi.editor.action.replaceAll,
· key: ctrl+alt+enter,
· when: editorFocus && findWidgetVisible,
===
* McshEngl.Vscdcmnd.editor.action.replaceAll,

Vsccmdi.editor.action.replaceOne,
· key: ctrl+shift+1,
· when: editorFocus && findWidgetVisible,
===
* McshEngl.Vscdcmnd.editor.action.replaceOne,

Vsccmdi.editor.action.replaceOne,
· key: enter,
· when: editorFocus && findWidgetVisible && replaceInputFocussed && !isComposing,
===
* McshEngl.Vscdcmnd.editor.action.replaceOne,

Vsccmdi.editor.action.resetSuggestSize,
===
* McshEngl.Vscdcmnd.editor.action.resetSuggestSize,

Vsccmdi.editor.action.revealDeclaration,
===
* McshEngl.Vscdcmnd.editor.action.revealDeclaration,

Vsccmdi.editor.action.revealDefinition,
· key: ctrl+f12,
· when: editorHasDefinitionProvider && editorTextFocus && isWeb,
===
* McshEngl.Vscdcmnd.editor.action.revealDefinition,

Vsccmdi.editor.action.revealDefinition,
· key: f12,
· when: editorHasDefinitionProvider && editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.action.revealDefinition,

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

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

Vsccmdi.editor.action.reverseLines,
===
* McshEngl.Vscdcmnd.editor.action.reverseLines,

Vsccmdi.editor.action.scrollDownHover,
· key: down,
· when: editorHoverFocused,
===
* McshEngl.Vscdcmnd.editor.action.scrollDownHover,

Vsccmdi.editor.action.scrollLeftHover,
· key: left,
· when: editorHoverFocused,
===
* McshEngl.Vscdcmnd.editor.action.scrollLeftHover,

Vsccmdi.editor.action.scrollRightHover,
· key: right,
· when: editorHoverFocused,
===
* McshEngl.Vscdcmnd.editor.action.scrollRightHover,

Vsccmdi.editor.action.scrollUpHover,
· key: up,
· when: editorHoverFocused,
===
* McshEngl.Vscdcmnd.editor.action.scrollUpHover,

Vsccmdi.editor.action.selectAll,
· key: ctrl+a,
===
* McshEngl.Vscdcmnd.editor.action.selectAll,

Vsccmdi.editor.action.selectAllMatches,
· key: alt+enter,
· when: editorFocus && findWidgetVisible,
===
* McshEngl.Vscdcmnd.editor.action.selectAllMatches,

Vsccmdi.editor.action.selectEditor,
· key: escape,
· when: stickyScrollFocused,
===
* McshEngl.Vscdcmnd.editor.action.selectEditor,

Vsccmdi.editor.action.selectFromAnchorToCursor,
· key: ctrl+k ctrl+k,
· when: editorTextFocus && selectionAnchorSet,
===
* McshEngl.Vscdcmnd.editor.action.selectFromAnchorToCursor,

Vsccmdi.editor.action.selectHighlights,
· key: ctrl+shift+l,
· when: editorFocus,
===
* McshEngl.Vscdcmnd.editor.action.selectHighlights,

Vsccmdi.editor.action.selectNextStickyScrollLine,
· key: down,
· when: stickyScrollFocused,
===
* McshEngl.Vscdcmnd.editor.action.selectNextStickyScrollLine,

Vsccmdi.editor.action.selectPreviousStickyScrollLine,
· key: up,
· when: stickyScrollFocused,
===
* McshEngl.Vscdcmnd.editor.action.selectPreviousStickyScrollLine,

Vsccmdi.editor.action.selectToBracket,
===
* McshEngl.Vscdcmnd.editor.action.selectToBracket,

Vsccmdi.editor.action.setSelectionAnchor,
· key: ctrl+k ctrl+b,
· when: editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.action.setSelectionAnchor,

Vsccmdi.editor.action.showContextMenu,
· key: shift+f10,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.editor.action.showContextMenu,

Vsccmdi.editor.action.showDefinitionPreviewHover,
===
* McshEngl.Vscdcmnd.editor.action.showDefinitionPreviewHover,

Vsccmdi.editor.action.showHover,
· key: ctrl+k ctrl+i,
· when: editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.action.showHover,

Vsccmdi.editor.action.showOrFocusStandaloneColorPicker,
===
* McshEngl.Vscdcmnd.editor.action.showOrFocusStandaloneColorPicker,

Vsccmdi.editor.action.showReferences,
===
* McshEngl.Vscdcmnd.editor.action.showReferences,

Vsccmdi.editor.action.showSnippets,
===
* McshEngl.Vscdcmnd.editor.action.showSnippets,

Vsccmdi.editor.action.smartSelect.expand,
· key: shift+alt+right,
· when: editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.action.smartSelect.expand,

Vsccmdi.editor.action.smartSelect.grow,
===
* McshEngl.Vscdcmnd.editor.action.smartSelect.grow,

Vsccmdi.editor.action.smartSelect.shrink,
· key: shift+alt+left,
· when: editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.action.smartSelect.shrink,

Vsccmdi.editor.action.sortLinesAscending,
===
* McshEngl.Vscdcmnd.editor.action.sortLinesAscending,

Vsccmdi.editor.action.sortLinesDescending,
===
* McshEngl.Vscdcmnd.editor.action.sortLinesDescending,

Vsccmdi.editor.action.sourceAction,
===
* McshEngl.Vscdcmnd.editor.action.sourceAction,

Vsccmdi.editor.action.startDebugTextMate,
===
* McshEngl.Vscdcmnd.editor.action.startDebugTextMate,

Vsccmdi.editor.action.startFindReplaceAction,
· key: ctrl+h,
· when: editorFocus || editorIsOpen,
===
* McshEngl.Vscdcmnd.editor.action.startFindReplaceAction,

Vsccmdi.editor.action.submitComment,
· key: ctrl+enter,
· when: commentEditorFocused,
===
* McshEngl.Vscdcmnd.editor.action.submitComment,

Vsccmdi.editor.action.surroundWithSnippet,
===
* McshEngl.Vscdcmnd.editor.action.surroundWithSnippet,

Vsccmdi.editor.action.toggleColumnSelection,
===
* McshEngl.Vscdcmnd.editor.action.toggleColumnSelection,

Vsccmdi.editor.action.toggleMinimap,
===
* McshEngl.Vscdcmnd.editor.action.toggleMinimap,

Vsccmdi.editor.action.toggleOvertypeInsertMode,
· key: insert,
===
* McshEngl.Vscdcmnd.editor.action.toggleOvertypeInsertMode,

Vsccmdi.editor.action.toggleRenderControlCharacter,
===
* McshEngl.Vscdcmnd.editor.action.toggleRenderControlCharacter,

Vsccmdi.editor.action.toggleRenderWhitespace,
===
* McshEngl.Vscdcmnd.editor.action.toggleRenderWhitespace,

Vsccmdi.editor.action.toggleScreenReaderAccessibilityMode,
· key: ctrl+e,
· when: accessibilityHelpIsShown,
===
* McshEngl.Vscdcmnd.editor.action.toggleScreenReaderAccessibilityMode,

Vsccmdi.editor.action.toggleScreenReaderAccessibilityMode,
· key: shift+alt+f1,
===
* McshEngl.Vscdcmnd.editor.action.toggleScreenReaderAccessibilityMode,

Vsccmdi.editor.action.toggleStickyScroll,
===
* McshEngl.Vscdcmnd.editor.action.toggleStickyScroll,

Vsccmdi.editor.action.toggleTabFocusMode,
· key: ctrl+m,
===
* McshEngl.Vscdcmnd.editor.action.toggleTabFocusMode,

Vsccmdi.editor.action.toggleWordWrap,
· key: alt+z,
===
* McshEngl.Vscdcmnd.editor.action.toggleWordWrap,

Vsccmdi.editor.action.transformToCamelcase,
===
* McshEngl.Vscdcmnd.editor.action.transformToCamelcase,

Vsccmdi.editor.action.transformToKebabcase,
===
* McshEngl.Vscdcmnd.editor.action.transformToKebabcase,

Vsccmdi.editor.action.transformToLowercase,
===
* McshEngl.Vscdcmnd.editor.action.transformToLowercase,

Vsccmdi.editor.action.transformToPascalcase,
===
* McshEngl.Vscdcmnd.editor.action.transformToPascalcase,

Vsccmdi.editor.action.transformToSnakecase,
===
* McshEngl.Vscdcmnd.editor.action.transformToSnakecase,

Vsccmdi.editor.action.transformToTitlecase,
===
* McshEngl.Vscdcmnd.editor.action.transformToTitlecase,

Vsccmdi.editor.action.transformToUppercase,
===
* McshEngl.Vscdcmnd.editor.action.transformToUppercase,

Vsccmdi.editor.action.transpose,
===
* McshEngl.Vscdcmnd.editor.action.transpose,

Vsccmdi.editor.action.transposeLetters,
===
* McshEngl.Vscdcmnd.editor.action.transposeLetters,

Vsccmdi.editor.action.triggerParameterHints,
· key: ctrl+shift+space,
· when: editorHasSignatureHelpProvider && editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.action.triggerParameterHints,

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

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

Vsccmdi.editor.action.trimTrailingWhitespace,
· key: ctrl+k ctrl+x,
· when: editorTextFocus && !editorReadonly,
===
* McshEngl.Vscdcmnd.editor.action.trimTrailingWhitespace,

Vsccmdi.editor.action.unicodeHighlight.disableHighlightingOfAmbiguousCharacters,
===
* McshEngl.Vscdcmnd.editor.action.unicodeHighlight.disableHighlightingOfAmbiguousCharacters,

Vsccmdi.editor.action.unicodeHighlight.disableHighlightingOfInvisibleCharacters,
===
* McshEngl.Vscdcmnd.editor.action.unicodeHighlight.disableHighlightingOfInvisibleCharacters,

Vsccmdi.editor.action.unicodeHighlight.disableHighlightingOfNonBasicAsciiCharacters,
===
* McshEngl.Vscdcmnd.editor.action.unicodeHighlight.disableHighlightingOfNonBasicAsciiCharacters,

Vsccmdi.editor.action.unicodeHighlight.showExcludeOptions,
===
* McshEngl.Vscdcmnd.editor.action.unicodeHighlight.showExcludeOptions,

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

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

Vsccmdi.editor.action.webvieweditor.hideFind,
· key: escape,
· when: webviewFindWidgetVisible && !editorFocus && activeEditor == 'WebviewEditor',
===
* McshEngl.Vscdcmnd.editor.action.webvieweditor.hideFind,

Vsccmdi.editor.action.webvieweditor.showFind,
· key: ctrl+f,
· when: webviewFindWidgetEnabled && !editorFocus && activeEditor == 'WebviewEditor',
===
* McshEngl.Vscdcmnd.editor.action.webvieweditor.showFind,

Vsccmdi.editor.action.wordHighlight.next,
· key: f7,
· when: editorTextFocus && hasWordHighlights,
===
* McshEngl.Vscdcmnd.editor.action.wordHighlight.next,

Vsccmdi.editor.action.wordHighlight.prev,
· key: shift+f7,
· when: editorTextFocus && hasWordHighlights,
===
* McshEngl.Vscdcmnd.editor.action.wordHighlight.prev,

Vsccmdi.editor.action.wordHighlight.trigger,
===
* McshEngl.Vscdcmnd.editor.action.wordHighlight.trigger,

Vsccmdi.editor.actions.findWithArgs,
===
* McshEngl.Vscdcmnd.editor.actions.findWithArgs,

Vsccmdi.editor.cancelOperation,
· key: escape,
· when: cancellableOperation,
===
* McshEngl.Vscdcmnd.editor.cancelOperation,

Vsccmdi.editor.changeDropType,
· key: ctrl+.,
· when: dropWidgetVisible,
===
* McshEngl.Vscdcmnd.editor.changeDropType,

Vsccmdi.editor.changePasteType,
· key: ctrl+.,
· when: pasteWidgetVisible,
===
* McshEngl.Vscdcmnd.editor.changePasteType,

Vsccmdi.editor.closeCallHierarchy,
· key: escape,
· when: callHierarchyVisible && !config.editor.stablePeek,
===
* McshEngl.Vscdcmnd.editor.closeCallHierarchy,

Vsccmdi.editor.closeTestPeek,
· key: escape,
· when: testing.isInPeek && !config.editor.stablePeek || testing.isPeekVisible && !config.editor.stablePeek,
===
* McshEngl.Vscdcmnd.editor.closeTestPeek,

Vsccmdi.editor.closeTypeHierarchy,
· key: escape,
· when: typeHierarchyVisible && !config.editor.stablePeek,
===
* McshEngl.Vscdcmnd.editor.closeTypeHierarchy,

Vsccmdi.editor.createFoldingRangeFromSelection,
· key: ctrl+k ctrl+,,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.createFoldingRangeFromSelection,

Vsccmdi.editor.debug.action.addLogPoint,
===
* McshEngl.Vscdcmnd.editor.debug.action.addLogPoint,

Vsccmdi.editor.debug.action.closeExceptionWidget,
· key: escape,
· when: exceptionWidgetVisible,
===
* McshEngl.Vscdcmnd.editor.debug.action.closeExceptionWidget,

Vsccmdi.editor.debug.action.conditionalBreakpoint,
===
* McshEngl.Vscdcmnd.editor.debug.action.conditionalBreakpoint,

Vsccmdi.editor.debug.action.copyAddress,
===
* McshEngl.Vscdcmnd.editor.debug.action.copyAddress,

Vsccmdi.editor.debug.action.editBreakpoint,
===
* McshEngl.Vscdcmnd.editor.debug.action.editBreakpoint,

Vsccmdi.editor.debug.action.goToNextBreakpoint,
===
* McshEngl.Vscdcmnd.editor.debug.action.goToNextBreakpoint,

Vsccmdi.editor.debug.action.goToPreviousBreakpoint,
===
* McshEngl.Vscdcmnd.editor.debug.action.goToPreviousBreakpoint,

Vsccmdi.editor.debug.action.runToCursor,
===
* McshEngl.Vscdcmnd.editor.debug.action.runToCursor,

Vsccmdi.editor.debug.action.selectionToRepl,
===
* McshEngl.Vscdcmnd.editor.debug.action.selectionToRepl,

Vsccmdi.editor.debug.action.selectionToWatch,
===
* McshEngl.Vscdcmnd.editor.debug.action.selectionToWatch,

Vsccmdi.editor.debug.action.showDebugHover,
· key: ctrl+k ctrl+i,
· when: editorTextFocus && inDebugMode,
===
* McshEngl.Vscdcmnd.editor.debug.action.showDebugHover,

Vsccmdi.editor.debug.action.stepIntoTargets,
===
* McshEngl.Vscdcmnd.editor.debug.action.stepIntoTargets,

Vsccmdi.editor.debug.action.toggleBreakpoint,
· key: f9,
· when: debuggersAvailable && disassemblyViewFocus || debuggersAvailable && editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.debug.action.toggleBreakpoint,

Vsccmdi.editor.debug.action.toggleInlineBreakpoint,
· key: shift+f9,
· when: editorTextFocus,
===
* McshEngl.Vscdcmnd.editor.debug.action.toggleInlineBreakpoint,

Vsccmdi.editor.debug.action.triggerByBreakpoint,
===
* McshEngl.Vscdcmnd.editor.debug.action.triggerByBreakpoint,

Vsccmdi.editor.detectLanguage,
· key: shift+alt+d,
· when: editorTextFocus && !notebookEditable,
===
* McshEngl.Vscdcmnd.editor.detectLanguage,

Vsccmdi.editor.emmet.action.balanceIn,
===
* McshEngl.Vscdcmnd.editor.emmet.action.balanceIn,

Vsccmdi.editor.emmet.action.balanceOut,
===
* McshEngl.Vscdcmnd.editor.emmet.action.balanceOut,

Vsccmdi.editor.emmet.action.decrementNumberByOne,
===
* McshEngl.Vscdcmnd.editor.emmet.action.decrementNumberByOne,

Vsccmdi.editor.emmet.action.decrementNumberByOneTenth,
===
* McshEngl.Vscdcmnd.editor.emmet.action.decrementNumberByOneTenth,

Vsccmdi.editor.emmet.action.decrementNumberByTen,
===
* McshEngl.Vscdcmnd.editor.emmet.action.decrementNumberByTen,

Vsccmdi.editor.emmet.action.evaluateMathExpression,
===
* McshEngl.Vscdcmnd.editor.emmet.action.evaluateMathExpression,

Vsccmdi.editor.emmet.action.expandAbbreviation,
· key: tab,
· when: config.emmet.triggerExpansionOnTab && editorTextFocus && !editorReadonly && !editorTabMovesFocus,
===
* McshEngl.Vscdcmnd.editor.emmet.action.expandAbbreviation,

Vsccmdi.editor.emmet.action.incrementNumberByOne,
===
* McshEngl.Vscdcmnd.editor.emmet.action.incrementNumberByOne,

Vsccmdi.editor.emmet.action.incrementNumberByOneTenth,
===
* McshEngl.Vscdcmnd.editor.emmet.action.incrementNumberByOneTenth,

Vsccmdi.editor.emmet.action.incrementNumberByTen,
===
* McshEngl.Vscdcmnd.editor.emmet.action.incrementNumberByTen,

Vsccmdi.editor.emmet.action.matchTag,
===
* McshEngl.Vscdcmnd.editor.emmet.action.matchTag,

Vsccmdi.editor.emmet.action.mergeLines,
===
* McshEngl.Vscdcmnd.editor.emmet.action.mergeLines,

Vsccmdi.editor.emmet.action.nextEditPoint,
===
* McshEngl.Vscdcmnd.editor.emmet.action.nextEditPoint,

Vsccmdi.editor.emmet.action.prevEditPoint,
===
* McshEngl.Vscdcmnd.editor.emmet.action.prevEditPoint,

Vsccmdi.editor.emmet.action.reflectCSSValue,
===
* McshEngl.Vscdcmnd.editor.emmet.action.reflectCSSValue,

Vsccmdi.editor.emmet.action.removeTag,
===
* McshEngl.Vscdcmnd.editor.emmet.action.removeTag,

Vsccmdi.editor.emmet.action.selectNextItem,
===
* McshEngl.Vscdcmnd.editor.emmet.action.selectNextItem,

Vsccmdi.editor.emmet.action.selectPrevItem,
===
* McshEngl.Vscdcmnd.editor.emmet.action.selectPrevItem,

Vsccmdi.editor.emmet.action.splitJoinTag,
===
* McshEngl.Vscdcmnd.editor.emmet.action.splitJoinTag,

Vsccmdi.editor.emmet.action.toggleComment,
===
* McshEngl.Vscdcmnd.editor.emmet.action.toggleComment,

Vsccmdi.editor.emmet.action.updateImageSize,
===
* McshEngl.Vscdcmnd.editor.emmet.action.updateImageSize,

Vsccmdi.editor.emmet.action.updateTag,
===
* McshEngl.Vscdcmnd.editor.emmet.action.updateTag,

Vsccmdi.editor.emmet.action.wrapWithAbbreviation,
===
* McshEngl.Vscdcmnd.editor.emmet.action.wrapWithAbbreviation,

Vsccmdi.editor.fold,
· key: ctrl+shift+[,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.fold,

Vsccmdi.editor.foldAll,
· key: ctrl+k ctrl+0,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.foldAll,

Vsccmdi.editor.foldAllBlockComments,
· key: ctrl+k ctrl+/,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.foldAllBlockComments,

Vsccmdi.editor.foldAllExcept,
· key: ctrl+k ctrl+-,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.foldAllExcept,

Vsccmdi.editor.foldAllMarkerRegions,
· key: ctrl+k ctrl+8,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.foldAllMarkerRegions,

Vsccmdi.editor.foldLevel1,
· key: ctrl+k ctrl+1,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.foldLevel1,

Vsccmdi.editor.foldLevel2,
· key: ctrl+k ctrl+2,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.foldLevel2,

Vsccmdi.editor.foldLevel3,
· key: ctrl+k ctrl+3,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.foldLevel3,

Vsccmdi.editor.foldLevel4,
· key: ctrl+k ctrl+4,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.foldLevel4,

Vsccmdi.editor.foldLevel5,
· key: ctrl+k ctrl+5,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.foldLevel5,

Vsccmdi.editor.foldLevel6,
· key: ctrl+k ctrl+6,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.foldLevel6,

Vsccmdi.editor.foldLevel7,
· key: ctrl+k ctrl+7,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.foldLevel7,

Vsccmdi.editor.foldRecursively,
· key: ctrl+k ctrl+[,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.foldRecursively,

Vsccmdi.editor.gotoNextFold,
===
* McshEngl.Vscdcmnd.editor.gotoNextFold,

Vsccmdi.editor.gotoNextSymbolFromResult,
· key: f12,
· when: hasSymbols,
===
* McshEngl.Vscdcmnd.editor.gotoNextSymbolFromResult,

Vsccmdi.editor.gotoNextSymbolFromResult.cancel,
· key: escape,
· when: hasSymbols,
===
* McshEngl.Vscdcmnd.editor.gotoNextSymbolFromResult.cancel,

Vsccmdi.editor.gotoParentFold,
===
* McshEngl.Vscdcmnd.editor.gotoParentFold,

Vsccmdi.editor.gotoPreviousFold,
===
* McshEngl.Vscdcmnd.editor.gotoPreviousFold,

Vsccmdi.editor.hideDropWidget,
· key: escape,
· when: dropWidgetVisible,
===
* McshEngl.Vscdcmnd.editor.hideDropWidget,

Vsccmdi.editor.hidePasteWidget,
· key: escape,
· when: pasteWidgetVisible,
===
* McshEngl.Vscdcmnd.editor.hidePasteWidget,

Vsccmdi.editor.inlayHints.Reset,
===
* McshEngl.Vscdcmnd.editor.inlayHints.Reset,

Vsccmdi.editor.refocusCallHierarchy,
· key: shift+enter,
· when: callHierarchyVisible,
===
* McshEngl.Vscdcmnd.editor.refocusCallHierarchy,

Vsccmdi.editor.refocusTypeHierarchy,
· key: shift+enter,
· when: typeHierarchyVisible,
===
* McshEngl.Vscdcmnd.editor.refocusTypeHierarchy,

Vsccmdi.editor.removeManualFoldingRanges,
· key: ctrl+k ctrl+.,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.removeManualFoldingRanges,

Vsccmdi.editor.showCallHierarchy,
· key: shift+alt+h,
· when: editorHasCallHierarchyProvider && editorTextFocus && !inReferenceSearchEditor,
===
* McshEngl.Vscdcmnd.editor.showCallHierarchy,

Vsccmdi.editor.showIncomingCalls,
· key: shift+alt+h,
· when: callHierarchyVisible && callHierarchyDirection == 'outgoingCalls',
===
* McshEngl.Vscdcmnd.editor.showIncomingCalls,

Vsccmdi.editor.showOutgoingCalls,
· key: shift+alt+h,
· when: callHierarchyVisible && callHierarchyDirection == 'incomingCalls',
===
* McshEngl.Vscdcmnd.editor.showOutgoingCalls,

Vsccmdi.editor.showSubtypes,
· key: shift+alt+h,
· when: typeHierarchyVisible && typeHierarchyDirection == 'supertypes',
===
* McshEngl.Vscdcmnd.editor.showSubtypes,

Vsccmdi.editor.showSupertypes,
· key: shift+alt+h,
· when: typeHierarchyVisible && typeHierarchyDirection == 'subtypes',
===
* McshEngl.Vscdcmnd.editor.showSupertypes,

Vsccmdi.editor.showTypeHierarchy,
===
* McshEngl.Vscdcmnd.editor.showTypeHierarchy,

Vsccmdi.editor.toggleFold,
· key: ctrl+k ctrl+l,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.toggleFold,

Vsccmdi.editor.toggleFoldRecursively,
· key: ctrl+k ctrl+shift+l,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.toggleFoldRecursively,

Vsccmdi.editor.toggleImportFold,
===
* McshEngl.Vscdcmnd.editor.toggleImportFold,

Vsccmdi.editor.unfold,
· key: ctrl+shift+],
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.unfold,

Vsccmdi.editor.unfoldAll,
· key: ctrl+k ctrl+j,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.unfoldAll,

Vsccmdi.editor.unfoldAllExcept,
· key: ctrl+k ctrl+=,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.unfoldAllExcept,

Vsccmdi.editor.unfoldAllMarkerRegions,
· key: ctrl+k ctrl+9,
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.unfoldAllMarkerRegions,

Vsccmdi.editor.unfoldRecursively,
· key: ctrl+k ctrl+],
· when: editorTextFocus && foldingEnabled,
===
* McshEngl.Vscdcmnd.editor.unfoldRecursively,

Vsccmdi.emmet.expandAbbreviation,
===
* McshEngl.Vscdcmnd.emmet.expandAbbreviation,

Vsccmdi.eslint.applyAllFixes,
===
* McshEngl.Vscdcmnd.eslint.applyAllFixes,

Vsccmdi.eslint.applyDisableFile,
===
* McshEngl.Vscdcmnd.eslint.applyDisableFile,

Vsccmdi.eslint.applyDisableLine,
===
* McshEngl.Vscdcmnd.eslint.applyDisableLine,

Vsccmdi.eslint.applySameFixes,
===
* McshEngl.Vscdcmnd.eslint.applySameFixes,

Vsccmdi.eslint.applySingleFix,
===
* McshEngl.Vscdcmnd.eslint.applySingleFix,

Vsccmdi.eslint.applySuggestion,
===
* McshEngl.Vscdcmnd.eslint.applySuggestion,

Vsccmdi.eslint.createConfig,
===
* McshEngl.Vscdcmnd.eslint.createConfig,

Vsccmdi.eslint.executeAutofix,
===
* McshEngl.Vscdcmnd.eslint.executeAutofix,

Vsccmdi.eslint.migrateSettings,
===
* McshEngl.Vscdcmnd.eslint.migrateSettings,

Vsccmdi.eslint.openRuleDoc,
===
* McshEngl.Vscdcmnd.eslint.openRuleDoc,

Vsccmdi.eslint.restart,
===
* McshEngl.Vscdcmnd.eslint.restart,

Vsccmdi.eslint.revalidate,
===
* McshEngl.Vscdcmnd.eslint.revalidate,

Vsccmdi.eslint.showOutputChannel,
===
* McshEngl.Vscdcmnd.eslint.showOutputChannel,

Vsccmdi.expandLineSelection,
· key: ctrl+l,
· when: textInputFocus,
===
* McshEngl.Vscdcmnd.expandLineSelection,

Vsccmdi.expandSectionCodeAction,
· key: right,
· when: codeActionMenuVisible && !codeActionMenuFilterFocused,
===
* McshEngl.Vscdcmnd.expandSectionCodeAction,

Vsccmdi.explorer.download,
===
* McshEngl.Vscdcmnd.explorer.download,

Vsccmdi.explorer.newFile,
===
* McshEngl.Vscdcmnd.explorer.newFile,

Vsccmdi.explorer.newFolder,
===
* McshEngl.Vscdcmnd.explorer.newFolder,

Vsccmdi.explorer.openAndPassFocus,
· key: enter,
· when: filesExplorerFocus && foldersViewVisible && !explorerResourceIsFolder && !inputFocus,
===
* McshEngl.Vscdcmnd.explorer.openAndPassFocus,

Vsccmdi.explorer.openToSide,
· key: ctrl+enter,
· when: explorerViewletFocus && foldersViewVisible && !inputFocus,
===
* McshEngl.Vscdcmnd.explorer.openToSide,

Vsccmdi.explorer.openWith,
===
* McshEngl.Vscdcmnd.explorer.openWith,

Vsccmdi.explorer.upload,
===
* McshEngl.Vscdcmnd.explorer.upload,

Vsccmdi.extension.bisect.next,
===
* McshEngl.Vscdcmnd.extension.bisect.next,

Vsccmdi.extension.bisect.start,
===
* McshEngl.Vscdcmnd.extension.bisect.start,

Vsccmdi.extension.bisect.stop,
===
* McshEngl.Vscdcmnd.extension.bisect.stop,

Vsccmdi.extension.charInsertInt,
· key: ctrl+alt+c i,
· when: editorTextFocus,
===
* McshEngl.Vscdcmnd.extension.charInsertInt,

Vsccmdi.extension.htmlLtReplace,
===
* McshEngl.Vscdcmnd.extension.htmlLtReplace,

Vsccmdi.extension.htmlTagInsert,
· key: ctrl+alt+h t,
· when: editorTextFocus,
===
* McshEngl.Vscdcmnd.extension.htmlTagInsert,

Vsccmdi.extension.js-debug.addCustomBreakpoints,
===
* McshEngl.Vscdcmnd.extension.js_debug.addCustomBreakpoints,

Vsccmdi.extension.js-debug.addXHRBreakpoints,
===
* McshEngl.Vscdcmnd.extension.js_debug.addXHRBreakpoints,

Vsccmdi.extension.js-debug.callers.add,
===
* McshEngl.Vscdcmnd.extension.js_debug.callers.add,

Vsccmdi.extension.js-debug.callers.goToCaller,
===
* McshEngl.Vscdcmnd.extension.js_debug.callers.goToCaller,

Vsccmdi.extension.js-debug.callers.gotToTarget,
===
* McshEngl.Vscdcmnd.extension.js_debug.callers.gotToTarget,

Vsccmdi.extension.js-debug.callers.remove,
===
* McshEngl.Vscdcmnd.extension.js_debug.callers.remove,

Vsccmdi.extension.js-debug.callers.removeAll,
===
* McshEngl.Vscdcmnd.extension.js_debug.callers.removeAll,

Vsccmdi.extension.js-debug.createDebuggerTerminal,
===
* McshEngl.Vscdcmnd.extension.js_debug.createDebuggerTerminal,

Vsccmdi.extension.js-debug.createDiagnostics,
===
* McshEngl.Vscdcmnd.extension.js_debug.createDiagnostics,

Vsccmdi.extension.js-debug.debugLink,
===
* McshEngl.Vscdcmnd.extension.js_debug.debugLink,

Vsccmdi.extension.js-debug.disableSourceMapStepping,
===
* McshEngl.Vscdcmnd.extension.js_debug.disableSourceMapStepping,

Vsccmdi.extension.js-debug.editXHRBreakpoints,
===
* McshEngl.Vscdcmnd.extension.js_debug.editXHRBreakpoints,

Vsccmdi.extension.js-debug.enableSourceMapStepping,
===
* McshEngl.Vscdcmnd.extension.js_debug.enableSourceMapStepping,

Vsccmdi.extension.js-debug.getDiagnosticLogs,
===
* McshEngl.Vscdcmnd.extension.js_debug.getDiagnosticLogs,

Vsccmdi.extension.js-debug.network.clear,
===
* McshEngl.Vscdcmnd.extension.js_debug.network.clear,

Vsccmdi.extension.js-debug.network.copyUri,
===
* McshEngl.Vscdcmnd.extension.js_debug.network.copyUri,

Vsccmdi.extension.js-debug.network.openBody,
===
* McshEngl.Vscdcmnd.extension.js_debug.network.openBody,

Vsccmdi.extension.js-debug.network.openBodyInHex,
===
* McshEngl.Vscdcmnd.extension.js_debug.network.openBodyInHex,

Vsccmdi.extension.js-debug.network.replayXHR,
===
* McshEngl.Vscdcmnd.extension.js_debug.network.replayXHR,

Vsccmdi.extension.js-debug.network.viewRequest,
===
* McshEngl.Vscdcmnd.extension.js_debug.network.viewRequest,

Vsccmdi.extension.js-debug.npmScript,
===
* McshEngl.Vscdcmnd.extension.js_debug.npmScript,

Vsccmdi.extension.js-debug.openEdgeDevTools,
===
* McshEngl.Vscdcmnd.extension.js_debug.openEdgeDevTools,

Vsccmdi.extension.js-debug.prettyPrint,
===
* McshEngl.Vscdcmnd.extension.js_debug.prettyPrint,

Vsccmdi.extension.js-debug.removeAllCustomBreakpoints,
===
* McshEngl.Vscdcmnd.extension.js_debug.removeAllCustomBreakpoints,

Vsccmdi.extension.js-debug.removeXHRBreakpoint,
===
* McshEngl.Vscdcmnd.extension.js_debug.removeXHRBreakpoint,

Vsccmdi.extension.js-debug.revealPage,
===
* McshEngl.Vscdcmnd.extension.js_debug.revealPage,

Vsccmdi.extension.js-debug.startProfile,
===
* McshEngl.Vscdcmnd.extension.js_debug.startProfile,

Vsccmdi.extension.js-debug.stopProfile,
===
* McshEngl.Vscdcmnd.extension.js_debug.stopProfile,

Vsccmdi.extension.js-debug.toggleSkippingFile,
===
* McshEngl.Vscdcmnd.extension.js_debug.toggleSkippingFile,

Vsccmdi.extension.jsProfileVisualizer.table.clearCodeLenses,
===
* McshEngl.Vscdcmnd.extension.jsProfileVisualizer.table.clearCodeLenses,

Vsccmdi.extension.multiCommand.execute,
===
* McshEngl.Vscdcmnd.extension.multiCommand.execute,

Vsccmdi.extension.node-debug.startWithStopOnEntry,
· key: f10,
· when: !inDebugMode && debugConfigurationType == 'node' || !inDebugMode && debugConfigurationType == 'pwa-extensionHost' || !inDebugMode && debugConfigurationType == 'pwa-node',
===
* McshEngl.Vscdcmnd.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',
===
* McshEngl.Vscdcmnd.extension.node_debug.startWithStopOnEntry,

Vsccmdi.extension.node-debug.toggleAutoAttach,
===
* McshEngl.Vscdcmnd.extension.node_debug.toggleAutoAttach,

Vsccmdi.extension.open,
===
* McshEngl.Vscdcmnd.extension.open,

Vsccmdi.extension.pwa-node-debug.attachNodeProcess,
===
* McshEngl.Vscdcmnd.extension.pwa_node_debug.attachNodeProcess,

Vsccmdi.extension.userInput,
· inserts user text and selects it.
· key: ctrl+alt+t,
· when: editorTextFocus,
===
* McshEngl.Vscdcmnd.extension.userInput,

Vsccmdi.extensions.actions.searchByCategory.AI,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.AI,

Vsccmdi.extensions.actions.searchByCategory.Azure,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Azure,

Vsccmdi.extensions.actions.searchByCategory.Chat,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Chat,

Vsccmdi.extensions.actions.searchByCategory.Data Science,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Data Science,

Vsccmdi.extensions.actions.searchByCategory.Debuggers,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Debuggers,

Vsccmdi.extensions.actions.searchByCategory.Education,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Education,

Vsccmdi.extensions.actions.searchByCategory.Extension Packs,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Extension Packs,

Vsccmdi.extensions.actions.searchByCategory.Formatters,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Formatters,

Vsccmdi.extensions.actions.searchByCategory.Keymaps,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Keymaps,

Vsccmdi.extensions.actions.searchByCategory.Language Packs,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Language Packs,

Vsccmdi.extensions.actions.searchByCategory.Linters,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Linters,

Vsccmdi.extensions.actions.searchByCategory.Machine Learning,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Machine Learning,

Vsccmdi.extensions.actions.searchByCategory.Notebooks,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Notebooks,

Vsccmdi.extensions.actions.searchByCategory.Other,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Other,

Vsccmdi.extensions.actions.searchByCategory.Programming Languages,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Programming Languages,

Vsccmdi.extensions.actions.searchByCategory.SCM Providers,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.SCM Providers,

Vsccmdi.extensions.actions.searchByCategory.Snippets,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Snippets,

Vsccmdi.extensions.actions.searchByCategory.Testing,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Testing,

Vsccmdi.extensions.actions.searchByCategory.Themes,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Themes,

Vsccmdi.extensions.actions.searchByCategory.Visualization,
===
* McshEngl.Vscdcmnd.extensions.actions.searchByCategory.Visualization,

Vsccmdi.extensions.filter.featured,
===
* McshEngl.Vscdcmnd.extensions.filter.featured,

Vsccmdi.extensions.recommendedList.focus,
===
* McshEngl.Vscdcmnd.extensions.recommendedList.focus,

Vsccmdi.extensions.recommendedList.resetViewLocation,
===
* McshEngl.Vscdcmnd.extensions.recommendedList.resetViewLocation,

Vsccmdi.extensions.sort.installs,
===
* McshEngl.Vscdcmnd.extensions.sort.installs,

Vsccmdi.extensions.sort.name,
===
* McshEngl.Vscdcmnd.extensions.sort.name,

Vsccmdi.extensions.sort.publishedDate,
===
* McshEngl.Vscdcmnd.extensions.sort.publishedDate,

Vsccmdi.extensions.sort.rating,
===
* McshEngl.Vscdcmnd.extensions.sort.rating,

Vsccmdi.extensions.sort.updateDate,
===
* McshEngl.Vscdcmnd.extensions.sort.updateDate,

Vsccmdi.files.openTimeline,
===
* McshEngl.Vscdcmnd.files.openTimeline,

Vsccmdi.files.participants.resetChoice,
===
* McshEngl.Vscdcmnd.files.participants.resetChoice,

Vsccmdi.filesExplorer.cancelCut,
· key: escape,
· when: explorerResourceCut && filesExplorerFocus && foldersViewVisible && !inputFocus,
===
* McshEngl.Vscdcmnd.filesExplorer.cancelCut,

Vsccmdi.filesExplorer.copy,
· key: ctrl+c,
· when: filesExplorerFocus && foldersViewVisible && !explorerResourceIsRoot && !inputFocus,
===
* McshEngl.Vscdcmnd.filesExplorer.copy,

Vsccmdi.filesExplorer.cut,
· key: ctrl+x,
· when: filesExplorerFocus && foldersViewVisible && !explorerResourceIsRoot && !explorerResourceReadonly && !inputFocus,
===
* McshEngl.Vscdcmnd.filesExplorer.cut,

Vsccmdi.filesExplorer.findInFolder,
· key: shift+alt+f,
· when: explorerResourceIsFolder && filesExplorerFocus && foldersViewVisible && !inputFocus,
===
* McshEngl.Vscdcmnd.filesExplorer.findInFolder,

Vsccmdi.filesExplorer.findInWorkspace,
===
* McshEngl.Vscdcmnd.filesExplorer.findInWorkspace,

Vsccmdi.filesExplorer.openFilePreserveFocus,
· key: space,
· when: filesExplorerFocus && foldersViewVisible && !explorerResourceIsFolder && !inputFocus,
===
* McshEngl.Vscdcmnd.filesExplorer.openFilePreserveFocus,

Vsccmdi.filesExplorer.paste,
· key: ctrl+v,
· when: filesExplorerFocus && foldersViewVisible && !explorerResourceReadonly && !inputFocus,
===
* McshEngl.Vscdcmnd.filesExplorer.paste,

Vsccmdi.firstCompressedFolder,
· key: home,
· when: explorerViewletCompressedFocus && filesExplorerFocus && foldersViewVisible && !explorerViewletCompressedFirstFocus && !inputFocus,
===
* McshEngl.Vscdcmnd.firstCompressedFolder,

Vsccmdi.focusAndAcceptSuggestion,
===
* McshEngl.Vscdcmnd.focusAndAcceptSuggestion,

Vsccmdi.focusNextRenameSuggestion,
· key: down,
· when: renameInputVisible,
===
* McshEngl.Vscdcmnd.focusNextRenameSuggestion,

Vsccmdi.focusPreviousRenameSuggestion,
· key: up,
· when: renameInputVisible,
===
* McshEngl.Vscdcmnd.focusPreviousRenameSuggestion,

Vsccmdi.focusSuggestion,
· key: ctrl+i,
· when: suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
===
* McshEngl.Vscdcmnd.focusSuggestion,

Vsccmdi.focusSuggestion,
· key: ctrl+space,
· when: suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
===
* McshEngl.Vscdcmnd.focusSuggestion,

Vsccmdi.getContextKeyInfo,
===
* McshEngl.Vscdcmnd.getContextKeyInfo,

Vsccmdi.git-base.api.getRemoteSources,
===
* McshEngl.Vscdcmnd.git_base.api.getRemoteSources,

Vsccmdi.git._syncAll,
===
* McshEngl.Vscdcmnd.git._syncAll,

Vsccmdi.git.acceptMerge,
===
* McshEngl.Vscdcmnd.git.acceptMerge,

Vsccmdi.git.addRemote,
===
* McshEngl.Vscdcmnd.git.addRemote,

Vsccmdi.git.api.getRemoteSources,
===
* McshEngl.Vscdcmnd.git.api.getRemoteSources,

Vsccmdi.git.api.getRepositories,
===
* McshEngl.Vscdcmnd.git.api.getRepositories,

Vsccmdi.git.api.getRepositoryState,
===
* McshEngl.Vscdcmnd.git.api.getRepositoryState,

Vsccmdi.git.blame.toggleEditorDecoration,
===
* McshEngl.Vscdcmnd.git.blame.toggleEditorDecoration,

Vsccmdi.git.blame.toggleStatusBarItem,
===
* McshEngl.Vscdcmnd.git.blame.toggleStatusBarItem,

Vsccmdi.git.branch,
===
* McshEngl.Vscdcmnd.git.branch,

Vsccmdi.git.branchFrom,
===
* McshEngl.Vscdcmnd.git.branchFrom,

Vsccmdi.git.checkout,
===
* McshEngl.Vscdcmnd.git.checkout,

Vsccmdi.git.checkoutDetached,
===
* McshEngl.Vscdcmnd.git.checkoutDetached,

Vsccmdi.git.cherryPick,
===
* McshEngl.Vscdcmnd.git.cherryPick,

Vsccmdi.git.cherryPickAbort,
===
* McshEngl.Vscdcmnd.git.cherryPickAbort,

Vsccmdi.git.clean,
===
* McshEngl.Vscdcmnd.git.clean,

Vsccmdi.git.cleanAll,
===
* McshEngl.Vscdcmnd.git.cleanAll,

Vsccmdi.git.cleanAllTracked,
===
* McshEngl.Vscdcmnd.git.cleanAllTracked,

Vsccmdi.git.cleanAllUntracked,
===
* McshEngl.Vscdcmnd.git.cleanAllUntracked,

Vsccmdi.git.clone,
===
* McshEngl.Vscdcmnd.git.clone,

Vsccmdi.git.cloneRecursive,
===
* McshEngl.Vscdcmnd.git.cloneRecursive,

Vsccmdi.git.close,
===
* McshEngl.Vscdcmnd.git.close,

Vsccmdi.git.closeAllDiffEditors,
===
* McshEngl.Vscdcmnd.git.closeAllDiffEditors,

Vsccmdi.git.closeAllUnmodifiedEditors,
===
* McshEngl.Vscdcmnd.git.closeAllUnmodifiedEditors,

Vsccmdi.git.closeOtherRepositories,
===
* McshEngl.Vscdcmnd.git.closeOtherRepositories,

Vsccmdi.git.commit,
===
* McshEngl.Vscdcmnd.git.commit,

Vsccmdi.git.commitAll,
===
* McshEngl.Vscdcmnd.git.commitAll,

Vsccmdi.git.commitAllAmend,
===
* McshEngl.Vscdcmnd.git.commitAllAmend,

Vsccmdi.git.commitAllAmendNoVerify,
===
* McshEngl.Vscdcmnd.git.commitAllAmendNoVerify,

Vsccmdi.git.commitAllNoVerify,
===
* McshEngl.Vscdcmnd.git.commitAllNoVerify,

Vsccmdi.git.commitAllSigned,
===
* McshEngl.Vscdcmnd.git.commitAllSigned,

Vsccmdi.git.commitAllSignedNoVerify,
===
* McshEngl.Vscdcmnd.git.commitAllSignedNoVerify,

Vsccmdi.git.commitAmend,
===
* McshEngl.Vscdcmnd.git.commitAmend,

Vsccmdi.git.commitAmendNoVerify,
===
* McshEngl.Vscdcmnd.git.commitAmendNoVerify,

Vsccmdi.git.commitEmpty,
===
* McshEngl.Vscdcmnd.git.commitEmpty,

Vsccmdi.git.commitEmptyNoVerify,
===
* McshEngl.Vscdcmnd.git.commitEmptyNoVerify,

Vsccmdi.git.commitMessageAccept,
===
* McshEngl.Vscdcmnd.git.commitMessageAccept,

Vsccmdi.git.commitMessageDiscard,
===
* McshEngl.Vscdcmnd.git.commitMessageDiscard,

Vsccmdi.git.commitNoVerify,
===
* McshEngl.Vscdcmnd.git.commitNoVerify,

Vsccmdi.git.commitSigned,
===
* McshEngl.Vscdcmnd.git.commitSigned,

Vsccmdi.git.commitSignedNoVerify,
===
* McshEngl.Vscdcmnd.git.commitSignedNoVerify,

Vsccmdi.git.commitStaged,
===
* McshEngl.Vscdcmnd.git.commitStaged,

Vsccmdi.git.commitStagedAmend,
===
* McshEngl.Vscdcmnd.git.commitStagedAmend,

Vsccmdi.git.commitStagedAmendNoVerify,
===
* McshEngl.Vscdcmnd.git.commitStagedAmendNoVerify,

Vsccmdi.git.commitStagedNoVerify,
===
* McshEngl.Vscdcmnd.git.commitStagedNoVerify,

Vsccmdi.git.commitStagedSigned,
===
* McshEngl.Vscdcmnd.git.commitStagedSigned,

Vsccmdi.git.commitStagedSignedNoVerify,
===
* McshEngl.Vscdcmnd.git.commitStagedSignedNoVerify,

Vsccmdi.git.compareWithWorkspace,
===
* McshEngl.Vscdcmnd.git.compareWithWorkspace,

Vsccmdi.git.continueInLocalClone,
===
* McshEngl.Vscdcmnd.git.continueInLocalClone,

Vsccmdi.git.copyCommitId,
===
* McshEngl.Vscdcmnd.git.copyCommitId,

Vsccmdi.git.copyCommitMessage,
===
* McshEngl.Vscdcmnd.git.copyCommitMessage,

Vsccmdi.git.copyContentToClipboard,
===
* McshEngl.Vscdcmnd.git.copyContentToClipboard,

Vsccmdi.git.createTag,
===
* McshEngl.Vscdcmnd.git.createTag,

Vsccmdi.git.createWorktree,
===
* McshEngl.Vscdcmnd.git.createWorktree,

Vsccmdi.git.delete,
===
* McshEngl.Vscdcmnd.git.delete,

Vsccmdi.git.deleteBranch,
===
* McshEngl.Vscdcmnd.git.deleteBranch,

Vsccmdi.git.deleteRemoteBranch,
===
* McshEngl.Vscdcmnd.git.deleteRemoteBranch,

Vsccmdi.git.deleteRemoteTag,
===
* McshEngl.Vscdcmnd.git.deleteRemoteTag,

Vsccmdi.git.deleteTag,
===
* McshEngl.Vscdcmnd.git.deleteTag,

Vsccmdi.git.deleteWorktree,
===
* McshEngl.Vscdcmnd.git.deleteWorktree,

Vsccmdi.git.deleteWorktree2,
===
* McshEngl.Vscdcmnd.git.deleteWorktree2,

Vsccmdi.git.diff.stageHunk,
===
* McshEngl.Vscdcmnd.git.diff.stageHunk,

Vsccmdi.git.diff.stageSelection,
===
* McshEngl.Vscdcmnd.git.diff.stageSelection,

Vsccmdi.git.fetch,
===
* McshEngl.Vscdcmnd.git.fetch,

Vsccmdi.git.fetchAll,
===
* McshEngl.Vscdcmnd.git.fetchAll,

Vsccmdi.git.fetchPrune,
===
* McshEngl.Vscdcmnd.git.fetchPrune,

Vsccmdi.git.fetchRef,
===
* McshEngl.Vscdcmnd.git.fetchRef,

Vsccmdi.git.graph.checkout,
===
* McshEngl.Vscdcmnd.git.graph.checkout,

Vsccmdi.git.graph.checkoutDetached,
===
* McshEngl.Vscdcmnd.git.graph.checkoutDetached,

Vsccmdi.git.graph.cherryPick,
===
* McshEngl.Vscdcmnd.git.graph.cherryPick,

Vsccmdi.git.graph.compareRef,
===
* McshEngl.Vscdcmnd.git.graph.compareRef,

Vsccmdi.git.graph.compareWithMergeBase,
===
* McshEngl.Vscdcmnd.git.graph.compareWithMergeBase,

Vsccmdi.git.graph.compareWithRemote,
===
* McshEngl.Vscdcmnd.git.graph.compareWithRemote,

Vsccmdi.git.graph.deleteBranch,
===
* McshEngl.Vscdcmnd.git.graph.deleteBranch,

Vsccmdi.git.graph.deleteTag,
===
* McshEngl.Vscdcmnd.git.graph.deleteTag,

Vsccmdi.git.ignore,
===
* McshEngl.Vscdcmnd.git.ignore,

Vsccmdi.git.init,
===
* McshEngl.Vscdcmnd.git.init,

Vsccmdi.git.manageUnsafeRepositories,
===
* McshEngl.Vscdcmnd.git.manageUnsafeRepositories,

Vsccmdi.git.merge,
===
* McshEngl.Vscdcmnd.git.merge,

Vsccmdi.git.mergeAbort,
===
* McshEngl.Vscdcmnd.git.mergeAbort,

Vsccmdi.git.migrateWorktreeChanges,
===
* McshEngl.Vscdcmnd.git.migrateWorktreeChanges,

Vsccmdi.git.openAllChanges,
===
* McshEngl.Vscdcmnd.git.openAllChanges,

Vsccmdi.git.openChange,
===
* McshEngl.Vscdcmnd.git.openChange,

Vsccmdi.git.openFile,
===
* McshEngl.Vscdcmnd.git.openFile,

Vsccmdi.git.openFile2,
===
* McshEngl.Vscdcmnd.git.openFile2,

Vsccmdi.git.openHEADFile,
===
* McshEngl.Vscdcmnd.git.openHEADFile,

Vsccmdi.git.openMergeEditor,
===
* McshEngl.Vscdcmnd.git.openMergeEditor,

Vsccmdi.git.openRepositoriesInParentFolders,
===
* McshEngl.Vscdcmnd.git.openRepositoriesInParentFolders,

Vsccmdi.git.openRepository,
===
* McshEngl.Vscdcmnd.git.openRepository,

Vsccmdi.git.openResource,
===
* McshEngl.Vscdcmnd.git.openResource,

Vsccmdi.git.openWorktree,
===
* McshEngl.Vscdcmnd.git.openWorktree,

Vsccmdi.git.openWorktreeInNewWindow,
===
* McshEngl.Vscdcmnd.git.openWorktreeInNewWindow,

Vsccmdi.git.openWorktreeMergeEditor,
===
* McshEngl.Vscdcmnd.git.openWorktreeMergeEditor,

Vsccmdi.git.publish,
===
* McshEngl.Vscdcmnd.git.publish,

Vsccmdi.git.pull,
===
* McshEngl.Vscdcmnd.git.pull,

Vsccmdi.git.pullFrom,
===
* McshEngl.Vscdcmnd.git.pullFrom,

Vsccmdi.git.pullRebase,
===
* McshEngl.Vscdcmnd.git.pullRebase,

Vsccmdi.git.pullRef,
===
* McshEngl.Vscdcmnd.git.pullRef,

Vsccmdi.git.push,
===
* McshEngl.Vscdcmnd.git.push,

Vsccmdi.git.pushForce,
===
* McshEngl.Vscdcmnd.git.pushForce,

Vsccmdi.git.pushRef,
===
* McshEngl.Vscdcmnd.git.pushRef,

Vsccmdi.git.pushTags,
===
* McshEngl.Vscdcmnd.git.pushTags,

Vsccmdi.git.pushTo,
===
* McshEngl.Vscdcmnd.git.pushTo,

Vsccmdi.git.pushToForce,
===
* McshEngl.Vscdcmnd.git.pushToForce,

Vsccmdi.git.pushWithTags,
===
* McshEngl.Vscdcmnd.git.pushWithTags,

Vsccmdi.git.pushWithTagsForce,
===
* McshEngl.Vscdcmnd.git.pushWithTagsForce,

Vsccmdi.git.rebase,
===
* McshEngl.Vscdcmnd.git.rebase,

Vsccmdi.git.rebaseAbort,
===
* McshEngl.Vscdcmnd.git.rebaseAbort,

Vsccmdi.git.refresh,
===
* McshEngl.Vscdcmnd.git.refresh,

Vsccmdi.git.removeRemote,
===
* McshEngl.Vscdcmnd.git.removeRemote,

Vsccmdi.git.rename,
===
* McshEngl.Vscdcmnd.git.rename,

Vsccmdi.git.renameBranch,
===
* McshEngl.Vscdcmnd.git.renameBranch,

Vsccmdi.git.reopenClosedRepositories,
===
* McshEngl.Vscdcmnd.git.reopenClosedRepositories,

Vsccmdi.git.repositories.checkout,
===
* McshEngl.Vscdcmnd.git.repositories.checkout,

Vsccmdi.git.repositories.checkoutDetached,
===
* McshEngl.Vscdcmnd.git.repositories.checkoutDetached,

Vsccmdi.git.repositories.compareRef,
===
* McshEngl.Vscdcmnd.git.repositories.compareRef,

Vsccmdi.git.repositories.copyBranchName,
===
* McshEngl.Vscdcmnd.git.repositories.copyBranchName,

Vsccmdi.git.repositories.copyCommitHash,
===
* McshEngl.Vscdcmnd.git.repositories.copyCommitHash,

Vsccmdi.git.repositories.copyStashName,
===
* McshEngl.Vscdcmnd.git.repositories.copyStashName,

Vsccmdi.git.repositories.copyTagName,
===
* McshEngl.Vscdcmnd.git.repositories.copyTagName,

Vsccmdi.git.repositories.createBranch,
===
* McshEngl.Vscdcmnd.git.repositories.createBranch,

Vsccmdi.git.repositories.createFrom,
===
* McshEngl.Vscdcmnd.git.repositories.createFrom,

Vsccmdi.git.repositories.createTag,
===
* McshEngl.Vscdcmnd.git.repositories.createTag,

Vsccmdi.git.repositories.createWorktree,
===
* McshEngl.Vscdcmnd.git.repositories.createWorktree,

Vsccmdi.git.repositories.deleteBranch,
===
* McshEngl.Vscdcmnd.git.repositories.deleteBranch,

Vsccmdi.git.repositories.deleteTag,
===
* McshEngl.Vscdcmnd.git.repositories.deleteTag,

Vsccmdi.git.repositories.deleteWorktree,
===
* McshEngl.Vscdcmnd.git.repositories.deleteWorktree,

Vsccmdi.git.repositories.merge,
===
* McshEngl.Vscdcmnd.git.repositories.merge,

Vsccmdi.git.repositories.openWorktree,
===
* McshEngl.Vscdcmnd.git.repositories.openWorktree,

Vsccmdi.git.repositories.openWorktreeInNewWindow,
===
* McshEngl.Vscdcmnd.git.repositories.openWorktreeInNewWindow,

Vsccmdi.git.repositories.rebase,
===
* McshEngl.Vscdcmnd.git.repositories.rebase,

Vsccmdi.git.repositories.stashApply,
===
* McshEngl.Vscdcmnd.git.repositories.stashApply,

Vsccmdi.git.repositories.stashCopyBranchName,
===
* McshEngl.Vscdcmnd.git.repositories.stashCopyBranchName,

Vsccmdi.git.repositories.stashDrop,
===
* McshEngl.Vscdcmnd.git.repositories.stashDrop,

Vsccmdi.git.repositories.stashPop,
===
* McshEngl.Vscdcmnd.git.repositories.stashPop,

Vsccmdi.git.repositories.stashView,
===
* McshEngl.Vscdcmnd.git.repositories.stashView,

Vsccmdi.git.repositories.worktreeCopyBranchName,
===
* McshEngl.Vscdcmnd.git.repositories.worktreeCopyBranchName,

Vsccmdi.git.repositories.worktreeCopyCommitHash,
===
* McshEngl.Vscdcmnd.git.repositories.worktreeCopyCommitHash,

Vsccmdi.git.repositories.worktreeCopyPath,
===
* McshEngl.Vscdcmnd.git.repositories.worktreeCopyPath,

Vsccmdi.git.restoreCommitTemplate,
===
* McshEngl.Vscdcmnd.git.restoreCommitTemplate,

Vsccmdi.git.revealFileInOS.linux,
===
* McshEngl.Vscdcmnd.git.revealFileInOS.linux,

Vsccmdi.git.revealFileInOS.mac,
===
* McshEngl.Vscdcmnd.git.revealFileInOS.mac,

Vsccmdi.git.revealFileInOS.windows,
===
* McshEngl.Vscdcmnd.git.revealFileInOS.windows,

Vsccmdi.git.revealInExplorer,
===
* McshEngl.Vscdcmnd.git.revealInExplorer,

Vsccmdi.git.revertChange,
===
* McshEngl.Vscdcmnd.git.revertChange,

Vsccmdi.git.revertSelectedRanges,
· key: ctrl+k ctrl+r,
· when: editorTextFocus && !operationInProgress && resourceScheme == 'file',
===
* McshEngl.Vscdcmnd.git.revertSelectedRanges,

Vsccmdi.git.runGitMerge,
===
* McshEngl.Vscdcmnd.git.runGitMerge,

Vsccmdi.git.runGitMergeDiff3,
===
* McshEngl.Vscdcmnd.git.runGitMergeDiff3,

Vsccmdi.git.showOutput,
===
* McshEngl.Vscdcmnd.git.showOutput,

Vsccmdi.git.stage,
===
* McshEngl.Vscdcmnd.git.stage,

Vsccmdi.git.stageAll,
===
* McshEngl.Vscdcmnd.git.stageAll,

Vsccmdi.git.stageAllMerge,
===
* McshEngl.Vscdcmnd.git.stageAllMerge,

Vsccmdi.git.stageAllTracked,
===
* McshEngl.Vscdcmnd.git.stageAllTracked,

Vsccmdi.git.stageAllUntracked,
===
* McshEngl.Vscdcmnd.git.stageAllUntracked,

Vsccmdi.git.stageChange,
===
* McshEngl.Vscdcmnd.git.stageChange,

Vsccmdi.git.stageFile,
===
* McshEngl.Vscdcmnd.git.stageFile,

Vsccmdi.git.stageSelectedRanges,
· key: ctrl+k ctrl+alt+s,
· when: editorTextFocus && !operationInProgress && resourceScheme == 'file',
===
* McshEngl.Vscdcmnd.git.stageSelectedRanges,

Vsccmdi.git.stash,
===
* McshEngl.Vscdcmnd.git.stash,

Vsccmdi.git.stashApply,
===
* McshEngl.Vscdcmnd.git.stashApply,

Vsccmdi.git.stashApplyEditor,
===
* McshEngl.Vscdcmnd.git.stashApplyEditor,

Vsccmdi.git.stashApplyLatest,
===
* McshEngl.Vscdcmnd.git.stashApplyLatest,

Vsccmdi.git.stashDrop,
===
* McshEngl.Vscdcmnd.git.stashDrop,

Vsccmdi.git.stashDropAll,
===
* McshEngl.Vscdcmnd.git.stashDropAll,

Vsccmdi.git.stashDropEditor,
===
* McshEngl.Vscdcmnd.git.stashDropEditor,

Vsccmdi.git.stashIncludeUntracked,
===
* McshEngl.Vscdcmnd.git.stashIncludeUntracked,

Vsccmdi.git.stashPop,
===
* McshEngl.Vscdcmnd.git.stashPop,

Vsccmdi.git.stashPopEditor,
===
* McshEngl.Vscdcmnd.git.stashPopEditor,

Vsccmdi.git.stashPopLatest,
===
* McshEngl.Vscdcmnd.git.stashPopLatest,

Vsccmdi.git.stashStaged,
===
* McshEngl.Vscdcmnd.git.stashStaged,

Vsccmdi.git.stashView,
===
* McshEngl.Vscdcmnd.git.stashView,

Vsccmdi.git.sync,
===
* McshEngl.Vscdcmnd.git.sync,

Vsccmdi.git.syncRebase,
===
* McshEngl.Vscdcmnd.git.syncRebase,

Vsccmdi.git.timeline.compareWithSelected,
===
* McshEngl.Vscdcmnd.git.timeline.compareWithSelected,

Vsccmdi.git.timeline.copyCommitId,
===
* McshEngl.Vscdcmnd.git.timeline.copyCommitId,

Vsccmdi.git.timeline.copyCommitMessage,
===
* McshEngl.Vscdcmnd.git.timeline.copyCommitMessage,

Vsccmdi.git.timeline.openDiff,
===
* McshEngl.Vscdcmnd.git.timeline.openDiff,

Vsccmdi.git.timeline.selectForCompare,
===
* McshEngl.Vscdcmnd.git.timeline.selectForCompare,

Vsccmdi.git.timeline.viewCommit,
===
* McshEngl.Vscdcmnd.git.timeline.viewCommit,

Vsccmdi.git.undoCommit,
===
* McshEngl.Vscdcmnd.git.undoCommit,

Vsccmdi.git.unstage,
===
* McshEngl.Vscdcmnd.git.unstage,

Vsccmdi.git.unstageAll,
===
* McshEngl.Vscdcmnd.git.unstageAll,

Vsccmdi.git.unstageChange,
===
* McshEngl.Vscdcmnd.git.unstageChange,

Vsccmdi.git.unstageFile,
===
* McshEngl.Vscdcmnd.git.unstageFile,

Vsccmdi.git.unstageSelectedRanges,
· key: ctrl+k ctrl+n,
· when: editorTextFocus && isInDiffEditor && isInDiffRightEditor && !operationInProgress && resourceScheme == 'git',
===
* McshEngl.Vscdcmnd.git.unstageSelectedRanges,

Vsccmdi.git.viewChanges,
===
* McshEngl.Vscdcmnd.git.viewChanges,

Vsccmdi.git.viewCommit,
===
* McshEngl.Vscdcmnd.git.viewCommit,

Vsccmdi.git.viewStagedChanges,
===
* McshEngl.Vscdcmnd.git.viewStagedChanges,

Vsccmdi.git.viewUntrackedChanges,
===
* McshEngl.Vscdcmnd.git.viewUntrackedChanges,

Vsccmdi.github.copilot.acceptCursorPanelSolution,
===
* McshEngl.Vscdcmnd.github.copilot.acceptCursorPanelSolution,

Vsccmdi.github.copilot.buildRemoteWorkspaceIndex,
===
* McshEngl.Vscdcmnd.github.copilot.buildRemoteWorkspaceIndex,

Vsccmdi.github.copilot.chat.applyCopilotCLIAgentSessionChanges,
===
* McshEngl.Vscdcmnd.github.copilot.chat.applyCopilotCLIAgentSessionChanges,

Vsccmdi.github.copilot.chat.applyCopilotCLIAgentSessionChanges.apply,
===
* McshEngl.Vscdcmnd.github.copilot.chat.applyCopilotCLIAgentSessionChanges.apply,

Vsccmdi.github.copilot.chat.attachFile,
===
* McshEngl.Vscdcmnd.github.copilot.chat.attachFile,

Vsccmdi.github.copilot.chat.attachSelection,
===
* McshEngl.Vscdcmnd.github.copilot.chat.attachSelection,

Vsccmdi.github.copilot.chat.checkoutPullRequestReroute,
===
* McshEngl.Vscdcmnd.github.copilot.chat.checkoutPullRequestReroute,

Vsccmdi.github.copilot.chat.clearTemporalContext,
===
* McshEngl.Vscdcmnd.github.copilot.chat.clearTemporalContext,

Vsccmdi.github.copilot.chat.cloudSessions.clearCaches,
===
* McshEngl.Vscdcmnd.github.copilot.chat.cloudSessions.clearCaches,

Vsccmdi.github.copilot.chat.cloudSessions.openRepository,
===
* McshEngl.Vscdcmnd.github.copilot.chat.cloudSessions.openRepository,

Vsccmdi.github.copilot.chat.codeReview.run,
===
* McshEngl.Vscdcmnd.github.copilot.chat.codeReview.run,

Vsccmdi.github.copilot.chat.compact,
===
* McshEngl.Vscdcmnd.github.copilot.chat.compact,

Vsccmdi.github.copilot.chat.completions.disable,
===
* McshEngl.Vscdcmnd.github.copilot.chat.completions.disable,

Vsccmdi.github.copilot.chat.completions.enable,
===
* McshEngl.Vscdcmnd.github.copilot.chat.completions.enable,

Vsccmdi.github.copilot.chat.completions.toggle,
===
* McshEngl.Vscdcmnd.github.copilot.chat.completions.toggle,

Vsccmdi.github.copilot.chat.copilotCLI.acceptDiff,
===
* McshEngl.Vscdcmnd.github.copilot.chat.copilotCLI.acceptDiff,

Vsccmdi.github.copilot.chat.copilotCLI.addFileReference,
· key: ctrl+shift+.,
· when: editorTextFocus && github.copilot.chat.copilotCLI.hasSession,
===
* McshEngl.Vscdcmnd.github.copilot.chat.copilotCLI.addFileReference,

Vsccmdi.github.copilot.chat.copilotCLI.addSelection,
===
* McshEngl.Vscdcmnd.github.copilot.chat.copilotCLI.addSelection,

Vsccmdi.github.copilot.chat.copilotCLI.rejectDiff,
===
* McshEngl.Vscdcmnd.github.copilot.chat.copilotCLI.rejectDiff,

Vsccmdi.github.copilot.chat.createDraftPullRequestCopilotCLIAgentSession.createDraftPR,
===
* McshEngl.Vscdcmnd.github.copilot.chat.createDraftPullRequestCopilotCLIAgentSession.createDraftPR,

Vsccmdi.github.copilot.chat.createPullRequestCopilotCLIAgentSession.createPR,
===
* McshEngl.Vscdcmnd.github.copilot.chat.createPullRequestCopilotCLIAgentSession.createPR,

Vsccmdi.github.copilot.chat.createPullRequestCopilotCLIAgentSession.updatePR,
===
* McshEngl.Vscdcmnd.github.copilot.chat.createPullRequestCopilotCLIAgentSession.updatePR,

Vsccmdi.github.copilot.chat.debug.exportAllPromptLogsAsJson,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.exportAllPromptLogsAsJson,

Vsccmdi.github.copilot.chat.debug.exportLogItem,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.exportLogItem,

Vsccmdi.github.copilot.chat.debug.exportPromptArchive,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.exportPromptArchive,

Vsccmdi.github.copilot.chat.debug.exportPromptLogsAsJson,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.exportPromptLogsAsJson,

Vsccmdi.github.copilot.chat.debug.hideElements,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.hideElements,

Vsccmdi.github.copilot.chat.debug.hideGhostRequests,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.hideGhostRequests,

Vsccmdi.github.copilot.chat.debug.hideNesRequests,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.hideNesRequests,

Vsccmdi.github.copilot.chat.debug.hideTools,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.hideTools,

Vsccmdi.github.copilot.chat.debug.saveCurrentMarkdown,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.saveCurrentMarkdown,

Vsccmdi.github.copilot.chat.debug.showElements,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.showElements,

Vsccmdi.github.copilot.chat.debug.showGhostRequests,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.showGhostRequests,

Vsccmdi.github.copilot.chat.debug.showNesRequests,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.showNesRequests,

Vsccmdi.github.copilot.chat.debug.showRawRequestBody,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.showRawRequestBody,

Vsccmdi.github.copilot.chat.debug.showTools,
===
* McshEngl.Vscdcmnd.github.copilot.chat.debug.showTools,

Vsccmdi.github.copilot.chat.explain,
===
* McshEngl.Vscdcmnd.github.copilot.chat.explain,

Vsccmdi.github.copilot.chat.explain.palette,
===
* McshEngl.Vscdcmnd.github.copilot.chat.explain.palette,

Vsccmdi.github.copilot.chat.fix,
===
* McshEngl.Vscdcmnd.github.copilot.chat.fix,

Vsccmdi.github.copilot.chat.generate,
===
* McshEngl.Vscdcmnd.github.copilot.chat.generate,

Vsccmdi.github.copilot.chat.generateAltText,
===
* McshEngl.Vscdcmnd.github.copilot.chat.generateAltText,

Vsccmdi.github.copilot.chat.mcp.setup.check,
===
* McshEngl.Vscdcmnd.github.copilot.chat.mcp.setup.check,

Vsccmdi.github.copilot.chat.mcp.setup.flow,
===
* McshEngl.Vscdcmnd.github.copilot.chat.mcp.setup.flow,

Vsccmdi.github.copilot.chat.mcp.setup.validatePackage,
===
* McshEngl.Vscdcmnd.github.copilot.chat.mcp.setup.validatePackage,

Vsccmdi.github.copilot.chat.mergeCopilotCLIAgentSessionChanges.merge,
===
* McshEngl.Vscdcmnd.github.copilot.chat.mergeCopilotCLIAgentSessionChanges.merge,

Vsccmdi.github.copilot.chat.mergeCopilotCLIAgentSessionChanges.mergeAndSync,
===
* McshEngl.Vscdcmnd.github.copilot.chat.mergeCopilotCLIAgentSessionChanges.mergeAndSync,

Vsccmdi.github.copilot.chat.notebook.disableFollowCellExecution,
===
* McshEngl.Vscdcmnd.github.copilot.chat.notebook.disableFollowCellExecution,

Vsccmdi.github.copilot.chat.notebook.enableFollowCellExecution,
===
* McshEngl.Vscdcmnd.github.copilot.chat.notebook.enableFollowCellExecution,

Vsccmdi.github.copilot.chat.openModelPicker,
===
* McshEngl.Vscdcmnd.github.copilot.chat.openModelPicker,

Vsccmdi.github.copilot.chat.openPullRequestCopilotCLIAgentSession.openPR,
===
* McshEngl.Vscdcmnd.github.copilot.chat.openPullRequestCopilotCLIAgentSession.openPR,

Vsccmdi.github.copilot.chat.openPullRequestReroute,
===
* McshEngl.Vscdcmnd.github.copilot.chat.openPullRequestReroute,

Vsccmdi.github.copilot.chat.openSuggestionsPanel,
===
* McshEngl.Vscdcmnd.github.copilot.chat.openSuggestionsPanel,

Vsccmdi.github.copilot.chat.openUserPreferences,
===
* McshEngl.Vscdcmnd.github.copilot.chat.openUserPreferences,

Vsccmdi.github.copilot.chat.otel.exportAgentTracesDB,
===
* McshEngl.Vscdcmnd.github.copilot.chat.otel.exportAgentTracesDB,

Vsccmdi.github.copilot.chat.otel.flush,
===
* McshEngl.Vscdcmnd.github.copilot.chat.otel.flush,

Vsccmdi.github.copilot.chat.replay,
===
* McshEngl.Vscdcmnd.github.copilot.chat.replay,

Vsccmdi.github.copilot.chat.replay.disableWorkspaceEditTracing,
===
* McshEngl.Vscdcmnd.github.copilot.chat.replay.disableWorkspaceEditTracing,

Vsccmdi.github.copilot.chat.replay.enableWorkspaceEditTracing,
===
* McshEngl.Vscdcmnd.github.copilot.chat.replay.enableWorkspaceEditTracing,

Vsccmdi.github.copilot.chat.rerunWithCopilotDebug,
· key: ctrl+alt+.,
· when: github.copilot-chat.activated && terminalFocus && terminalShellIntegrationEnabled && !terminalAltBufferActive,
===
* McshEngl.Vscdcmnd.github.copilot.chat.rerunWithCopilotDebug,

Vsccmdi.github.copilot.chat.review,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review,

Vsccmdi.github.copilot.chat.review.apply,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.apply,

Vsccmdi.github.copilot.chat.review.applyAndNext,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.applyAndNext,

Vsccmdi.github.copilot.chat.review.applyShort,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.applyShort,

Vsccmdi.github.copilot.chat.review.changes,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.changes,

Vsccmdi.github.copilot.chat.review.continueInChat,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.continueInChat,

Vsccmdi.github.copilot.chat.review.continueInInlineChat,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.continueInInlineChat,

Vsccmdi.github.copilot.chat.review.current,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.current,

Vsccmdi.github.copilot.chat.review.discard,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.discard,

Vsccmdi.github.copilot.chat.review.discardAll,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.discardAll,

Vsccmdi.github.copilot.chat.review.discardAndNext,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.discardAndNext,

Vsccmdi.github.copilot.chat.review.discardShort,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.discardShort,

Vsccmdi.github.copilot.chat.review.markHelpful,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.markHelpful,

Vsccmdi.github.copilot.chat.review.markUnhelpful,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.markUnhelpful,

Vsccmdi.github.copilot.chat.review.next,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.next,

Vsccmdi.github.copilot.chat.review.previous,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.previous,

Vsccmdi.github.copilot.chat.review.stagedChanges,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.stagedChanges,

Vsccmdi.github.copilot.chat.review.stagedFileChange,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.stagedFileChange,

Vsccmdi.github.copilot.chat.review.unstagedChanges,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.unstagedChanges,

Vsccmdi.github.copilot.chat.review.unstagedFileChange,
===
* McshEngl.Vscdcmnd.github.copilot.chat.review.unstagedFileChange,

Vsccmdi.github.copilot.chat.sendCompletionFeedback,
===
* McshEngl.Vscdcmnd.github.copilot.chat.sendCompletionFeedback,

Vsccmdi.github.copilot.chat.showAsChatSession,
===
* McshEngl.Vscdcmnd.github.copilot.chat.showAsChatSession,

Vsccmdi.github.copilot.chat.startCopilotDebugCommand,
===
* McshEngl.Vscdcmnd.github.copilot.chat.startCopilotDebugCommand,

Vsccmdi.github.copilot.chat.toggleStatusMenu,
===
* McshEngl.Vscdcmnd.github.copilot.chat.toggleStatusMenu,

Vsccmdi.github.copilot.chat.tools.memory.clearMemories,
===
* McshEngl.Vscdcmnd.github.copilot.chat.tools.memory.clearMemories,

Vsccmdi.github.copilot.chat.tools.memory.showMemories,
===
* McshEngl.Vscdcmnd.github.copilot.chat.tools.memory.showMemories,

Vsccmdi.github.copilot.chat.triggerPermissiveSignIn,
===
* McshEngl.Vscdcmnd.github.copilot.chat.triggerPermissiveSignIn,

Vsccmdi.github.copilot.chat.updateCopilotCLIAgentSessionChanges.update,
===
* McshEngl.Vscdcmnd.github.copilot.chat.updateCopilotCLIAgentSessionChanges.update,

Vsccmdi.github.copilot.claude.sessions.rename,
===
* McshEngl.Vscdcmnd.github.copilot.claude.sessions.rename,

Vsccmdi.github.copilot.cli.newSession,
===
* McshEngl.Vscdcmnd.github.copilot.cli.newSession,

Vsccmdi.github.copilot.cli.newSessionToSide,
===
* McshEngl.Vscdcmnd.github.copilot.cli.newSessionToSide,

Vsccmdi.github.copilot.cli.openInCopilotCLI,
===
* McshEngl.Vscdcmnd.github.copilot.cli.openInCopilotCLI,

Vsccmdi.github.copilot.cli.sessions.commitToRepository,
===
* McshEngl.Vscdcmnd.github.copilot.cli.sessions.commitToRepository,

Vsccmdi.github.copilot.cli.sessions.commitToWorktree,
===
* McshEngl.Vscdcmnd.github.copilot.cli.sessions.commitToWorktree,

Vsccmdi.github.copilot.cli.sessions.copyWorktreeBranchName,
===
* McshEngl.Vscdcmnd.github.copilot.cli.sessions.copyWorktreeBranchName,

Vsccmdi.github.copilot.cli.sessions.delete,
===
* McshEngl.Vscdcmnd.github.copilot.cli.sessions.delete,

Vsccmdi.github.copilot.cli.sessions.openRepository,
===
* McshEngl.Vscdcmnd.github.copilot.cli.sessions.openRepository,

Vsccmdi.github.copilot.cli.sessions.openWorktreeInNewWindow,
===
* McshEngl.Vscdcmnd.github.copilot.cli.sessions.openWorktreeInNewWindow,

Vsccmdi.github.copilot.cli.sessions.openWorktreeInTerminal,
===
* McshEngl.Vscdcmnd.github.copilot.cli.sessions.openWorktreeInTerminal,

Vsccmdi.github.copilot.cli.sessions.rename,
===
* McshEngl.Vscdcmnd.github.copilot.cli.sessions.rename,

Vsccmdi.github.copilot.cli.sessions.resumeInTerminal,
===
* McshEngl.Vscdcmnd.github.copilot.cli.sessions.resumeInTerminal,

Vsccmdi.github.copilot.cli.sessions.setTitle,
===
* McshEngl.Vscdcmnd.github.copilot.cli.sessions.setTitle,

Vsccmdi.github.copilot.cloud.resetWorkspaceConfirmations,
===
* McshEngl.Vscdcmnd.github.copilot.cloud.resetWorkspaceConfirmations,

Vsccmdi.github.copilot.cloud.sessions.installPRExtension,
===
* McshEngl.Vscdcmnd.github.copilot.cloud.sessions.installPRExtension,

Vsccmdi.github.copilot.cloud.sessions.openInBrowser,
===
* McshEngl.Vscdcmnd.github.copilot.cloud.sessions.openInBrowser,

Vsccmdi.github.copilot.cloud.sessions.proxy.closeChatSessionPullRequest,
===
* McshEngl.Vscdcmnd.github.copilot.cloud.sessions.proxy.closeChatSessionPullRequest,

Vsccmdi.github.copilot.completions.disable,
===
* McshEngl.Vscdcmnd.github.copilot.completions.disable,

Vsccmdi.github.copilot.completions.enable,
===
* McshEngl.Vscdcmnd.github.copilot.completions.enable,

Vsccmdi.github.copilot.completions.toggle,
===
* McshEngl.Vscdcmnd.github.copilot.completions.toggle,

Vsccmdi.github.copilot.createFile,
===
* McshEngl.Vscdcmnd.github.copilot.createFile,

Vsccmdi.github.copilot.createLaunchJsonFileWithContents,
===
* McshEngl.Vscdcmnd.github.copilot.createLaunchJsonFileWithContents,

Vsccmdi.github.copilot.createProject,
===
* McshEngl.Vscdcmnd.github.copilot.createProject,

Vsccmdi.github.copilot.debug.collectDiagnostics,
===
* McshEngl.Vscdcmnd.github.copilot.debug.collectDiagnostics,

Vsccmdi.github.copilot.debug.collectDiagnostics.internal,
===
* McshEngl.Vscdcmnd.github.copilot.debug.collectDiagnostics.internal,

Vsccmdi.github.copilot.debug.collectWorkspaceIndexDiagnostics,
===
* McshEngl.Vscdcmnd.github.copilot.debug.collectWorkspaceIndexDiagnostics,

Vsccmdi.github.copilot.debug.extensionState,
===
* McshEngl.Vscdcmnd.github.copilot.debug.extensionState,

Vsccmdi.github.copilot.debug.generateInlineEditTests,
===
* McshEngl.Vscdcmnd.github.copilot.debug.generateInlineEditTests,

Vsccmdi.github.copilot.debug.generateSTest,
===
* McshEngl.Vscdcmnd.github.copilot.debug.generateSTest,

Vsccmdi.github.copilot.debug.inlineEdit.clearCache,
===
* McshEngl.Vscdcmnd.github.copilot.debug.inlineEdit.clearCache,

Vsccmdi.github.copilot.debug.inlineEdit.learnMore,
===
* McshEngl.Vscdcmnd.github.copilot.debug.inlineEdit.learnMore,

Vsccmdi.github.copilot.debug.inlineEdit.pickProvider,
===
* McshEngl.Vscdcmnd.github.copilot.debug.inlineEdit.pickProvider,

Vsccmdi.github.copilot.debug.inlineEdit.reportFeedback,
===
* McshEngl.Vscdcmnd.github.copilot.debug.inlineEdit.reportFeedback,

Vsccmdi.github.copilot.debug.inlineEdit.reportNotebookNESIssue,
===
* McshEngl.Vscdcmnd.github.copilot.debug.inlineEdit.reportNotebookNESIssue,

Vsccmdi.github.copilot.debug.resetVirtualToolGroups,
===
* McshEngl.Vscdcmnd.github.copilot.debug.resetVirtualToolGroups,

Vsccmdi.github.copilot.debug.showChatLogView,
===
* McshEngl.Vscdcmnd.github.copilot.debug.showChatLogView,

Vsccmdi.github.copilot.debug.showContextInspectorView,
===
* McshEngl.Vscdcmnd.github.copilot.debug.showContextInspectorView,

Vsccmdi.github.copilot.debug.showNodeSystemCertificatesErrors,
===
* McshEngl.Vscdcmnd.github.copilot.debug.showNodeSystemCertificatesErrors,

Vsccmdi.github.copilot.debug.showOutputChannel,
===
* McshEngl.Vscdcmnd.github.copilot.debug.showOutputChannel,

Vsccmdi.github.copilot.debug.showOutputChannel.internal,
===
* McshEngl.Vscdcmnd.github.copilot.debug.showOutputChannel.internal,

Vsccmdi.github.copilot.debug.togglePowerSaveBlocker,
===
* McshEngl.Vscdcmnd.github.copilot.debug.togglePowerSaveBlocker,

Vsccmdi.github.copilot.debug.validateNesRename,
===
* McshEngl.Vscdcmnd.github.copilot.debug.validateNesRename,

Vsccmdi.github.copilot.debug.workbenchState,
===
* McshEngl.Vscdcmnd.github.copilot.debug.workbenchState,

Vsccmdi.github.copilot.deleteExternalIngestWorkspaceIndex,
===
* McshEngl.Vscdcmnd.github.copilot.deleteExternalIngestWorkspaceIndex,

Vsccmdi.github.copilot.devcontainer.generateDevContainerConfig,
===
* McshEngl.Vscdcmnd.github.copilot.devcontainer.generateDevContainerConfig,

Vsccmdi.github.copilot.executeSearch,
===
* McshEngl.Vscdcmnd.github.copilot.executeSearch,

Vsccmdi.github.copilot.generate,
===
* McshEngl.Vscdcmnd.github.copilot.generate,

Vsccmdi.github.copilot.git.generateCommitMessage,
===
* McshEngl.Vscdcmnd.github.copilot.git.generateCommitMessage,

Vsccmdi.github.copilot.git.resolveMergeConflicts,
===
* McshEngl.Vscdcmnd.github.copilot.git.resolveMergeConflicts,

Vsccmdi.github.copilot.interactiveSession.feedback,
===
* McshEngl.Vscdcmnd.github.copilot.interactiveSession.feedback,

Vsccmdi.github.copilot.mcp.viewContext7,
===
* McshEngl.Vscdcmnd.github.copilot.mcp.viewContext7,

Vsccmdi.github.copilot.nes.captureExpected.abort,
· key: escape,
· when: copilotNesCaptureMode && editorTextFocus,
===
* McshEngl.Vscdcmnd.github.copilot.nes.captureExpected.abort,

Vsccmdi.github.copilot.nes.captureExpected.confirm,
· key: ctrl+enter,
· when: copilotNesCaptureMode && editorTextFocus,
===
* McshEngl.Vscdcmnd.github.copilot.nes.captureExpected.confirm,

Vsccmdi.github.copilot.nes.captureExpected.start,
===
* McshEngl.Vscdcmnd.github.copilot.nes.captureExpected.start,

Vsccmdi.github.copilot.nes.captureExpected.submit,
===
* McshEngl.Vscdcmnd.github.copilot.nes.captureExpected.submit,

Vsccmdi.github.copilot.nes.postRename,
===
* McshEngl.Vscdcmnd.github.copilot.nes.postRename,

Vsccmdi.github.copilot.nes.prepareRename,
===
* McshEngl.Vscdcmnd.github.copilot.nes.prepareRename,

Vsccmdi.github.copilot.nextPanelSolution,
===
* McshEngl.Vscdcmnd.github.copilot.nextPanelSolution,

Vsccmdi.github.copilot.open.walkthrough,
===
* McshEngl.Vscdcmnd.github.copilot.open.walkthrough,

Vsccmdi.github.copilot.openDocs,
===
* McshEngl.Vscdcmnd.github.copilot.openDocs,

Vsccmdi.github.copilot.openFile,
===
* McshEngl.Vscdcmnd.github.copilot.openFile,

Vsccmdi.github.copilot.openLogs,
===
* McshEngl.Vscdcmnd.github.copilot.openLogs,

Vsccmdi.github.copilot.openModelPicker,
===
* McshEngl.Vscdcmnd.github.copilot.openModelPicker,

Vsccmdi.github.copilot.previousPanelSolution,
===
* McshEngl.Vscdcmnd.github.copilot.previousPanelSolution,

Vsccmdi.github.copilot.refreshToken,
===
* McshEngl.Vscdcmnd.github.copilot.refreshToken,

Vsccmdi.github.copilot.report,
===
* McshEngl.Vscdcmnd.github.copilot.report,

Vsccmdi.github.copilot.search.feedback,
===
* McshEngl.Vscdcmnd.github.copilot.search.feedback,

Vsccmdi.github.copilot.search.markHelpful,
===
* McshEngl.Vscdcmnd.github.copilot.search.markHelpful,

Vsccmdi.github.copilot.search.markUnhelpful,
===
* McshEngl.Vscdcmnd.github.copilot.search.markUnhelpful,

Vsccmdi.github.copilot.sessions.commitChanges,
===
* McshEngl.Vscdcmnd.github.copilot.sessions.commitChanges,

Vsccmdi.github.copilot.sessions.discardChanges,
===
* McshEngl.Vscdcmnd.github.copilot.sessions.discardChanges,

Vsccmdi.github.copilot.sessions.refreshChanges,
===
* McshEngl.Vscdcmnd.github.copilot.sessions.refreshChanges,

Vsccmdi.github.copilot.startDebugging,
===
* McshEngl.Vscdcmnd.github.copilot.startDebugging,

Vsccmdi.github.copilot.survey.signalUsage,
===
* McshEngl.Vscdcmnd.github.copilot.survey.signalUsage,

Vsccmdi.github.copilot.terminal.explainTerminalLastCommand,
===
* McshEngl.Vscdcmnd.github.copilot.terminal.explainTerminalLastCommand,

Vsccmdi.github.copilot.terminal.fixTerminalLastCommand,
===
* McshEngl.Vscdcmnd.github.copilot.terminal.fixTerminalLastCommand,

Vsccmdi.github.copilot.terminal.generateCommitMessage,
===
* McshEngl.Vscdcmnd.github.copilot.terminal.generateCommitMessage,

Vsccmdi.github.copilot.tests.applyMutations,
===
* McshEngl.Vscdcmnd.github.copilot.tests.applyMutations,

Vsccmdi.github.copilot.tests.fixTestFailure,
===
* McshEngl.Vscdcmnd.github.copilot.tests.fixTestFailure,

Vsccmdi.github.copilot.tests.fixTestFailure.fromInline,
===
* McshEngl.Vscdcmnd.github.copilot.tests.fixTestFailure.fromInline,

Vsccmdi.github.copilot.toggleStatusMenu,
===
* McshEngl.Vscdcmnd.github.copilot.toggleStatusMenu,

Vsccmdi.github.copyVscodeDevLink,
===
* McshEngl.Vscdcmnd.github.copyVscodeDevLink,

Vsccmdi.github.copyVscodeDevLinkFile,
===
* McshEngl.Vscdcmnd.github.copyVscodeDevLinkFile,

Vsccmdi.github.copyVscodeDevLinkWithoutRange,
===
* McshEngl.Vscdcmnd.github.copyVscodeDevLinkWithoutRange,

Vsccmdi.github.createPullRequest,
===
* McshEngl.Vscdcmnd.github.createPullRequest,

Vsccmdi.github.graph.openOnGitHub,
===
* McshEngl.Vscdcmnd.github.graph.openOnGitHub,

Vsccmdi.github.openOnGitHub,
===
* McshEngl.Vscdcmnd.github.openOnGitHub,

Vsccmdi.github.openOnVscodeDev,
===
* McshEngl.Vscdcmnd.github.openOnVscodeDev,

Vsccmdi.github.openPullRequest,
===
* McshEngl.Vscdcmnd.github.openPullRequest,

Vsccmdi.github.publish,
===
* McshEngl.Vscdcmnd.github.publish,

Vsccmdi.github.timeline.openOnGitHub,
===
* McshEngl.Vscdcmnd.github.timeline.openOnGitHub,

Vsccmdi.goToNextReference,
· key: f4,
· when: inReferenceSearchEditor || referenceSearchVisible,
===
* McshEngl.Vscdcmnd.goToNextReference,

Vsccmdi.goToNextReference,
· key: f12,
· when: inReferenceSearchEditor || referenceSearchVisible,
===
* McshEngl.Vscdcmnd.goToNextReference,

Vsccmdi.goToNextReferenceFromEmbeddedEditor,
===
* McshEngl.Vscdcmnd.goToNextReferenceFromEmbeddedEditor,

Vsccmdi.goToPreviousReference,
· key: shift+f4,
· when: inReferenceSearchEditor || referenceSearchVisible,
===
* McshEngl.Vscdcmnd.goToPreviousReference,

Vsccmdi.goToPreviousReference,
· key: shift+f12,
· when: inReferenceSearchEditor || referenceSearchVisible,
===
* McshEngl.Vscdcmnd.goToPreviousReference,

Vsccmdi.goToPreviousReferenceFromEmbeddedEditor,
===
* McshEngl.Vscdcmnd.goToPreviousReferenceFromEmbeddedEditor,

Vsccmdi.hideCodeActionWidget,
· key: escape,
· when: codeActionMenuVisible && kb-macro.active,
===
* McshEngl.Vscdcmnd.hideCodeActionWidget,

Vsccmdi.hideCodeActionWidget,
· key: escape,
· when: codeActionMenuVisible,
===
* McshEngl.Vscdcmnd.hideCodeActionWidget,

Vsccmdi.hideCodeActionWidget,
· key: shift+escape,
· when: codeActionMenuVisible && kb-macro.active,
===
* McshEngl.Vscdcmnd.hideCodeActionWidget,

Vsccmdi.hideCodeActionWidget,
· key: shift+escape,
· when: codeActionMenuVisible,
===
* McshEngl.Vscdcmnd.hideCodeActionWidget,

Vsccmdi.hideCustomTitleBar,
===
* McshEngl.Vscdcmnd.hideCustomTitleBar,

Vsccmdi.hideCustomTitleBarInFullScreen,
===
* McshEngl.Vscdcmnd.hideCustomTitleBarInFullScreen,

Vsccmdi.hideSuggestWidget,
· key: escape,
· when: suggestWidgetVisible && textInputFocus,
===
* McshEngl.Vscdcmnd.hideSuggestWidget,

Vsccmdi.hideSuggestWidget,
· key: shift+escape,
· when: suggestWidgetVisible && textInputFocus,
===
* McshEngl.Vscdcmnd.hideSuggestWidget,

Vsccmdi.history.showNext,
· key: alt+down,
· when: historyNavigationForwardsEnabled && historyNavigationWidgetFocus && !isComposing && !suggestWidgetVisible,
===
* McshEngl.Vscdcmnd.history.showNext,

Vsccmdi.history.showNext,
· key: down,
· when: historyNavigationForwardsEnabled && historyNavigationWidgetFocus && !isComposing && !suggestWidgetVisible,
===
* McshEngl.Vscdcmnd.history.showNext,

Vsccmdi.history.showPrevious,
· key: alt+up,
· when: historyNavigationBackwardsEnabled && historyNavigationWidgetFocus && !isComposing && !suggestWidgetVisible,
===
* McshEngl.Vscdcmnd.history.showPrevious,

Vsccmdi.history.showPrevious,
· key: up,
· when: historyNavigationBackwardsEnabled && historyNavigationWidgetFocus && !isComposing && !suggestWidgetVisible,
===
* McshEngl.Vscdcmnd.history.showPrevious,

Vsccmdi.iconSelectBox.focusDown,
· key: down,
· when: iconSelectBoxFocus,
===
* McshEngl.Vscdcmnd.iconSelectBox.focusDown,

Vsccmdi.iconSelectBox.focusNext,
· key: right,
· when: iconSelectBoxFocus && iconSelectBoxInputEmpty || iconSelectBoxFocus && !iconSelectBoxInputFocus,
===
* McshEngl.Vscdcmnd.iconSelectBox.focusNext,

Vsccmdi.iconSelectBox.focusPrevious,
· key: left,
· when: iconSelectBoxFocus && iconSelectBoxInputEmpty || iconSelectBoxFocus && !iconSelectBoxInputFocus,
===
* McshEngl.Vscdcmnd.iconSelectBox.focusPrevious,

Vsccmdi.iconSelectBox.focusUp,
· key: up,
· when: iconSelectBoxFocus,
===
* McshEngl.Vscdcmnd.iconSelectBox.focusUp,

Vsccmdi.iconSelectBox.selectFocused,
· key: enter,
· when: iconSelectBoxFocus,
===
* McshEngl.Vscdcmnd.iconSelectBox.selectFocused,

Vsccmdi.imagePreview.copyImage,
===
* McshEngl.Vscdcmnd.imagePreview.copyImage,

Vsccmdi.imagePreview.reopenAsPreview,
===
* McshEngl.Vscdcmnd.imagePreview.reopenAsPreview,

Vsccmdi.imagePreview.reopenAsText,
===
* McshEngl.Vscdcmnd.imagePreview.reopenAsText,

Vsccmdi.imagePreview.zoomIn,
===
* McshEngl.Vscdcmnd.imagePreview.zoomIn,

Vsccmdi.imagePreview.zoomOut,
===
* McshEngl.Vscdcmnd.imagePreview.zoomOut,

Vsccmdi.increaseSearchEditorContextLines,
· key: alt+=,
· when: inSearchEditor,
===
* McshEngl.Vscdcmnd.increaseSearchEditorContextLines,

Vsccmdi.inlayHints.startReadingLineWithHint,
===
* McshEngl.Vscdcmnd.inlayHints.startReadingLineWithHint,

Vsccmdi.inlayHints.stopReadingLineWithHint,
· key: escape,
· when: isReadingLineWithInlayHints,
===
* McshEngl.Vscdcmnd.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',
===
* McshEngl.Vscdcmnd.inlineChat.askInChat,

Vsccmdi.inlineChat.dismissEditorAffordance,
· key: escape,
· when: editorTextFocus && inlineChatAffordanceVisible && config.inlineChat.affordance == 'editor',
===
* McshEngl.Vscdcmnd.inlineChat.dismissEditorAffordance,

Vsccmdi.inlineChat.fixDiagnostics,
===
* McshEngl.Vscdcmnd.inlineChat.fixDiagnostics,

Vsccmdi.inlineChat.focus,
· key: ctrl+down,
· when: editorTextFocus && inlineChatVisible && !accessibilityModeEnabled && !inlineChatFocused && !isEmbeddedDiffEditor && inlineChatOuterCursorPosition == 'above',
===
* McshEngl.Vscdcmnd.inlineChat.focus,

Vsccmdi.inlineChat.focus,
· key: ctrl+up,
· when: editorTextFocus && inlineChatVisible && !accessibilityModeEnabled && !inlineChatFocused && !isEmbeddedDiffEditor && inlineChatOuterCursorPosition == 'below',
===
* McshEngl.Vscdcmnd.inlineChat.focus,

Vsccmdi.inlineChat.hideInput,
· key: escape,
· when: inlineChatHasEditsAgent && inlineChatInputWidgetFocused || inlineChatHasNotebookAgent && inlineChatInputWidgetFocused && activeEditor == 'workbench.editor.notebook',
===
* McshEngl.Vscdcmnd.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',
===
* McshEngl.Vscdcmnd.inlineChat.queueInChat,

Vsccmdi.inlineChat.resetMoveToPanelChatChoice,
===
* McshEngl.Vscdcmnd.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',
===
* McshEngl.Vscdcmnd.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',
===
* McshEngl.Vscdcmnd.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',
===
* McshEngl.Vscdcmnd.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',
===
* McshEngl.Vscdcmnd.inlineChat2.close,

Vsccmdi.inlineChat2.continueInChat,
===
* McshEngl.Vscdcmnd.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',
===
* McshEngl.Vscdcmnd.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',
===
* McshEngl.Vscdcmnd.inlineChat2.keep,

Vsccmdi.inlineChat2.rephrase,
===
* McshEngl.Vscdcmnd.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',
===
* McshEngl.Vscdcmnd.inlineChat2.undo,

Vsccmdi.insertBestCompletion,
· key: tab,
· when: atEndOfWord && textInputFocus && !hasOtherSuggestions && !inSnippetMode && !suggestWidgetVisible && config.editor.tabCompletion == 'on',
===
* McshEngl.Vscdcmnd.insertBestCompletion,

Vsccmdi.insertNextSuggestion,
· key: tab,
· when: hasOtherSuggestions && textInputFocus && !inSnippetMode && !suggestWidgetVisible && config.editor.tabCompletion == 'on',
===
* McshEngl.Vscdcmnd.insertNextSuggestion,

Vsccmdi.insertPrevSuggestion,
· key: shift+tab,
· when: hasOtherSuggestions && textInputFocus && !inSnippetMode && !suggestWidgetVisible && config.editor.tabCompletion == 'on',
===
* McshEngl.Vscdcmnd.insertPrevSuggestion,

Vsccmdi.insertSnippet,
· key: tab,
· when: editorTextFocus && hasSnippetCompletions && !editorTabMovesFocus && !inSnippetMode,
===
* McshEngl.Vscdcmnd.insertSnippet,

Vsccmdi.interactive.acceptChanges,
===
* McshEngl.Vscdcmnd.interactive.acceptChanges,

Vsccmdi.interactive.execute,
· key: ctrl+enter,
· when: isCompositeNotebook && activeEditor == 'workbench.editor.interactive',
===
* McshEngl.Vscdcmnd.interactive.execute,

Vsccmdi.interactive.execute,
· key: enter,
· when: isCompositeNotebook && !config.interactiveWindow.executeWithShiftEnter && activeEditor == 'workbench.editor.interactive',
===
* McshEngl.Vscdcmnd.interactive.execute,

Vsccmdi.interactive.execute,
· key: shift+enter,
· when: config.interactiveWindow.executeWithShiftEnter && isCompositeNotebook && activeEditor == 'workbench.editor.interactive',
===
* McshEngl.Vscdcmnd.interactive.execute,

Vsccmdi.interactive.history.focus,
· key: ctrl+up,
· when: isCompositeNotebook && !notebookEditorFocused && interactiveInputCursorAtBoundary != 'bottom' && interactiveInputCursorAtBoundary != 'none',
===
* McshEngl.Vscdcmnd.interactive.history.focus,

Vsccmdi.interactive.history.focus,
· key: ctrl+up,
· when: isCompositeNotebook && isLinux && !notebookEditorFocused || isCompositeNotebook && isWindows && !notebookEditorFocused,
===
* McshEngl.Vscdcmnd.interactive.history.focus,

Vsccmdi.interactive.history.next,
· key: down,
· when: isCompositeNotebook && !notebookEditorFocused && !suggestWidgetVisible && interactiveInputCursorAtBoundary != 'none' && interactiveInputCursorAtBoundary != 'top',
===
* McshEngl.Vscdcmnd.interactive.history.next,

Vsccmdi.interactive.history.previous,
· key: up,
· when: isCompositeNotebook && !notebookEditorFocused && !suggestWidgetVisible && interactiveInputCursorAtBoundary != 'bottom' && interactiveInputCursorAtBoundary != 'none',
===
* McshEngl.Vscdcmnd.interactive.history.previous,

Vsccmdi.interactive.input.clear,
===
* McshEngl.Vscdcmnd.interactive.input.clear,

Vsccmdi.interactive.input.focus,
===
* McshEngl.Vscdcmnd.interactive.input.focus,

Vsccmdi.interactive.scrollToBottom,
· key: ctrl+end,
· when: activeEditor == 'workbench.editor.interactive',
===
* McshEngl.Vscdcmnd.interactive.scrollToBottom,

Vsccmdi.interactive.scrollToTop,
· key: ctrl+home,
· when: activeEditor == 'workbench.editor.interactive',
===
* McshEngl.Vscdcmnd.interactive.scrollToTop,

Vsccmdi.interactiveEditor.start,
===
* McshEngl.Vscdcmnd.interactiveEditor.start,

Vsccmdi.ipynb.cleanInvalidImageAttachment,
===
* McshEngl.Vscdcmnd.ipynb.cleanInvalidImageAttachment,

Vsccmdi.ipynb.newUntitledIpynb,
===
* McshEngl.Vscdcmnd.ipynb.newUntitledIpynb,

Vsccmdi.ipynb.openIpynbInNotebookEditor,
===
* McshEngl.Vscdcmnd.ipynb.openIpynbInNotebookEditor,

Vsccmdi.javascript.goToProjectConfig,
===
* McshEngl.Vscdcmnd.javascript.goToProjectConfig,

Vsccmdi.javascript.reloadProjects,
===
* McshEngl.Vscdcmnd.javascript.reloadProjects,

Vsccmdi.javascript.removeUnusedImports,
===
* McshEngl.Vscdcmnd.javascript.removeUnusedImports,

Vsccmdi.javascript.sortImports,
===
* McshEngl.Vscdcmnd.javascript.sortImports,

Vsccmdi.jsBrowserBreakpoints.focus,
===
* McshEngl.Vscdcmnd.jsBrowserBreakpoints.focus,

Vsccmdi.jsBrowserBreakpoints.resetViewLocation,
===
* McshEngl.Vscdcmnd.jsBrowserBreakpoints.resetViewLocation,

Vsccmdi.jsDebugNetworkTree.focus,
===
* McshEngl.Vscdcmnd.jsDebugNetworkTree.focus,

Vsccmdi.jsDebugNetworkTree.resetViewLocation,
===
* McshEngl.Vscdcmnd.jsDebugNetworkTree.resetViewLocation,

Vsccmdi.jsExcludedCallers.focus,
===
* McshEngl.Vscdcmnd.jsExcludedCallers.focus,

Vsccmdi.jsExcludedCallers.resetViewLocation,
===
* McshEngl.Vscdcmnd.jsExcludedCallers.resetViewLocation,

Vsccmdi.json.clearCache,
===
* McshEngl.Vscdcmnd.json.clearCache,

Vsccmdi.json.sort,
===
* McshEngl.Vscdcmnd.json.sort,

Vsccmdi.json.validate,
===
* McshEngl.Vscdcmnd.json.validate,

Vsccmdi.jumpToNextSnippetPlaceholder,
· key: tab,
· when: hasNextTabstop && inSnippetMode && textInputFocus,
===
* McshEngl.Vscdcmnd.jumpToNextSnippetPlaceholder,

Vsccmdi.jumpToPrevSnippetPlaceholder,
· key: shift+tab,
· when: hasPrevTabstop && inSnippetMode && textInputFocus,
===
* McshEngl.Vscdcmnd.jumpToPrevSnippetPlaceholder,

Vsccmdi.jumpToSchema,
===
* McshEngl.Vscdcmnd.jumpToSchema,

Vsccmdi.kb-macro.abortPlayback,
· key: escape,
· when: kb-macro.playing,
===
* McshEngl.Vscdcmnd.kb_macro.abortPlayback,

Vsccmdi.kb-macro.cancelRecording,
· key: ctrl+alt+p,
· when: kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option1',
===
* McshEngl.Vscdcmnd.kb_macro.cancelRecording,

Vsccmdi.kb-macro.cancelRecording,
· key: ctrl+shift+alt+p,
· when: kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option2',
===
* McshEngl.Vscdcmnd.kb_macro.cancelRecording,

Vsccmdi.kb-macro.copyMacroAsKeybinding,
===
* McshEngl.Vscdcmnd.kb_macro.copyMacroAsKeybinding,

Vsccmdi.kb-macro.finishRecording,
· key: ctrl+alt+r,
· when: kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option1',
===
* McshEngl.Vscdcmnd.kb_macro.finishRecording,

Vsccmdi.kb-macro.finishRecording,
· key: ctrl+shift+alt+r,
· when: kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option2',
===
* McshEngl.Vscdcmnd.kb_macro.finishRecording,

Vsccmdi.kb-macro.playback,
· key: ctrl+alt+p,
· when: !kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option1',
===
* McshEngl.Vscdcmnd.kb_macro.playback,

Vsccmdi.kb-macro.playback,
· key: ctrl+shift+alt+p,
· when: !kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option2',
===
* McshEngl.Vscdcmnd.kb_macro.playback,

Vsccmdi.kb-macro.repeatPlayback,
===
* McshEngl.Vscdcmnd.kb_macro.repeatPlayback,

Vsccmdi.kb-macro.repeatPlaybackTillEndOfFile,
===
* McshEngl.Vscdcmnd.kb_macro.repeatPlaybackTillEndOfFile,

Vsccmdi.kb-macro.startRecording,
· key: ctrl+alt+r,
· when: !kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option1',
===
* McshEngl.Vscdcmnd.kb_macro.startRecording,

Vsccmdi.kb-macro.startRecording,
· key: ctrl+shift+alt+r,
· when: !kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option2',
===
* McshEngl.Vscdcmnd.kb_macro.startRecording,

Vsccmdi.kb-macro.wrap,
· key: alt+-,
· when: inSearchEditor && kb-macro.active,
· args: {"command":"decreaseSearchEditorContextLines"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+0,
· when: kb-macro.active,
· args: {"command":"workbench.action.lastEditorInGroup"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+1,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex1"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+2,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex2"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+3,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex3"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+4,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex4"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+5,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex5"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+6,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex6"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+7,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex7"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+8,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex8"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+9,
· when: kb-macro.active,
· args: {"command":"workbench.action.openEditorAtIndex9"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+=,
· when: inSearchEditor && kb-macro.active,
· args: {"command":"increaseSearchEditorContextLines"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+[,
· when: accessibleViewIsShown && accessibleViewSupportsNavigation && kb-macro.active,
· args: {"command":"editor.action.accessibleViewPrevious"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+[,
· when: inlineSuggestionVisible && kb-macro.active && !editorReadonly,
· args: {"command":"editor.action.inlineSuggest.showPrevious","record":"side-effect"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+],
· when: accessibleViewIsShown && accessibleViewSupportsNavigation && kb-macro.active,
· args: {"command":"editor.action.accessibleViewNext"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+],
· when: inlineSuggestionVisible && kb-macro.active && !editorReadonly,
· args: {"command":"editor.action.inlineSuggest.showNext","record":"side-effect"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+`,
· when: hasSpeechProvider && kb-macro.active && !editorReadonly && !speechToTextInProgress,
· args: {"command":"workbench.action.editorDictation.start"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+a,
· when: accessibilityHelpIsShown && accessibleViewHasAssignedKeybindings && kb-macro.active,
· args: {"command":"editor.action.accessibilityHelpConfigureAssignedKeybindings"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+backspace,
· when: commentWidgetVisible && editorFocus && kb-macro.active,
· args: {"command":"workbench.action.hideComment"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+c,
· when: editorFocus && kb-macro.active,
· args: {"command":"toggleFindCaseSensitive"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+c,
· when: inSearchEditor && kb-macro.active && searchInputBoxFocus,
· args: {"command":"toggleSearchEditorCaseSensitive"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+c,
· when: kb-macro.active && searchViewletFocus,
· args: {"command":"toggleSearchCaseSensitive"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+delete,
· when: false,
· args: {"command":"deleteWordRight"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+delete,
· when: false,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001bd"}},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+delete,
· when: kb-macro.active && notebookCellEditable && notebookCellHasOutputs && notebookEditable && notebookEditorFocused && !inputFocus,
· args: {"command":"notebook.cell.clearOutputs"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: editorHoverFocused && kb-macro.active,
· args: {"command":"editor.action.pageDownHover"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: editorPartModal && editorPartModalNavigation && kb-macro.active,
· args: {"command":"workbench.action.navigateModalEditorNext"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: editorTextFocus && kb-macro.active && !editorReadonly,
· args: {"command":"editor.action.moveLinesDownAction"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: historyNavigationForwardsEnabled && historyNavigationWidgetFocus && kb-macro.active && !isComposing && !suggestWidgetVisible,
· args: {"command":"history.showNext"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused,
· args: {"command":"list.focusAnyDown"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: kb-macro.active && notebookEditorFocused && !inputFocus,
· args: {"command":"notebook.cell.moveDown"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+down,
· when: kb-macro.active && scmRepository,
· args: {"command":"scm.forceViewNextCommit"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"}},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+end,
· when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused,
· args: {"command":"list.focusAnyLast"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: breakpointsFocused && kb-macro.active,
· args: {"command":"debug.openBreakpointToSide"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: editorFocus && findWidgetVisible && kb-macro.active,
· args: {"command":"editor.action.selectAllMatches"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: hasSearchResult && kb-macro.active && searchViewletFocus,
· args: {"command":"search.action.openInEditor"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget',
· args: {"command":"quickInput.accept"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+enter,
· when: kb-macro.active && focusedView == 'workbench.view.testing',
· args: {"command":"testing.editFocusedTest"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+escape,
· when: false,
· args: {"command":"editor.action.triggerSuggest","record":"side-effect"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+escape,
· when: inQuickInput && kb-macro.active,
· args: {"command":"quickInput.hide"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f1,
· when: kb-macro.active && !accessibilityHelpIsShown,
· args: {"command":"editor.action.accessibilityHelp"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f2,
· when: kb-macro.active,
· args: {"command":"editor.action.accessibleView"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f3,
· when: editorTextFocus && kb-macro.active && !textCompareEditorActive,
· args: {"command":"editor.action.dirtydiff.next"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f3,
· when: kb-macro.active && activeEditor == 'workbench.editor.notebookTextDiffEditor',
· args: {"command":"notebook.diff.action.next"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f4,
· when: kb-macro.active,
· args: {"command":"workbench.action.closeWindow"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f5,
· when: editorTextFocus && kb-macro.active && !textCompareEditorActive && quickDiffDecorationCount != '0',
· args: {"command":"workbench.action.editor.nextChange"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f5,
· when: kb-macro.active && activeEditor == 'multiDiffEditor',
· args: {"command":"multiDiffEditor.goToNextChange"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f5,
· when: kb-macro.active && textCompareEditorVisible,
· args: {"command":"workbench.action.compareEditor.nextChange"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f8,
· when: editorFocus && kb-macro.active && testing.isPeekVisible,
· args: {"command":"testing.goToNextMessage"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f8,
· when: editorFocus && kb-macro.active,
· args: {"command":"editor.action.marker.next"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f9,
· when: activeEditor && kb-macro.active && testing.hasCoverageInFile,
· args: {"command":"testing.coverage.goToNextMissedLine"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f9,
· when: kb-macro.active,
· args: {"command":"editor.action.nextCommentThreadAction"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f10,
· when: activeEditorHasCommentingRange && kb-macro.active,
· args: {"command":"editor.action.nextCommentedRangeAction"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+f12,
· when: editorHasDefinitionProvider && editorTextFocus && kb-macro.active && !inReferenceSearchEditor && !isInEmbeddedEditor,
· args: {"command":"editor.action.peekDefinition"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+h,
· when: accessibilityHelpIsShown && kb-macro.active,
· args: {"command":"editor.action.accessibilityHelpOpenHelpLink"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+h,
· when: kb-macro.active && testing.isPeekVisible,
· args: {"command":"testing.toggleTestingPeekHistory"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+home alt+home,
· when: kb-macro.active && mostRecentReplEditor,
· args: {"command":"repl.input.focus"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+home,
· when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused,
· args: {"command":"list.focusAnyFirst"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+k,
· when: accessibilityHelpIsShown && accessibleViewHasUnassignedKeybindings && kb-macro.active,
· args: {"command":"editor.action.accessibilityHelpConfigureKeybindings"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+k,
· when: inKeybindings && inKeybindingsSearch && kb-macro.active,
· args: {"command":"keybindings.editor.recordSearchKeys"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+l,
· when: editorFocus && kb-macro.active,
· args: {"command":"toggleFindInSelection"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+l,
· when: inSearchEditor && kb-macro.active,
· args: {"command":"toggleSearchEditorContextLines"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: canNavigateBack && kb-macro.active,
· args: {"command":"workbench.action.navigateBack"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: false,
· args: {"command":"breadcrumbs.focusPrevious"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: false,
· args: {"command":"breadcrumbs.focusPreviousWithPicker"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: false,
· args: {"command":"cursorWordLeft"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: false,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001bb"}},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+left,
· when: inQuickOpen && kb-macro.active,
· args: {"command":"workbench.action.quickInputBack"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"}},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+n,
· when: chatHasQuestionCarousel && inChat && inChatQuestionCarousel && kb-macro.active,
· args: {"command":"workbench.action.chat.nextQuestion"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+p,
· when: chatHasQuestionCarousel && inChat && inChatQuestionCarousel && kb-macro.active,
· args: {"command":"workbench.action.chat.previousQuestion"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+p,
· when: editorFocus && kb-macro.active,
· args: {"command":"togglePreserveCase"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+p,
· when: inKeybindings && kb-macro.active,
· args: {"command":"keybindings.editor.toggleSortByPrecedence"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+p,
· when: kb-macro.active && searchViewletFocus,
· args: {"command":"toggleSearchPreserveCase"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+pagedown,
· when: kb-macro.active && textInputFocus,
· args: {"command":"scrollPageDown"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+pageup,
· when: kb-macro.active && textInputFocus,
· args: {"command":"scrollPageUp"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+r,
· when: editorFocus && kb-macro.active,
· args: {"command":"toggleFindRegex"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+r,
· when: inSearchEditor && kb-macro.active && searchInputBoxFocus,
· args: {"command":"toggleSearchEditorRegex"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+r,
· when: kb-macro.active && searchViewletFocus,
· args: {"command":"toggleSearchRegex"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: canNavigateForward && kb-macro.active,
· args: {"command":"workbench.action.navigateForward"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: false,
· args: {"command":"breadcrumbs.focusNext"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: false,
· args: {"command":"breadcrumbs.focusNextWithPicker"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: false,
· args: {"command":"cursorWordEndRight"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+right,
· when: false,
· args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001bf"}},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"}},
===
* McshEngl.Vscdcmnd.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"}},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+t,
· when: accessibleViewIsShown && chatIsEnabled && kb-macro.active && accessibleViewCurrentProviderId == 'panelChat',
· args: {"command":"workbench.action.chat.toggleThinkingContentAccessibleView"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: editorHoverFocused && kb-macro.active,
· args: {"command":"editor.action.pageUpHover"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: editorPartModal && editorPartModalNavigation && kb-macro.active,
· args: {"command":"workbench.action.navigateModalEditorPrevious"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: editorTextFocus && kb-macro.active && !editorReadonly,
· args: {"command":"editor.action.moveLinesUpAction"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: historyNavigationBackwardsEnabled && historyNavigationWidgetFocus && kb-macro.active && !isComposing && !suggestWidgetVisible,
· args: {"command":"history.showPrevious"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused,
· args: {"command":"list.focusAnyUp"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: kb-macro.active && notebookEditorFocused && !inputFocus,
· args: {"command":"notebook.cell.moveUp"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+up,
· when: kb-macro.active && scmRepository,
· args: {"command":"scm.forceViewPreviousCommit"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"}},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+w,
· when: editorFocus && kb-macro.active,
· args: {"command":"toggleFindWholeWord"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+w,
· when: inSearchEditor && kb-macro.active && searchInputBoxFocus,
· args: {"command":"toggleSearchEditorWholeWord"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+w,
· when: kb-macro.active && searchViewletFocus,
· args: {"command":"toggleSearchWholeWord"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+/,
· when: chatIsEnabled && kb-macro.active,
· args: {"command":"workbench.action.chat.run.prompt"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+/,
· when: chatIsEnabled && kb-macro.active,
· args: {"command":"workbench.action.chat.run.prompt"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+backspace,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"editor.action.removeBrackets"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+c,
· when: fileMatchOrFolderMatchWithResourceFocus && kb-macro.active,
· args: {"command":"search.action.copyPath"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+c,
· when: kb-macro.active && !editorFocus,
· args: {"command":"copyFilePath"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+c,
· when: kb-macro.active && searchViewletFocus && !fileMatchOrFolderMatchFocus,
· args: {"command":"toggleSearchCaseSensitive"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+down,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"editor.action.insertCursorBelow"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+enter,
· when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget',
· args: {"command":"quickInput.accept"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+escape,
· when: inQuickInput && kb-macro.active,
· args: {"command":"quickInput.hide"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+j,
· when: kb-macro.active && notebookEditorFocused,
· args: {"command":"notebook.cell.joinBelow"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+j,
· when: kb-macro.active && notebookEditorFocused,
· args: {"command":"notebook.cell.joinBelow"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+left,
· when: kb-macro.active,
· args: {"command":"workbench.action.previousEditor"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+r,
· when: kb-macro.active && !editorFocus,
· args: {"command":"revealFileInOS"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+right,
· when: kb-macro.active,
· args: {"command":"workbench.action.nextEditor"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+s,
· when: kb-macro.active,
· args: {"command":"saveAll"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+t,
· when: kb-macro.active,
· args: {"command":"workbench.action.closeOtherEditors"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+win+up,
· when: editorTextFocus && kb-macro.active,
· args: {"command":"editor.action.insertCursorAbove"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.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"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,

Vsccmdi.kb-macro.wrap,
· key: alt+z,
· when: kb-macro.active,
· args: {"command":"editor.action.toggleWordWrap"},
===
* McshEngl.Vscdcmnd.kb_macro.wrap,