Update CLI and bump to beta-7

# Conflicts:
#	package.json

.github/workflows/build.yml

@@ -13,6 +13,9 @@ on:
   schedule:
     - cron: '0 3 * * *' # run every day at 3AM (https://docs.github.com/en/actions/reference/events-that-trigger-workflows#scheduled-events-schedule)
 
+env:
+  JOB_TRANSFER_ARTIFACT: build-artifacts
+
 jobs:
 
   build:
@@ -21,7 +24,7 @@ jobs:
       matrix:
         config:
           - os: windows-latest
-          - os: ubuntu-latest
+          - os: ubuntu-18.04 # https://github.com/arduino/arduino-ide/issues/259
           - os: macos-latest
     runs-on: ${{ matrix.config.os }}
     timeout-minutes: 90
@@ -79,9 +82,42 @@ jobs:
       - name: Upload [GitHub Actions]
         uses: actions/upload-artifact@v2
         with:
-          name: build-artifacts
+          name: ${{ env.JOB_TRANSFER_ARTIFACT }}
           path: electron/build/dist/build-artifacts/
 
+  artifacts:
+    name: ${{ matrix.artifact.name }} artifact
+    needs: build
+    if: always() && needs.build.result != 'skipped'
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        artifact:
+          - path: "*Linux_64bit.zip"
+            name: Linux_X86-64
+          - path: "*macOS_64bit.dmg"
+            name: macOS
+          - path: "*Windows_64bit.exe"
+            name: Windows_X86-64_interactive_installer
+          - path: "*Windows_64bit.msi"
+            name: Windows_X86-64_MSI
+          - path: "*Windows_64bit.zip"
+            name: Windows_X86-64_zip
+
+    steps:
+      - name: Download job transfer artifact
+        uses: actions/download-artifact@v2
+        with:
+          name: ${{ env.JOB_TRANSFER_ARTIFACT }}
+          path: ${{ env.JOB_TRANSFER_ARTIFACT }}
+      
+      - name: Upload tester build artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ matrix.artifact.name }}
+          path: ${{ env.JOB_TRANSFER_ARTIFACT }}/${{ matrix.artifact.path }}
+
   changelog:
     needs: build
     runs-on: ubuntu-latest
@@ -121,7 +157,7 @@ jobs:
         if: github.event_name == 'schedule' || (github.event_name == 'workflow_dispatch' && github.ref == 'refs/heads/main')
         uses: actions/upload-artifact@v2
         with:
-          name: build-artifacts
+          name: ${{ env.JOB_TRANSFER_ARTIFACT }}
           path: CHANGELOG.txt
 
   publish:
@@ -132,14 +168,14 @@ jobs:
       - name: Download [GitHub Actions]
         uses: actions/download-artifact@v2
         with:
-          name: build-artifacts
-          path: build-artifacts
+          name: ${{ env.JOB_TRANSFER_ARTIFACT }}
+          path: ${{ env.JOB_TRANSFER_ARTIFACT }}
 
       - name: Publish Nightly [S3]
         uses: docker://plugins/s3
         env:
-          PLUGIN_SOURCE: "build-artifacts/*"
-          PLUGIN_STRIP_PREFIX: "build-artifacts/"
+          PLUGIN_SOURCE: "${{ env.JOB_TRANSFER_ARTIFACT }}/*"
+          PLUGIN_STRIP_PREFIX: "${{ env.JOB_TRANSFER_ARTIFACT }}/"
           PLUGIN_TARGET: "/arduino-ide/nightly"
           PLUGIN_BUCKET: ${{ secrets.DOWNLOADS_BUCKET }}
           AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
@@ -153,8 +189,8 @@ jobs:
       - name: Download [GitHub Actions]
         uses: actions/download-artifact@v2
         with:
-          name: build-artifacts
-          path: build-artifacts
+          name: ${{ env.JOB_TRANSFER_ARTIFACT }}
+          path: ${{ env.JOB_TRANSFER_ARTIFACT }}
 
       - name: Get Tag
         id: tag_name
@@ -166,7 +202,7 @@ jobs:
         with:
           repo_token: ${{ secrets.GITHUB_TOKEN }}
           release_name: ${{ steps.tag_name.outputs.TAG_NAME }}
-          file: build-artifacts/*
+          file: ${{ env.JOB_TRANSFER_ARTIFACT }}/*
           tag: ${{ github.ref }}
           file_glob: true
           body: ${{ needs.changelog.outputs.BODY }}
@@ -174,9 +210,25 @@ jobs:
       - name: Publish Release [S3]
         uses: docker://plugins/s3
         env:
-          PLUGIN_SOURCE: "build-artifacts/*"
-          PLUGIN_STRIP_PREFIX: "build-artifacts/"
+          PLUGIN_SOURCE: "${{ env.JOB_TRANSFER_ARTIFACT }}/*"
+          PLUGIN_STRIP_PREFIX: "${{ env.JOB_TRANSFER_ARTIFACT }}/"
           PLUGIN_TARGET: "/arduino-ide"
           PLUGIN_BUCKET: ${{ secrets.DOWNLOADS_BUCKET }}
           AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
           AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+
+  clean:
+    # This job must run after all jobs that use the transfer artifact.
+    needs:
+      - build
+      - publish
+      - release
+      - artifacts
+    if: always() && needs.build.result != 'skipped'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Remove unneeded job transfer artifact
+        uses: geekyeggo/delete-artifact@v1
+        with:
+          name: ${{ env.JOB_TRANSFER_ARTIFACT }}

.vscode/launch.json

@@ -29,15 +29,17 @@
           "NODE_PRESERVE_SYMLINKS": "1"
         }
       },
-      "program": "${workspaceRoot}/electron-app/src-gen/frontend/electron-main.js",
+      "cwd": "${workspaceFolder}/electron-app",
       "protocol": "inspector",
       "args": [
+        ".",
         "--log-level=debug",
         "--hostname=localhost",
         "--no-cluster",
+        "--app-project-path=${workspaceRoot}/electron-app",
         "--remote-debugging-port=9222",
         "--no-app-auto-install",
-        "--plugins=local-dir:plugins"
+        "--plugins=local-dir:../plugins"
       ],
       "env": {
         "NODE_ENV": "development"

BUILDING.md

@@ -61,7 +61,7 @@ yarn start
 
 This project is built on [GitHub Actions](https://github.com/arduino/arduino-ide/actions).
 
- - _Snapshot_ builds run when changes are pushed to the `main` branch, or when a PR is created against the `main` branch. For the sake of the review and verification process, the build artifacts can be downloaded from the GitHub Actions page. Note: [due to a limitation](https://github.com/actions/upload-artifact/issues/80#issuecomment-630030144) with the GH Actions UI, you cannot download a particular build, but you have to get all together inside the `build-artifacts.zip`.
+ - _Snapshot_ builds run when changes are pushed to the `main` branch, or when a PR is created against the `main` branch. For the sake of the review and verification process, the build artifacts for each operating system can be downloaded from the GitHub Actions page.
  - _Nightly_ builds run every day at 03:00 GMT from the `main` branch.
  - _Release_ builds run when a new tag is pushed to the remote. The tag must follow the [semver](https://semver.org/). For instance, `1.2.3` is a correct tag, but `v2.3.4` won't work. Steps to trigger a new release build:
    - Create a local tag:

arduino-ide-extension/README.md

@@ -54,3 +54,7 @@ The Config Service knows about your system, like for example the default sketch
 ### `"arduino"` configuration in the `package.json`:
  - `"cli"`:
    - `"version"` type `string` | `{ owner: string, repo: string, commitish?: string }`: if the type is a `string` and is a valid semver, it will get the corresponding [released](https://github.com/arduino/arduino-cli/releases) CLI. If the type is `string` and is a [date in `YYYYMMDD`](https://arduino.github.io/arduino-cli/latest/installation/#nightly-builds) format, it will get a nightly CLI. If the type is an object, a CLI, build from the sources in the `owner/repo` will be used. If `commitish` is not defined, the HEAD of the default branch will be used. In any other cases an error is thrown.
+
+#### Rebuild gRPC protocol interfaces
+  - Some CLI updates can bring changes to the gRPC interfaces, as the API might change. gRPC interfaces can be updated running the command
+    `yarn --cwd arduino-ide-extension generate-protocol`

arduino-ide-extension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arduino-ide-extension",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.7",
   "description": "An extension for Theia building the Arduino IDE",
   "license": "AGPL-3.0-or-later",
   "scripts": {
@@ -23,6 +23,7 @@
     "@theia/editor": "next",
     "@theia/filesystem": "next",
     "@theia/git": "next",
+    "@theia/keymaps": "next",
     "@theia/markers": "next",
     "@theia/monaco": "next",
     "@theia/navigator": "next",
@@ -121,7 +122,7 @@
   ],
   "arduino": {
     "cli": {
-      "version": "0.17.0"
+      "version": "0.18.3"
     }
   }
 }

arduino-ide-extension/src/browser/arduino-frontend-contribution.tsx

@@ -1,5 +1,5 @@
 import { Mutex } from 'async-mutex';
-import { MAIN_MENU_BAR, MenuContribution, MenuModelRegistry, SelectionService, ILogger } from '@theia/core';
+import { MAIN_MENU_BAR, MenuContribution, MenuModelRegistry, SelectionService, ILogger, DisposableCollection } from '@theia/core';
 import {
     ContextMenuRenderer,
     FrontendApplication, FrontendApplicationContribution,
@@ -12,7 +12,7 @@ import { TabBarToolbarContribution, TabBarToolbarRegistry } from '@theia/core/li
 import { CommandContribution, CommandRegistry } from '@theia/core/lib/common/command';
 import { MessageService } from '@theia/core/lib/common/message-service';
 import URI from '@theia/core/lib/common/uri';
-import { EditorMainMenu, EditorManager } from '@theia/editor/lib/browser';
+import { EditorMainMenu, EditorManager, EditorOpenerOptions } from '@theia/editor/lib/browser';
 import { FileDialogService } from '@theia/filesystem/lib/browser/file-dialog';
 import { ProblemContribution } from '@theia/markers/lib/browser/problem/problem-contribution';
 import { MonacoMenus } from '@theia/monaco/lib/browser/monaco-menu';
@@ -26,7 +26,7 @@ import { inject, injectable, postConstruct } from 'inversify';
 import * as React from 'react';
 import { remote } from 'electron';
 import { MainMenuManager } from '../common/main-menu-manager';
-import { BoardsService, CoreService, Port, SketchesService, ExecutableService } from '../common/protocol';
+import { BoardsService, CoreService, Port, SketchesService, ExecutableService, Sketch } from '../common/protocol';
 import { ArduinoDaemon } from '../common/protocol/arduino-daemon';
 import { ConfigService } from '../common/protocol/config-service';
 import { FileSystemExt } from '../common/protocol/filesystem-ext';
@@ -44,10 +44,12 @@ import { WorkspaceService } from './theia/workspace/workspace-service';
 import { ArduinoToolbar } from './toolbar/arduino-toolbar';
 import { HostedPluginSupport } from '@theia/plugin-ext/lib/hosted/browser/hosted-plugin';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
-import { OutputService } from '../common/protocol/output-service';
+import { ResponseService } from '../common/protocol/response-service';
 import { ArduinoPreferences } from './arduino-preferences';
 import { SketchesServiceClientImpl } from '../common/protocol/sketches-service-client-impl';
 import { SaveAsSketch } from './contributions/save-as-sketch';
+import { FileChangeType } from '@theia/filesystem/lib/browser';
+import { FrontendApplicationStateService } from '@theia/core/lib/browser/frontend-application-state';
 
 @injectable()
 export class ArduinoFrontendContribution implements FrontendApplicationContribution,
@@ -81,7 +83,7 @@ export class ArduinoFrontendContribution implements FrontendApplicationContribut
     protected readonly fileDialogService: FileDialogService;
 
     @inject(FileService)
-    protected readonly fileSystem: FileService;
+    protected readonly fileService: FileService;
 
     @inject(SketchesService)
     protected readonly sketchService: SketchesService;
@@ -149,8 +151,8 @@ export class ArduinoFrontendContribution implements FrontendApplicationContribut
     @inject(ExecutableService)
     protected executableService: ExecutableService;
 
-    @inject(OutputService)
-    protected readonly outputService: OutputService;
+    @inject(ResponseService)
+    protected readonly responseService: ResponseService;
 
     @inject(ArduinoPreferences)
     protected readonly arduinoPreferences: ArduinoPreferences;
@@ -158,7 +160,11 @@ export class ArduinoFrontendContribution implements FrontendApplicationContribut
     @inject(SketchesServiceClientImpl)
     protected readonly sketchServiceClient: SketchesServiceClientImpl;
 
+    @inject(FrontendApplicationStateService)
+    protected readonly appStateService: FrontendApplicationStateService;
+
     protected invalidConfigPopup: Promise<void | 'No' | 'Yes' | undefined> | undefined;
+    protected toDisposeOnStop = new DisposableCollection();
 
     @postConstruct()
     protected async init(): Promise<void> {
@@ -182,6 +188,23 @@ export class ArduinoFrontendContribution implements FrontendApplicationContribut
         }
         this.boardsServiceClientImpl.onBoardsConfigChanged(updateStatusBar);
         updateStatusBar(this.boardsServiceClientImpl.boardsConfig);
+        this.appStateService.reachedState('ready').then(async () => {
+            const sketch = await this.sketchServiceClient.currentSketch();
+            if (sketch && (!await this.sketchService.isTemp(sketch))) {
+                this.toDisposeOnStop.push(this.fileService.watch(new URI(sketch.uri)));
+                this.toDisposeOnStop.push(this.fileService.onDidFilesChange(async event => {
+                    for (const { type, resource } of event.changes) {
+                        if (type === FileChangeType.ADDED && resource.parent.toString() === sketch.uri) {
+                            const reloadedSketch = await this.sketchService.loadSketch(sketch.uri)
+                            if (Sketch.isInSketch(resource, reloadedSketch)) {
+                                this.ensureOpened(resource.toString(), true, { mode: 'open' });
+                            }
+                        }
+                    }
+                }));
+            }
+        });
+
     }
 
     onStart(app: FrontendApplication): void {
@@ -225,6 +248,10 @@ export class ArduinoFrontendContribution implements FrontendApplicationContribut
         app.shell.leftPanelHandler.removeMenu('settings-menu');
     }
 
+    onStop(): void {
+        this.toDisposeOnStop.dispose();
+    }
+
     protected languageServerFqbn?: string;
     protected languageServerStartMutex = new Mutex();
     protected async startLanguageServer(fqbn: string, name: string | undefined): Promise<void> {
@@ -257,14 +284,15 @@ export class ArduinoFrontendContribution implements FrontendApplicationContribut
             if (log) {
                 const currentSketch = await this.sketchServiceClient.currentSketch();
                 if (currentSketch) {
-                    currentSketchPath = await this.fileSystem.fsPath(new URI(currentSketch.uri));
+                    currentSketchPath = await this.fileService.fsPath(new URI(currentSketch.uri));
                 }
             }
             const { clangdUri, cliUri, lsUri } = await this.executableService.list();
-            const [clangdPath, cliPath, lsPath] = await Promise.all([
-                this.fileSystem.fsPath(new URI(clangdUri)),
-                this.fileSystem.fsPath(new URI(cliUri)),
-                this.fileSystem.fsPath(new URI(lsUri)),
+            const [clangdPath, cliPath, lsPath, cliConfigPath] = await Promise.all([
+                this.fileService.fsPath(new URI(clangdUri)),
+                this.fileService.fsPath(new URI(cliUri)),
+                this.fileService.fsPath(new URI(lsUri)),
+                this.fileService.fsPath(new URI(await this.configService.getCliConfigFileUri()))
             ]);
             this.languageServerFqbn = await Promise.race([
                 new Promise<undefined>((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${20_000} ms.`)), 20_000)),
@@ -273,6 +301,7 @@ export class ArduinoFrontendContribution implements FrontendApplicationContribut
                     cliPath,
                     clangdPath,
                     log: currentSketchPath ? currentSketchPath : log,
+                    cliConfigPath,
                     board: {
                         fqbn,
                         name: name ? `"${name}"` : undefined
@@ -367,10 +396,10 @@ export class ArduinoFrontendContribution implements FrontendApplicationContribut
         }
     }
 
-    protected async ensureOpened(uri: string, forceOpen: boolean = false): Promise<any> {
+    protected async ensureOpened(uri: string, forceOpen: boolean = false, options?: EditorOpenerOptions | undefined): Promise<any> {
         const widget = this.editorManager.all.find(widget => widget.editor.uri.toString() === uri);
         if (!widget || forceOpen) {
-            return this.editorManager.open(new URI(uri));
+            return this.editorManager.open(new URI(uri), options);
         }
     }
 
@@ -420,13 +449,13 @@ export class ArduinoFrontendContribution implements FrontendApplicationContribut
                 description: 'Background color of the toolbar items when hovering over them. Such as Upload, Verify, etc.'
             },
             {
-              id: 'arduino.toolbar.toggleBackground',
-              defaults: {
-                  dark: 'editor.selectionBackground',
-                  light: 'editor.selectionBackground',
-                  hc: 'textPreformat.foreground'
-              },
-              description: 'Toggle color of the toolbar items when they are currently toggled (the command is in progress)'
+                id: 'arduino.toolbar.toggleBackground',
+                defaults: {
+                    dark: 'editor.selectionBackground',
+                    light: 'editor.selectionBackground',
+                    hc: 'textPreformat.foreground'
+                },
+                description: 'Toggle color of the toolbar items when they are currently toggled (the command is in progress)'
             },
             {
                 id: 'arduino.output.foreground',

arduino-ide-extension/src/browser/arduino-ide-frontend-module.ts

@@ -24,6 +24,8 @@ import { ProblemContribution as TheiaProblemContribution } from '@theia/markers/
 import { ProblemContribution } from './theia/markers/problem-contribution';
 import { FileNavigatorContribution } from './theia/navigator/navigator-contribution';
 import { FileNavigatorContribution as TheiaFileNavigatorContribution } from '@theia/navigator/lib/browser/navigator-contribution';
+import { KeymapsFrontendContribution } from './theia/keymaps/keymaps-frontend-contribution';
+import { KeymapsFrontendContribution as TheiaKeymapsFrontendContribution } from '@theia/keymaps/lib/browser/keymaps-frontend-contribution';
 import { ArduinoToolbarContribution } from './toolbar/arduino-toolbar-contribution';
 import { EditorContribution as TheiaEditorContribution } from '@theia/editor/lib/browser/editor-contribution';
 import { EditorContribution } from './theia/editor/editor-contribution';
@@ -67,8 +69,7 @@ import { ListItemRenderer } from './widgets/component-list/list-item-renderer';
 import { ColorContribution } from '@theia/core/lib/browser/color-application-contribution';
 import { MonacoThemingService } from '@theia/monaco/lib/browser/monaco-theming-service';
 import { ArduinoDaemonPath, ArduinoDaemon } from '../common/protocol/arduino-daemon';
-import { EditorManager as TheiaEditorManager, EditorCommandContribution as TheiaEditorCommandContribution } from '@theia/editor/lib/browser';
-import { EditorManager } from './theia/editor/editor-manager';
+import { EditorCommandContribution as TheiaEditorCommandContribution } from '@theia/editor/lib/browser';
 import { FrontendConnectionStatusService, ApplicationConnectionStatusContribution } from './theia/core/connection-status-service';
 import {
     FrontendConnectionStatusService as TheiaFrontendConnectionStatusService,
@@ -119,8 +120,8 @@ import { OutputChannelRegistryMainImpl as TheiaOutputChannelRegistryMainImpl, Ou
 import { ExecutableService, ExecutableServicePath } from '../common/protocol';
 import { MonacoTextModelService as TheiaMonacoTextModelService } from '@theia/monaco/lib/browser/monaco-text-model-service';
 import { MonacoTextModelService } from './theia/monaco/monaco-text-model-service';
-import { OutputServiceImpl } from './output-service-impl';
-import { OutputServicePath, OutputService } from '../common/protocol/output-service';
+import { ResponseServiceImpl } from './response-service-impl';
+import { ResponseServicePath, ResponseService } from '../common/protocol/response-service';
 import { NotificationCenter } from './notification-center';
 import { NotificationServicePath, NotificationServiceServer } from '../common/protocol';
 import { About } from './contributions/about';
@@ -153,6 +154,15 @@ import { SearchInWorkspaceWidget as TheiaSearchInWorkspaceWidget } from '@theia/
 import { SearchInWorkspaceWidget } from './theia/search-in-workspace/search-in-workspace-widget';
 import { SearchInWorkspaceResultTreeWidget as TheiaSearchInWorkspaceResultTreeWidget } from '@theia/search-in-workspace/lib/browser/search-in-workspace-result-tree-widget';
 import { SearchInWorkspaceResultTreeWidget } from './theia/search-in-workspace/search-in-workspace-result-tree-widget';
+import { MonacoEditorProvider } from './theia/monaco/monaco-editor-provider';
+import { MonacoEditorProvider as TheiaMonacoEditorProvider } from '@theia/monaco/lib/browser/monaco-editor-provider';
+import { DebugEditorModel } from './theia/debug/debug-editor-model';
+import { DebugEditorModelFactory } from '@theia/debug/lib/browser/editor/debug-editor-model';
+import { StorageWrapper } from './storage-wrapper';
+import { NotificationManager } from './theia/messages/notifications-manager';
+import { NotificationManager as TheiaNotificationManager } from '@theia/messages/lib/browser/notifications-manager';
+import { NotificationsRenderer as TheiaNotificationsRenderer } from '@theia/messages/lib/browser/notifications-renderer';
+import { NotificationsRenderer } from './theia/messages/notifications-renderer';
 
 const ElementQueries = require('css-element-queries/src/ElementQueries');
 
@@ -278,6 +288,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     rebind(TheiaOutlineViewContribution).to(OutlineViewContribution).inSingletonScope();
     rebind(TheiaProblemContribution).to(ProblemContribution).inSingletonScope();
     rebind(TheiaFileNavigatorContribution).to(FileNavigatorContribution).inSingletonScope();
+    rebind(TheiaKeymapsFrontendContribution).to(KeymapsFrontendContribution).inSingletonScope();
     rebind(TheiaEditorContribution).to(EditorContribution).inSingletonScope();
     rebind(TheiaMonacoStatusBarContribution).to(MonacoStatusBarContribution).inSingletonScope();
     rebind(TheiaApplicationShell).to(ApplicationShell).inSingletonScope();
@@ -305,6 +316,8 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     rebind(TheiaOutputChannelRegistryMainImpl).toService(OutputChannelRegistryMainImpl);
     bind(MonacoTextModelService).toSelf().inSingletonScope();
     rebind(TheiaMonacoTextModelService).toService(MonacoTextModelService);
+    bind(MonacoEditorProvider).toSelf().inSingletonScope();
+    rebind(TheiaMonacoEditorProvider).toService(MonacoEditorProvider);
 
     bind(SearchInWorkspaceWidget).toSelf();
     rebind(TheiaSearchInWorkspaceWidget).toService(SearchInWorkspaceWidget);
@@ -321,10 +334,6 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(FrontendConnectionStatusService).toSelf().inSingletonScope();
     rebind(TheiaFrontendConnectionStatusService).toService(FrontendConnectionStatusService);
 
-    // Editor customizations. Sets the editor to `readOnly` if under the data dir.
-    bind(EditorManager).toSelf().inSingletonScope();
-    rebind(TheiaEditorManager).toService(EditorManager);
-
     // Decorator customizations
     bind(TabBarDecoratorService).toSelf().inSingletonScope();
     rebind(TheiaTabBarDecoratorService).toService(TabBarDecoratorService);
@@ -378,11 +387,11 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     Contribution.configure(bind, ArchiveSketch);
     Contribution.configure(bind, AddZipLibrary);
 
-    bind(OutputServiceImpl).toSelf().inSingletonScope().onActivation(({ container }, outputService) => {
-        WebSocketConnectionProvider.createProxy(container, OutputServicePath, outputService);
-        return outputService;
+    bind(ResponseServiceImpl).toSelf().inSingletonScope().onActivation(({ container }, responseService) => {
+        WebSocketConnectionProvider.createProxy(container, ResponseServicePath, responseService);
+        return responseService;
     });
-    bind(OutputService).toService(OutputServiceImpl);
+    bind(ResponseService).toService(ResponseServiceImpl);
 
     bind(NotificationCenter).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(NotificationCenter);
@@ -415,6 +424,11 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(DebugConfigurationManager).toSelf().inSingletonScope();
     rebind(TheiaDebugConfigurationManager).toService(DebugConfigurationManager);
 
+    // Patch for the debug hover: https://github.com/eclipse-theia/theia/pull/9256/
+    rebind(DebugEditorModelFactory).toDynamicValue(({ container }) => <DebugEditorModelFactory>(editor =>
+        DebugEditorModel.createModel(container, editor)
+    )).inSingletonScope();
+
     // Preferences
     bindArduinoPreferences(bind);
 
@@ -426,4 +440,12 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(SettingsDialogProps).toConstantValue({
         title: 'Preferences'
     });
+
+    bind(StorageWrapper).toSelf().inSingletonScope();
+    bind(CommandContribution).toService(StorageWrapper);
+
+    bind(NotificationManager).toSelf().inSingletonScope();
+    rebind(TheiaNotificationManager).toService(NotificationManager);
+    bind(NotificationsRenderer).toSelf().inSingletonScope();
+    rebind(TheiaNotificationsRenderer).toService(NotificationsRenderer);
 });

arduino-ide-extension/src/browser/boards/boards-auto-installer.ts

@@ -1,11 +1,12 @@
 import { injectable, inject } from 'inversify';
 import { MessageService } from '@theia/core/lib/common/message-service';
 import { FrontendApplicationContribution } from '@theia/core/lib/browser/frontend-application';
-import { BoardsService, BoardsPackage } from '../../common/protocol/boards-service';
+import { BoardsService, BoardsPackage, Board } from '../../common/protocol/boards-service';
 import { BoardsServiceProvider } from './boards-service-provider';
 import { BoardsListWidgetFrontendContribution } from './boards-widget-frontend-contribution';
-import { InstallationProgressDialog } from '../widgets/progress-dialog';
 import { BoardsConfig } from './boards-config';
+import { Installable } from '../../common/protocol';
+import { ResponseServiceImpl } from '../response-service-impl';
 
 /**
  * Listens on `BoardsConfig.Config` changes, if a board is selected which does not
@@ -23,9 +24,15 @@ export class BoardsAutoInstaller implements FrontendApplicationContribution {
     @inject(BoardsServiceProvider)
     protected readonly boardsServiceClient: BoardsServiceProvider;
 
+    @inject(ResponseServiceImpl)
+    protected readonly responseService: ResponseServiceImpl;
+
     @inject(BoardsListWidgetFrontendContribution)
     protected readonly boardsManagerFrontendContribution: BoardsListWidgetFrontendContribution;
 
+    // Workaround for https://github.com/eclipse-theia/theia/issues/9349
+    protected notifications: Board[] = [];
+
     onStart(): void {
         this.boardsServiceClient.onBoardsConfigChanged(this.ensureCoreExists.bind(this));
         this.ensureCoreExists(this.boardsServiceClient.boardsConfig);
@@ -33,22 +40,43 @@ export class BoardsAutoInstaller implements FrontendApplicationContribution {
 
     protected ensureCoreExists(config: BoardsConfig.Config): void {
         const { selectedBoard } = config;
-        if (selectedBoard) {
+        if (selectedBoard && !this.notifications.find(board => Board.sameAs(board, selectedBoard))) {
+            this.notifications.push(selectedBoard);
             this.boardsService.search({}).then(packages => {
-                const candidates = packages
-                    .filter(pkg => BoardsPackage.contains(selectedBoard, pkg))
+
+                // filter packagesForBoard selecting matches from the cli (installed packages)
+                // and matches based on the board name
+                // NOTE: this ensures the Deprecated & new packages are all in the array
+                // so that we can check if any of the valid packages is already installed
+                const packagesForBoard = packages.filter(pkg => BoardsPackage.contains(selectedBoard, pkg) || pkg.boards.some(board => board.name === selectedBoard.name));
+
+                // check if one of the packages for the board is already installed. if so, no hint
+                if (packagesForBoard.some(({ installedVersion }) => !!installedVersion)) { return; }
+
+                // filter the installable (not installed) packages,
+                // CLI returns the packages already sorted with the deprecated ones at the end of the list
+                // in order to ensure the new ones are preferred
+                const candidates = packagesForBoard
                     .filter(({ installable, installedVersion }) => installable && !installedVersion);
-                for (const candidate of candidates) {
+
+                const candidate = candidates[0];
+                if (candidate) {
+                    const version = candidate.availableVersions[0] ? `[v ${candidate.availableVersions[0]}]` : '';
                     // tslint:disable-next-line:max-line-length
-                    this.messageService.info(`The \`"${candidate.name}"\` core has to be installed for the currently selected \`"${selectedBoard.name}"\` board. Do you want to install it now?`, 'Install Manually', 'Yes').then(async answer => {
+                    this.messageService.info(`The \`"${candidate.name} ${version}"\` core has to be installed for the currently selected \`"${selectedBoard.name}"\` board. Do you want to install it now?`, 'Install Manually', 'Yes').then(async answer => {
+                        const index = this.notifications.findIndex(board => Board.sameAs(board, selectedBoard));
+                        if (index !== -1) {
+                            this.notifications.splice(index, 1);
+                        }
                         if (answer === 'Yes') {
-                            const dialog = new InstallationProgressDialog(candidate.name, candidate.availableVersions[0]);
-                            dialog.open();
-                            try {
-                                await this.boardsService.install({ item: candidate });
-                            } finally {
-                                dialog.close();
-                            }
+                            await Installable.installWithProgress({
+                                installable: this.boardsService,
+                                item: candidate,
+                                messageService: this.messageService,
+                                responseService: this.responseService,
+                                version: candidate.availableVersions[0]
+                            });
+                            return
                         }
                         if (answer) {
                             this.boardsManagerFrontendContribution.openView({ reveal: true }).then(widget => widget.refresh(candidate.name.toLocaleLowerCase()));

arduino-ide-extension/src/browser/boards/boards-config-dialog.ts

@@ -69,7 +69,7 @@ export class BoardsConfigDialog extends AbstractDialog<BoardsConfig.Config> {
             'Select both a Board and a Port if you want to upload a sketch.',
             'If you only select a Board you will be able just to compile, but not to upload your sketch.'
         ]) {
-            const p = document.createElement('p');
+            const p = document.createElement('div');
             p.textContent = paragraph;
             text.appendChild(p);
         }

arduino-ide-extension/src/browser/boards/boards-config.tsx

@@ -281,6 +281,39 @@ export namespace BoardsConfig {
             return `${name}${port ? ' at ' + Port.toString(port) : ''}`;
         }
 
+        export function setConfig(config: Config | undefined, urlToAttachTo: URL): URL {
+            const copy = new URL(urlToAttachTo.toString());
+            if (!config) {
+                copy.searchParams.delete('boards-config');
+                return copy;
+            }
+
+            const selectedBoard = config.selectedBoard ? { name: config.selectedBoard.name, fqbn: config.selectedBoard.fqbn } : undefined;
+            const selectedPort = config.selectedPort ? { protocol: config.selectedPort.protocol, address: config.selectedPort.address } : undefined;
+            const jsonConfig = JSON.stringify({ selectedBoard, selectedPort });
+            copy.searchParams.set('boards-config', encodeURIComponent(jsonConfig));
+            return copy;
+        }
+
+        export function getConfig(url: URL): Config | undefined {
+            const encoded = url.searchParams.get('boards-config');
+            if (!encoded) {
+                return undefined;
+            }
+            try {
+                const raw = decodeURIComponent(encoded);
+                const candidate = JSON.parse(raw);
+                if (typeof candidate === 'object') {
+                    return candidate;
+                }
+                console.warn(`Expected candidate to be an object. It was ${typeof candidate}. URL was: ${url}`);
+                return undefined;
+            } catch (e) {
+                console.log(`Could not get board config from URL: ${url}.`, e);
+                return undefined;
+            }
+        }
+
     }
 
 }

arduino-ide-extension/src/browser/boards/boards-list-widget.ts

@@ -20,6 +20,7 @@ export class BoardsListWidget extends ListWidget<BoardsPackage> {
             searchable: service,
             installable: service,
             itemLabel: (item: BoardsPackage) => item.name,
+            itemDeprecated: (item: BoardsPackage) => item.deprecated,
             itemRenderer
         });
     }
@@ -33,4 +34,14 @@ export class BoardsListWidget extends ListWidget<BoardsPackage> {
         ]);
     }
 
+    protected async install({ item, progressId, version }: { item: BoardsPackage, progressId: string, version: string; }): Promise<void> {
+        await super.install({ item, progressId, version });
+        this.messageService.info(`Successfully installed platform ${item.name}:${version}`, { timeout: 3000 });
+    }
+
+    protected async uninstall({ item, progressId }: { item: BoardsPackage, progressId: string }): Promise<void> {
+        await super.uninstall({ item, progressId });
+        this.messageService.info(`Successfully uninstalled platform ${item.name}:${item.installedVersion}`, { timeout: 3000 });
+    }
+
 }

arduino-ide-extension/src/browser/boards/boards-service-provider.ts

@@ -1,8 +1,8 @@
 import { injectable, inject } from 'inversify';
 import { Emitter } from '@theia/core/lib/common/event';
 import { ILogger } from '@theia/core/lib/common/logger';
+import { CommandService } from '@theia/core/lib/common/command';
 import { MessageService } from '@theia/core/lib/common/message-service';
-import { StorageService } from '@theia/core/lib/browser/storage-service';
 import { FrontendApplicationContribution } from '@theia/core/lib/browser/frontend-application';
 import { RecursiveRequired } from '../../common/types';
 import {
@@ -16,8 +16,8 @@ import {
 import { BoardsConfig } from './boards-config';
 import { naturalCompare } from '../../common/utils';
 import { NotificationCenter } from '../notification-center';
-import { CommandService } from '@theia/core';
 import { ArduinoCommands } from '../arduino-commands';
+import { StorageWrapper } from '../storage-wrapper';
 
 @injectable()
 export class BoardsServiceProvider implements FrontendApplicationContribution {
@@ -28,8 +28,6 @@ export class BoardsServiceProvider implements FrontendApplicationContribution {
     @inject(MessageService)
     protected messageService: MessageService;
 
-    @inject(StorageService)
-    protected storageService: StorageService;
 
     @inject(BoardsService)
     protected boardsService: BoardsService;
@@ -349,7 +347,7 @@ export class BoardsServiceProvider implements FrontendApplicationContribution {
             return undefined;
         }
         const key = this.getLastSelectedBoardOnPortKey(port);
-        return this.storageService.getData<Board>(key);
+        return this.getData<Board>(key);
     }
 
     protected async saveState(): Promise<void> {
@@ -360,11 +358,11 @@ export class BoardsServiceProvider implements FrontendApplicationContribution {
         const { selectedBoard, selectedPort } = this.boardsConfig;
         if (selectedBoard && selectedPort) {
             const key = this.getLastSelectedBoardOnPortKey(selectedPort);
-            await this.storageService.setData(key, selectedBoard);
+            await this.setData(key, selectedBoard);
         }
         await Promise.all([
-            this.storageService.setData('latest-valid-boards-config', this.latestValidBoardsConfig),
-            this.storageService.setData('latest-boards-config', this.latestBoardsConfig)
+            this.setData('latest-valid-boards-config', this.latestValidBoardsConfig),
+            this.setData('latest-boards-config', this.latestBoardsConfig)
         ]);
     }
 
@@ -374,7 +372,7 @@ export class BoardsServiceProvider implements FrontendApplicationContribution {
     }
 
     protected async loadState(): Promise<void> {
-        const storedLatestValidBoardsConfig = await this.storageService.getData<RecursiveRequired<BoardsConfig.Config>>('latest-valid-boards-config');
+        const storedLatestValidBoardsConfig = await this.getData<RecursiveRequired<BoardsConfig.Config>>('latest-valid-boards-config');
         if (storedLatestValidBoardsConfig) {
             this.latestValidBoardsConfig = storedLatestValidBoardsConfig;
             if (this.canUploadTo(this.latestValidBoardsConfig)) {
@@ -382,13 +380,25 @@ export class BoardsServiceProvider implements FrontendApplicationContribution {
             }
         } else {
             // If we could not restore the latest valid config, try to restore something, the board at least.
-            const storedLatestBoardsConfig = await this.storageService.getData<BoardsConfig.Config | undefined>('latest-boards-config');
+            let storedLatestBoardsConfig = await this.getData<BoardsConfig.Config | undefined>('latest-boards-config');
+            // Try to get from the URL if it was not persisted.
+            if (!storedLatestBoardsConfig) {
+                storedLatestBoardsConfig = BoardsConfig.Config.getConfig(new URL(window.location.href));
+            }
             if (storedLatestBoardsConfig) {
                 this.latestBoardsConfig = storedLatestBoardsConfig;
                 this.boardsConfig = this.latestBoardsConfig;
             }
         }
     }
+
+    private setData<T>(key: string, value: T): Promise<void> {
+        return this.commandService.executeCommand(StorageWrapper.Commands.SET_DATA.id, key, value);
+    }
+
+    private getData<T>(key: string): Promise<T | undefined> {
+        return this.commandService.executeCommand<T>(StorageWrapper.Commands.GET_DATA.id, key);
+    }
 }
 
 /**

arduino-ide-extension/src/browser/contributions/add-zip-library.ts

@@ -1,12 +1,12 @@
 import { inject, injectable } from 'inversify';
 import { remote } from 'electron';
-import { ArduinoMenus } from '../menu/arduino-menus';
-import { SketchContribution, Command, CommandRegistry, MenuModelRegistry } from './contribution';
-import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import URI from '@theia/core/lib/common/uri';
-import { InstallationProgressDialog } from '../widgets/progress-dialog';
-import { LibraryService } from '../../common/protocol';
-import { ConfirmDialog } from '@theia/core/lib/browser';
+import { ConfirmDialog } from '@theia/core/lib/browser/dialogs';
+import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
+import { ArduinoMenus } from '../menu/arduino-menus';
+import { ResponseServiceImpl } from '../response-service-impl';
+import { Installable, LibraryService } from '../../common/protocol';
+import { SketchContribution, Command, CommandRegistry, MenuModelRegistry } from './contribution';
 
 @injectable()
 export class AddZipLibrary extends SketchContribution {
@@ -14,6 +14,9 @@ export class AddZipLibrary extends SketchContribution {
     @inject(EnvVariablesServer)
     protected readonly envVariableServer: EnvVariablesServer;
 
+    @inject(ResponseServiceImpl)
+    protected readonly responseService: ResponseServiceImpl;
+
     @inject(LibraryService)
     protected readonly libraryService: LibraryService;
 
@@ -69,11 +72,14 @@ export class AddZipLibrary extends SketchContribution {
     }
 
     private async doInstall(zipUri: string, overwrite?: boolean): Promise<void> {
-        const dialog = new InstallationProgressDialog('Installing library', 'zip');
         try {
-            this.outputChannelManager.getChannel('Arduino').clear();
-            dialog.open();
-            await this.libraryService.installZip({ zipUri, overwrite });
+            await Installable.doWithProgress({
+                messageService: this.messageService,
+                progressText: `Processing ${new URI(zipUri).path.base}`,
+                responseService: this.responseService,
+                run: () => this.libraryService.installZip({ zipUri, overwrite })
+            });
+            this.messageService.info(`Successfully installed library from ${new URI(zipUri).path.base} archive`, { timeout: 3000 });
         } catch (error) {
             if (error instanceof Error) {
                 const match = error.message.match(/library (.*?) already installed/);
@@ -88,8 +94,6 @@ export class AddZipLibrary extends SketchContribution {
             }
             this.messageService.error(error.toString());
             throw error;
-        } finally {
-            dialog.close();
         }
     }
 

arduino-ide-extension/src/browser/contributions/burn-bootloader.ts

@@ -61,7 +61,7 @@ export class BurnBootloader extends SketchContribution {
                 verify,
                 verbose
             });
-            this.messageService.info('Done burning bootloader.', { timeout: 1000 });
+            this.messageService.info('Done burning bootloader.', { timeout: 3000 });
         } catch (e) {
             this.messageService.error(e.toString());
         } finally {

arduino-ide-extension/src/browser/contributions/examples.ts

@@ -1,5 +1,6 @@
 import * as PQueue from 'p-queue';
 import { inject, injectable, postConstruct } from 'inversify';
+import { CommandHandler } from '@theia/core/lib/common/command';
 import { MenuPath, CompositeMenuNode, SubMenuOptions } from '@theia/core/lib/common/menu';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { OpenSketch } from './open-sketch';
@@ -93,12 +94,7 @@ export abstract class Examples extends SketchContribution {
                 const { uri } = sketch;
                 const commandId = `arduino-open-example-${submenuPath.join(':')}--${uri}`;
                 const command = { id: commandId };
-                const handler = {
-                    execute: async () => {
-                        const sketch = await this.sketchService.cloneExample(uri);
-                        this.commandService.executeCommand(OpenSketch.Commands.OPEN_SKETCH.id, sketch);
-                    }
-                };
+                const handler = this.createHandler(uri);
                 pushToDispose.push(this.commandRegistry.registerCommand(command, handler));
                 this.menuRegistry.registerMenuAction(submenuPath, { commandId, label: sketch.name, order: sketch.name.toLocaleLowerCase() });
                 pushToDispose.push(Disposable.create(() => this.menuRegistry.unregisterMenuAction(command)));
@@ -106,6 +102,15 @@ export abstract class Examples extends SketchContribution {
         }
     }
 
+    protected createHandler(uri: string): CommandHandler {
+        return {
+            execute: async () => {
+                const sketch = await this.sketchService.cloneExample(uri);
+                return this.commandService.executeCommand(OpenSketch.Commands.OPEN_SKETCH.id, sketch);
+            }
+        }
+    }
+
 }
 
 @injectable()
@@ -154,15 +159,14 @@ export class LibraryExamples extends Examples {
     protected async register(board: Board | undefined = this.boardsServiceClient.boardsConfig.selectedBoard): Promise<void> {
         return this.queue.add(async () => {
             this.toDispose.dispose();
-            if (!board || !board.fqbn) {
-                return;
-            }
-            const { fqbn, name } = board;
+            const fqbn = board?.fqbn;
+            const name = board?.name;
+            // Shows all examples when no board is selected, or the platform of the currently selected board is not installed.
             const { user, current, any } = await this.examplesService.installed({ fqbn });
             if (user.length) {
                 (user as any).unshift('Examples from Custom Libraries');
             }
-            if (current.length) {
+            if (name && fqbn && current.length) {
                 (current as any).unshift(`Examples for ${name}`);
             }
             if (any.length) {

arduino-ide-extension/src/browser/contributions/include-library.ts

@@ -74,10 +74,9 @@ export class IncludeLibrary extends SketchContribution {
             this.mainMenuManager.update();
             const libraries: LibraryPackage[] = []
             const fqbn = this.boardsServiceClient.boardsConfig.selectedBoard?.fqbn;
-            // Do not show board specific examples, when no board is selected.
-            if (fqbn) {
-                libraries.push(...await this.libraryService.list({ fqbn }));
-            }
+            // Show all libraries, when no board is selected.
+            // Otherwise, show libraries only for the selected board.
+            libraries.push(...await this.libraryService.list({ fqbn }));
 
             const includeLibMenuPath = [...ArduinoMenus.SKETCH__UTILS_GROUP, '0_include'];
             // `Add .ZIP Library...`

arduino-ide-extension/src/browser/contributions/settings.ts

@@ -33,11 +33,12 @@ export class Settings extends SketchContribution {
     }
 
     registerMenus(registry: MenuModelRegistry): void {
-        registry.registerMenuAction(ArduinoMenus.FILE__SETTINGS_GROUP, {
+        registry.registerMenuAction(ArduinoMenus.FILE__PREFERENCES_GROUP, {
             commandId: Settings.Commands.OPEN.id,
             label: 'Preferences...',
             order: '0'
         });
+        registry.registerSubmenu(ArduinoMenus.FILE__ADVANCED_SUBMENU, 'Advanced');
     }
 
     registerKeybindings(registry: KeybindingRegistry): void {

arduino-ide-extension/src/browser/contributions/sketchbook.ts

@@ -1,10 +1,12 @@
 import { inject, injectable } from 'inversify';
+import { CommandHandler } from '@theia/core/lib/common/command';
 import { CommandRegistry, MenuModelRegistry } from './contribution';
 import { ArduinoMenus } from '../menu/arduino-menus';
 import { MainMenuManager } from '../../common/main-menu-manager';
 import { NotificationCenter } from '../notification-center';
 import { Examples } from './examples';
 import { SketchContainer } from '../../common/protocol';
+import { OpenSketch } from './open-sketch';
 
 @injectable()
 export class Sketchbook extends Examples {
@@ -43,4 +45,13 @@ export class Sketchbook extends Examples {
         this.registerRecursively([...container.children, ...container.sketches], ArduinoMenus.FILE__SKETCHBOOK_SUBMENU, this.toDispose);
     }
 
+    protected createHandler(uri: string): CommandHandler {
+        return {
+            execute: async () => {
+                const sketch = await this.sketchService.loadSketch(uri);
+                return this.commandService.executeCommand(OpenSketch.Commands.OPEN_SKETCH.id, sketch);
+            }
+        }
+    }
+
 }

arduino-ide-extension/src/browser/contributions/upload-sketch.ts

@@ -148,7 +148,7 @@ export class UploadSketch extends SketchContribution {
             } else {
                 await this.coreService.upload(options);
             }
-            this.messageService.info('Done uploading.', { timeout: 1000 });
+            this.messageService.info('Done uploading.', { timeout: 3000 });
         } catch (e) {
             this.messageService.error(e.toString());
         } finally {

arduino-ide-extension/src/browser/contributions/verify-sketch.ts

@@ -109,7 +109,7 @@ export class VerifySketch extends SketchContribution {
                 sourceOverride,
                 compilerWarnings
             });
-            this.messageService.info('Done compiling.', { timeout: 1000 });
+            this.messageService.info('Done compiling.', { timeout: 3000 });
         } catch (e) {
             this.messageService.error(e.toString());
         } finally {

arduino-ide-extension/src/browser/data/arduino.color-theme.json

@@ -28,7 +28,8 @@
       "scope": [
         "meta.function.c",
         "entity.name.function",
-        "meta.function-call.c"
+        "meta.function-call.c",
+        "variable.other"
       ],
       "settings": {
         "foreground": "#D35400"
@@ -42,16 +43,19 @@
         "meta.block.c",
         "meta.function.c",
         "entity.name.function.preprocessor.c",
-        "meta.preprocessor.macro.c"
+        "meta.preprocessor.macro.c",
+        "variable",
+        "variable.name"
       ],
       "settings": {
         "foreground": "#434f54"
       }
     },
     {
-      "name": "strings",
+      "name": "constants",
       "scope": [
-        "string.quoted.double"
+        "string.quoted.double",
+        "constant"
       ],
       "settings": {
         "foreground": "#005C5F"
@@ -82,6 +86,7 @@
   "colors": {
     "list.highlightForeground": "#005c5f",
     "list.activeSelectionBackground": "#005c5f",
+    "progressBar.background": "#005c5f",
     "editor.background": "#ffffff",
     "editorCursor.foreground": "#434f54",
     "editor.foreground": "#434f54",

arduino-ide-extension/src/browser/library/library-list-widget.ts

@@ -24,6 +24,7 @@ export class LibraryListWidget extends ListWidget<LibraryPackage> {
             searchable: service,
             installable: service,
             itemLabel: (item: LibraryPackage) => item.name,
+            itemDeprecated: (item: LibraryPackage) => item.deprecated,
             itemRenderer
         });
     }
@@ -37,7 +38,7 @@ export class LibraryListWidget extends ListWidget<LibraryPackage> {
         ]);
     }
 
-    protected async install({ item, version }: { item: LibraryPackage, version: Installable.Version }): Promise<void> {
+    protected async install({ item, progressId, version }: { item: LibraryPackage, progressId: string, version: Installable.Version }): Promise<void> {
         const dependencies = await this.service.listDependencies({ item, version, filterSelf: true });
         let installDependencies: boolean | undefined = undefined;
         if (dependencies.length) {
@@ -84,10 +85,16 @@ export class LibraryListWidget extends ListWidget<LibraryPackage> {
         }
 
         if (typeof installDependencies === 'boolean') {
-            return this.service.install({ item, version, installDependencies });
+            await this.service.install({ item, version, progressId, installDependencies });
+            this.messageService.info(`Successfully installed library ${item.name}:${version}`, { timeout: 3000 });
         }
     }
 
+    protected async uninstall({ item, progressId }: { item: LibraryPackage, progressId: string }): Promise<void> {
+        await super.uninstall({ item, progressId });
+        this.messageService.info(`Successfully uninstalled library ${item.name}:${item.installedVersion}`, { timeout: 3000 });
+    }
+
 }
 
 class MessageBoxDialog extends AbstractDialog<MessageBoxDialog.Result> {

arduino-ide-extension/src/browser/menu/arduino-menus.ts

@@ -8,8 +8,12 @@ export namespace ArduinoMenus {
     // -- File
     export const FILE__SKETCH_GROUP = [...CommonMenus.FILE, '0_sketch'];
     export const FILE__PRINT_GROUP = [...CommonMenus.FILE, '1_print'];
-    // XXX: on macOS, the settings group is not under `File`
-    export const FILE__SETTINGS_GROUP = [...(isOSX ? MAIN_MENU_BAR : CommonMenus.FILE), '2_settings'];
+    // XXX: on macOS, the "Preferences" and "Advanced" group is not under `File`
+    // The empty path ensures no top level menu is created for the preferences, even if they contains sub menus
+    export const FILE__PREFERENCES_GROUP = [...(isOSX ? [''] : CommonMenus.FILE), '2_preferences'];
+    export const FILE__ADVANCED_GROUP = [...(isOSX ? [''] : CommonMenus.FILE), '3_advanced'];
+    export const FILE__ADVANCED_SUBMENU = [...FILE__ADVANCED_GROUP, '0_advanced_sub'];
+
     export const FILE__QUIT_GROUP = [...CommonMenus.FILE, '3_quit'];
 
     // -- File / Open Recent

arduino-ide-extension/src/browser/output-service-impl.ts

@@ -1,22 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { OutputContribution } from '@theia/output/lib/browser/output-contribution';
-import { OutputChannelManager } from '@theia/output/lib/common/output-channel';
-import { OutputService, OutputMessage } from '../common/protocol/output-service';
-
-@injectable()
-export class OutputServiceImpl implements OutputService {
-
-    @inject(OutputContribution)
-    protected outputContribution: OutputContribution;
-
-    @inject(OutputChannelManager)
-    protected outputChannelManager: OutputChannelManager;
-
-    append(message: OutputMessage): void {
-        const { chunk } = message;
-        const channel = this.outputChannelManager.getChannel('Arduino');
-        channel.show({ preserveFocus: true });
-        channel.append(chunk);
-    }
-
-}

arduino-ide-extension/src/browser/response-service-impl.ts

@@ -0,0 +1,34 @@
+import { inject, injectable } from 'inversify';
+import { Emitter } from '@theia/core/lib/common/event';
+import { OutputContribution } from '@theia/output/lib/browser/output-contribution';
+import { OutputChannelManager } from '@theia/output/lib/common/output-channel';
+import { ResponseService, OutputMessage, ProgressMessage } from '../common/protocol/response-service';
+
+@injectable()
+export class ResponseServiceImpl implements ResponseService {
+
+    @inject(OutputContribution)
+    protected outputContribution: OutputContribution;
+
+    @inject(OutputChannelManager)
+    protected outputChannelManager: OutputChannelManager;
+
+    protected readonly progressDidChangeEmitter = new Emitter<ProgressMessage>();
+    readonly onProgressDidChange = this.progressDidChangeEmitter.event;
+
+    appendToOutput(message: OutputMessage): void {
+        const { chunk } = message;
+        const channel = this.outputChannelManager.getChannel('Arduino');
+        channel.show({ preserveFocus: true });
+        channel.append(chunk);
+    }
+
+    clearArduinoChannel(): void {
+        this.outputChannelManager.getChannel('Arduino').clear();
+    }
+
+    reportProgress(progress: ProgressMessage): void {
+        this.progressDidChangeEmitter.fire(progress);
+    }
+
+}

arduino-ide-extension/src/browser/settings.tsx

@@ -24,7 +24,7 @@ export interface Settings extends Index {
     editorFontSize: number; // `editor.fontSize`
     themeId: string; // `workbench.colorTheme`
     autoSave: 'on' | 'off'; // `editor.autoSave`
-    quickSuggestions: Record<'other'|'comments'|'strings', boolean>; // `editor.quickSuggestions`
+    quickSuggestions: Record<'other' | 'comments' | 'strings', boolean>; // `editor.quickSuggestions`
 
     autoScaleInterface: boolean; // `arduino.window.autoScale`
     interfaceScale: number; // `arduino.window.zoomLevel` https://github.com/eclipse-theia/theia/issues/8751
@@ -100,9 +100,9 @@ export class SettingsService {
             this.preferenceService.get<string>('workbench.colorTheme', 'arduino-theme'),
             this.preferenceService.get<'on' | 'off'>('editor.autoSave', 'on'),
             this.preferenceService.get<object>('editor.quickSuggestion', {
-              'other': false,
-              'comments': false,
-              'strings': false
+                'other': false,
+                'comments': false,
+                'strings': false
             }),
             this.preferenceService.get<boolean>('arduino.window.autoScale', true),
             this.preferenceService.get<number>('arduino.window.zoomLevel', 0),
@@ -507,7 +507,7 @@ export class SettingsComponent extends React.Component<SettingsComponent.Props,
     protected browseSketchbookDidClick = async () => {
         const uri = await this.props.fileDialogService.showOpenDialog({
             title: 'Select new sketchbook location',
-            openLabel: 'Chose',
+            openLabel: 'Choose',
             canSelectFiles: false,
             canSelectMany: false,
             canSelectFolders: true
@@ -569,18 +569,18 @@ export class SettingsComponent extends React.Component<SettingsComponent.Props,
     };
 
     protected quickSuggestionsOtherDidChange = (event: React.ChangeEvent<HTMLInputElement>) => {
-      
-      // need to persist react events through lifecycle https://reactjs.org/docs/events.html#event-pooling
-      const newVal = event.target.checked ? true : false
-      
-      this.setState(prevState => {
-        return {
-          quickSuggestions: {
-            ...prevState.quickSuggestions,
-            other: newVal
-          }
-        }
-      });
+
+        // need to persist react events through lifecycle https://reactjs.org/docs/events.html#event-pooling
+        const newVal = event.target.checked ? true : false
+
+        this.setState(prevState => {
+            return {
+                quickSuggestions: {
+                    ...prevState.quickSuggestions,
+                    other: newVal
+                }
+            }
+        });
     };
 
     protected themeDidChange = (event: React.ChangeEvent<HTMLSelectElement>) => {
@@ -777,6 +777,11 @@ export class SettingsDialog extends AbstractDialog<Promise<Settings>> {
 
     protected onActivateRequest(msg: Message): void {
         super.onActivateRequest(msg);
+
+        // calling settingsService.reset() in order to reload the settings from the preferenceService
+        // and update the UI including changes triggerd from the command palette
+        this.settingsService.reset();
+
         this.widget.activate();
     }
 
@@ -823,7 +828,7 @@ export class AdditionalUrlsDialog extends AbstractDialog<string[]> {
     }
 
     get value(): string[] {
-        return this.textArea.value.split('\n').map(url => url.trim());
+        return this.textArea.value.split('\n').map(url => url.trim()).filter(url => !!url);
     }
 
     protected onAfterAttach(message: Message): void {

arduino-ide-extension/src/browser/storage-wrapper.ts

@@ -0,0 +1,33 @@
+import { injectable, inject } from 'inversify';
+import { StorageService } from '@theia/core/lib/browser/storage-service';
+import { Command, CommandContribution, CommandRegistry } from '@theia/core/lib/common/command';
+
+/**
+ * This is a workaround to break cycles in the dependency injection. Provides commands for `setData` and `getData`.
+ */
+@injectable()
+export class StorageWrapper implements CommandContribution {
+
+    @inject(StorageService)
+    protected storageService: StorageService;
+
+    registerCommands(commands: CommandRegistry): void {
+        commands.registerCommand(StorageWrapper.Commands.GET_DATA, {
+            execute: (key: string, defaultValue?: any) => this.storageService.getData(key, defaultValue)
+        });
+        commands.registerCommand(StorageWrapper.Commands.SET_DATA, {
+            execute: (key: string, value: any) => this.storageService.setData(key, value)
+        });
+    }
+
+}
+export namespace StorageWrapper {
+    export namespace Commands {
+        export const SET_DATA: Command = {
+            id: 'arduino-store-wrapper-set'
+        };
+        export const GET_DATA: Command = {
+            id: 'arduino-store-wrapper-get'
+        };
+    }
+}

arduino-ide-extension/src/browser/style/boards-config-dialog.css

@@ -1,5 +1,5 @@
 div#select-board-dialog {
-    margin: 5px 20px 50px 20px;
+    margin: 5px;
 }
 
 div#select-board-dialog .selectBoardContainer .body {
@@ -7,8 +7,8 @@ div#select-board-dialog .selectBoardContainer .body {
     overflow: hidden;
 }
 
-div.dialogContent.select-board-dialog > div.head {
-    padding-left: 21px;
+.select-board-dialog .head {
+    margin: 5px;
 }
 
 div.dialogContent.select-board-dialog > div.head .title {
@@ -16,11 +16,7 @@ div.dialogContent.select-board-dialog > div.head .title {
     letter-spacing: .02em;
     font-size: 1.2em;
     color: var(--theia-arduino-branding-primary);
-    margin: 17px 0;
-}
-
-div#select-board-dialog .selectBoardContainer .head .text {
-    margin-bottom: 21px;
+    margin-bottom: 10px;
 }
 
 div#select-board-dialog .selectBoardContainer .body .list .item.selected {
@@ -57,6 +53,8 @@ div#select-board-dialog .selectBoardContainer .body .list .item.selected i {
 #select-board-dialog .selectBoardContainer .body .container {
     flex: 1;
     padding: 0px 10px 0px 0px;
+    min-width: 240px;
+    max-width: 240px;
 }
 
 #select-board-dialog .selectBoardContainer .body .left.container .content {
@@ -82,15 +80,17 @@ div#select-board-dialog .selectBoardContainer .body .list .item.selected i {
     color: var(--theia-arduino-branding-secondary);
     padding: 10px 5px 10px 10px;
     text-transform: uppercase;
-    /* The max, min-height comes from `.body .list` 265px + 47px top padding - 2 * 10px top padding */
-    max-height: 292px;
-    min-height: 292px;
+    /* The max, min-height comes from `.body .list` 200px + 47px top padding - 2 * 10px top padding */
+    max-height: 227px;
+    min-height: 227px;
 }
 
 #select-board-dialog .selectBoardContainer .body .list .item {
     padding: 10px 5px 10px 10px;
     display: flex;
     justify-content: end;
+    white-space: nowrap;
+    overflow-x: hidden;
 }
 
 #select-board-dialog .selectBoardContainer .body .list .item .selected-icon {
@@ -114,9 +114,17 @@ div#select-board-dialog .selectBoardContainer .body .list .item.selected i {
     background: var(--theia-secondaryButton-hoverBackground);
 }
 
+#select-board-dialog .selectBoardContainer .body .list .label {
+    max-width: 215px;
+    width: 215px;
+    white-space: pre;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
 #select-board-dialog .selectBoardContainer .body .list {
-    max-height: 265px;
-    min-height: 265px;
+    max-height: 200px;
+    min-height: 200px;
     overflow-y: auto;
 }
 
@@ -132,14 +140,8 @@ div#select-board-dialog .selectBoardContainer .body .list .item.selected i {
 }
 
 .p-Widget.dialogOverlay .dialogContent.select-board-dialog {
-    width: 740px;
+    width: 500px;
 }
-
-
-.dialogControl {
-    margin: 0 20px 30px 0;
-}
-
 .arduino-boards-toolbar-item-container {
     margin-left: 3px;
 }

arduino-ide-extension/src/browser/style/debug.css

@@ -0,0 +1,36 @@
+/* TODO: remove after https://github.com/eclipse-theia/theia/pull/9256/ */
+
+/* To fix colors in Theia. */
+.theia-debug-hover-title.number,
+.theia-debug-console-variable.number {
+    color: var(--theia-variable-number-variable-color);
+}
+.theia-debug-hover-title.boolean,
+.theia-debug-console-variable.boolean {
+    color: var(--theia-variable-boolean-variable-color);
+}
+.theia-debug-hover-title.string,
+.theia-debug-console-variable.string {
+    color: var(--theia-variable-string-variable-color);
+}
+
+/* To unset the default debug hover dimension. */
+.theia-debug-hover {
+    min-width: unset;
+    min-height: unset;
+    width: unset;
+    height: unset;
+}
+
+/* To adjust the left padding in the hover title. */
+.theia-debug-hover-title {
+    padding-left: 5px;
+}
+
+/* Use the default Theia dimensions only iff the expression is complex (`!!expression.hasChildren~) */
+.theia-debug-hover.complex-value {
+    min-width: 324px;
+    min-height: 324px;
+    width: 324px;
+    height: 324px;
+}

arduino-ide-extension/src/browser/style/index.css

@@ -7,6 +7,7 @@
 @import './terminal.css';
 @import './editor.css';
 @import './settings-dialog.css';
+@import './debug.css';
 
 .theia-input.warning:focus {
     outline-width: 1px;
@@ -66,3 +67,20 @@ button.theia-button.secondary {
 button.theia-button.main {
     color: var(--theia-button-foreground);
 }
+
+/* To make the progress-bar slightly thicker, and use the color from the status bar */
+.theia-progress-bar-container {
+    width: 100%;
+    height: 4px;
+}
+
+.theia-progress-bar {
+    height: 4px;
+    width: 3%;
+    animation: progress-animation 1.3s 0s infinite cubic-bezier(0.645, 0.045, 0.355, 1);
+}
+
+.theia-notification-item-progressbar {
+    height: 4px;
+    width: 66%;
+}

arduino-ide-extension/src/browser/style/main.css

@@ -175,7 +175,6 @@
 
 #arduino-open-sketch-control--toolbar--container {
     background-color: var(--theia-arduino-toolbar-background);
-    padding: 8px 8px 8px 8px; /* based on pure heuristics */
 }
 
 #arduino-open-sketch-control--toolbar {
@@ -183,6 +182,7 @@
     width: unset;
     line-height: unset;
     color: var(--theia-titleBar-activeBackground);
+    padding: 5px 8px; /* based on pure heuristics */
 }
 
 /* Output */

arduino-ide-extension/src/browser/theia/debug/debug-editor-model.ts

@@ -0,0 +1,84 @@
+import debounce from 'p-debounce';
+import { inject, injectable, postConstruct, interfaces, Container } from 'inversify';
+import URI from '@theia/core/lib/common/uri';
+import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
+import { MonacoConfigurationService } from '@theia/monaco/lib/browser/monaco-frontend-module';
+import { INLINE_VALUE_DECORATION_KEY } from '@theia/debug/lib/browser/editor//debug-inline-value-decorator';
+import { DebugEditor } from '@theia/debug/lib/browser/editor/debug-editor';
+import { DebugExceptionWidget } from '@theia/debug/lib/browser/editor/debug-exception-widget';
+import { DebugBreakpointWidget } from '@theia/debug/lib/browser/editor/debug-breakpoint-widget';
+import { DebugEditorModel as TheiaDebugEditorModel } from '@theia/debug/lib/browser/editor/debug-editor-model';
+import { createDebugHoverWidgetContainer } from './debug-hover-widget'
+
+// TODO: Remove after https://github.com/eclipse-theia/theia/pull/9256/
+@injectable()
+export class DebugEditorModel extends TheiaDebugEditorModel {
+
+    static createContainer(parent: interfaces.Container, editor: DebugEditor): Container {
+        const child = createDebugHoverWidgetContainer(parent, editor);
+        child.bind(DebugEditorModel).toSelf();
+        child.bind(DebugBreakpointWidget).toSelf();
+        child.bind(DebugExceptionWidget).toSelf();
+        return child;
+    }
+
+    static createModel(parent: interfaces.Container, editor: DebugEditor): DebugEditorModel {
+        return DebugEditorModel.createContainer(parent, editor).get(DebugEditorModel);
+    }
+
+    @inject(MonacoConfigurationService)
+    readonly configurationService: monaco.services.IConfigurationService;
+
+    protected readonly toDisposeOnRenderFrames = new DisposableCollection();
+
+    @postConstruct()
+    protected init(): void {
+        this.toDispose.push(this.toDisposeOnRenderFrames);
+        super.init();
+    }
+
+    protected async updateEditorHover(): Promise<void> {
+        if (this.isCurrentEditorFrame(this.uri)) {
+            const codeEditor = this.editor.getControl();
+            codeEditor.updateOptions({ hover: { enabled: false } });
+            this.toDisposeOnRenderFrames.push(Disposable.create(() => {
+                const model = codeEditor.getModel()!;
+                const overrides = {
+                    resource: model.uri,
+                    overrideIdentifier: (model as any).getLanguageIdentifier().language,
+                };
+                const { enabled, delay, sticky } = this.configurationService._configuration.getValue('editor.hover', overrides, undefined);
+                codeEditor.updateOptions({
+                    hover: {
+                        enabled,
+                        delay,
+                        sticky
+                    }
+                });
+            }));
+        }
+    }
+
+    private isCurrentEditorFrame(uri: URI): boolean {
+        return this.sessions.currentFrame?.source?.uri.toString() === uri.toString();
+    }
+
+    protected readonly renderFrames = debounce(async () => {
+        if (this.toDispose.disposed) {
+            return;
+        }
+        this.toDisposeOnRenderFrames.dispose();
+
+        this.toggleExceptionWidget();
+        const [newFrameDecorations, inlineValueDecorations] = await Promise.all([
+            this.createFrameDecorations(),
+            this.createInlineValueDecorations()
+        ]);
+        const codeEditor = this.editor.getControl();
+        codeEditor.removeDecorations(INLINE_VALUE_DECORATION_KEY);
+        codeEditor.setDecorations(INLINE_VALUE_DECORATION_KEY, inlineValueDecorations);
+        this.frameDecorations = this.deltaDecorations(this.frameDecorations, newFrameDecorations);
+        this.updateEditorHover();
+    }, 100);
+
+}

arduino-ide-extension/src/browser/theia/debug/debug-hover-source.ts

@@ -0,0 +1,18 @@
+import { injectable } from 'inversify';
+import { ExpressionItem, DebugVariable } from '@theia/debug/lib/browser/console/debug-console-items';
+import { DebugHoverSource as TheiaDebugHoverSource } from '@theia/debug/lib/browser/editor/debug-hover-source';
+
+// TODO: remove after https://github.com/eclipse-theia/theia/pull/9256/.
+@injectable()
+export class DebugHoverSource extends TheiaDebugHoverSource {
+
+    async evaluate2(expression: string): Promise<ExpressionItem | DebugVariable | undefined> {
+        const evaluated = await this.doEvaluate(expression);
+        const elements = evaluated && await evaluated.getElements();
+        this._expression = evaluated;
+        this.elements = elements ? [...elements] : [];
+        this.fireDidChange();
+        return evaluated;
+    }
+
+}

arduino-ide-extension/src/browser/theia/debug/debug-hover-widget.ts

@@ -0,0 +1,96 @@
+import { injectable, interfaces, Container } from 'inversify';
+import { Widget } from '@phosphor/widgets';
+import { SourceTreeWidget } from '@theia/core/lib/browser/source-tree';
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
+import { DebugEditor } from '@theia/debug/lib/browser/editor/debug-editor';
+import { DebugVariable } from '@theia/debug/lib/browser/console/debug-console-items';
+import { DebugExpressionProvider } from '@theia/debug/lib/browser/editor/debug-expression-provider';
+import { DebugHoverSource as TheiaDebugHoverSource } from '@theia/debug/lib/browser/editor/debug-hover-source';
+import { DebugHoverWidget as TheiaDebugHoverWidget, ShowDebugHoverOptions } from '@theia/debug/lib/browser/editor/debug-hover-widget';
+import { DebugHoverSource } from './debug-hover-source';
+
+export function createDebugHoverWidgetContainer(parent: interfaces.Container, editor: DebugEditor): Container {
+    const child = SourceTreeWidget.createContainer(parent, {
+        virtualized: false
+    });
+    child.bind(DebugEditor).toConstantValue(editor);
+    child.bind(TheiaDebugHoverSource).toSelf();
+    child.bind(DebugHoverSource).toSelf();
+    child.rebind(TheiaDebugHoverSource).to(DebugHoverSource);
+    child.unbind(SourceTreeWidget);
+    child.bind(DebugExpressionProvider).toSelf();
+    child.bind(TheiaDebugHoverWidget).toSelf();
+    child.bind(DebugHoverWidget).toSelf();
+    child.rebind(TheiaDebugHoverWidget).to(DebugHoverWidget);
+    return child;
+}
+
+// TODO: remove patch after https://github.com/eclipse-theia/theia/pull/9256/
+@injectable()
+export class DebugHoverWidget extends TheiaDebugHoverWidget {
+
+    protected async doShow(options: ShowDebugHoverOptions | undefined = this.options): Promise<void> {
+        if (!this.isEditorFrame()) {
+            this.hide();
+            return;
+        }
+        if (!options) {
+            this.hide();
+            return;
+        }
+        if (this.options && this.options.selection.equalsRange(options.selection)) {
+            return;
+        }
+        if (!this.isAttached) {
+            Widget.attach(this, this.contentNode);
+        }
+
+        this.options = options;
+        const matchingExpression = this.expressionProvider.get(this.editor.getControl().getModel()!, options.selection);
+        if (!matchingExpression) {
+            this.hide();
+            return;
+        }
+        const toFocus = new DisposableCollection();
+        if (this.options.focus === true) {
+            toFocus.push(this.model.onNodeRefreshed(() => {
+                toFocus.dispose();
+                this.activate();
+            }));
+        }
+        const expression = await (this.hoverSource as DebugHoverSource).evaluate2(matchingExpression);
+        if (!expression || !expression.value) {
+            toFocus.dispose();
+            this.hide();
+            return;
+        }
+
+        this.contentNode.hidden = false;
+        ['number', 'boolean', 'string'].forEach(token => this.titleNode.classList.remove(token));
+        this.domNode.classList.remove('complex-value');
+        if (expression.hasElements) {
+            this.domNode.classList.add('complex-value');
+        } else {
+            this.contentNode.hidden = true;
+            if (expression.type === 'number' || expression.type === 'boolean' || expression.type === 'string') {
+                this.titleNode.classList.add(expression.type);
+            } else if (!isNaN(+expression.value)) {
+                this.titleNode.classList.add('number');
+            } else if (DebugVariable.booleanRegex.test(expression.value)) {
+                this.titleNode.classList.add('boolean');
+            } else if (DebugVariable.stringRegex.test(expression.value)) {
+                this.titleNode.classList.add('string');
+            }
+        }
+
+        // super.show(); // Here we cannot call `super.show()` but have to call `show` on the `Widget` prototype.
+        Widget.prototype.show.call(this);
+        await new Promise<void>(resolve => {
+            setTimeout(() => window.requestAnimationFrame(() => {
+                this.editor.getControl().layoutContentWidget(this);
+                resolve();
+            }), 0);
+        });
+    }
+
+}

arduino-ide-extension/src/browser/theia/editor/editor-manager.ts

@@ -1,31 +0,0 @@
-import { inject, injectable } from 'inversify';
-import URI from '@theia/core/lib/common/uri';
-import { EditorManager as TheiaEditorManager, EditorOpenerOptions } from '@theia/editor/lib/browser/editor-manager';
-import { ConfigService } from '../../../common/protocol/config-service';
-import { EditorWidget } from '@theia/editor/lib/browser';
-import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
-
-@injectable()
-export class EditorManager extends TheiaEditorManager {
-
-    @inject(ConfigService)
-    protected readonly configService: ConfigService;
-
-    async open(uri: URI, options?: EditorOpenerOptions): Promise<EditorWidget> {
-        const [widget, readOnly] = await Promise.all([super.open(uri, options), this.isReadOnly(uri)]);
-        if (readOnly) {
-            const { editor } = widget;
-            if (editor instanceof MonacoEditor) {
-                const codeEditor = editor.getControl();
-                codeEditor.updateOptions({ readOnly });
-            }
-        }
-        return widget;
-    }
-
-    protected async isReadOnly(uri: URI): Promise<boolean> {
-        const config = await this.configService.getConfiguration();
-        return new URI(config.dataDirUri).isEqualOrParent(uri)
-    }
-
-}

arduino-ide-extension/src/browser/theia/keymaps/keymaps-frontend-contribution.ts

@@ -0,0 +1,16 @@
+import { injectable } from 'inversify';
+import { MenuModelRegistry } from '@theia/core';
+import { KeymapsFrontendContribution as TheiaKeymapsFrontendContribution, KeymapsCommands } from '@theia/keymaps/lib/browser/keymaps-frontend-contribution';
+import { ArduinoMenus } from '../../menu/arduino-menus';
+
+@injectable()
+export class KeymapsFrontendContribution extends TheiaKeymapsFrontendContribution {
+
+    registerMenus(menus: MenuModelRegistry): void {
+        menus.registerMenuAction(ArduinoMenus.FILE__ADVANCED_SUBMENU, {
+            commandId: KeymapsCommands.OPEN_KEYMAPS.id,
+            label: 'Keyboard Shortcuts',
+            order: '1'
+        });
+    }
+}

arduino-ide-extension/src/browser/theia/messages/notification-center-component.tsx

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import { NotificationComponent } from './notification-component';
+import { NotificationCenterComponent as TheiaNotificationCenterComponent } from '@theia/messages/lib/browser/notification-center-component'
+
+const PerfectScrollbar = require('react-perfect-scrollbar');
+
+export class NotificationCenterComponent extends TheiaNotificationCenterComponent {
+
+    render(): React.ReactNode {
+        const empty = this.state.notifications.length === 0;
+        const title = empty ? 'NO NEW NOTIFICATIONS' : 'NOTIFICATIONS';
+        return (
+            <div className={`theia-notifications-container theia-notification-center ${this.state.visibilityState === 'center' ? 'open' : 'closed'}`}>
+                <div className='theia-notification-center-header'>
+                    <div className='theia-notification-center-header-title'>{title}</div>
+                    <div className='theia-notification-center-header-actions'>
+                        <ul className='theia-notification-actions'>
+                            <li className='collapse' title='Hide Notification Center' onClick={this.onHide} />
+                            <li className='clear-all' title='Clear All' onClick={this.onClearAll} />
+                        </ul>
+                    </div>
+                </div>
+                <PerfectScrollbar className='theia-notification-list-scroll-container'>
+                    <div className='theia-notification-list'>
+                        {this.state.notifications.map(notification =>
+                            <NotificationComponent key={notification.messageId} notification={notification} manager={this.props.manager} />
+                        )}
+                    </div>
+                </PerfectScrollbar>
+            </div>
+        );
+    }
+
+}

arduino-ide-extension/src/browser/theia/messages/notification-component.tsx

@@ -0,0 +1,62 @@
+import * as React from 'react';
+import { NotificationComponent as TheiaNotificationComponent } from '@theia/messages/lib/browser/notification-component'
+
+export class NotificationComponent extends TheiaNotificationComponent {
+
+    render(): React.ReactNode {
+        const { messageId, message, type, collapsed, expandable, source, actions } = this.props.notification;
+        return (<div key={messageId} className='theia-notification-list-item'>
+            <div className={`theia-notification-list-item-content ${collapsed ? 'collapsed' : ''}`}>
+                <div className='theia-notification-list-item-content-main'>
+                    <div className={`theia-notification-icon theia-notification-icon-${type}`} />
+                    <div className='theia-notification-message'>
+                        <span dangerouslySetInnerHTML={{ __html: message }} onClick={this.onMessageClick} />
+                    </div>
+                    <ul className='theia-notification-actions'>
+                        {expandable && (
+                            <li className={collapsed ? 'expand' : 'collapse'} title={collapsed ? 'Expand' : 'Collapse'}
+                                data-message-id={messageId} onClick={this.onToggleExpansion} />
+                        )}
+                        {!this.isProgress && (<li className='clear' title='Clear' data-message-id={messageId} onClick={this.onClear} />)}
+                    </ul>
+                </div>
+                {(source || !!actions.length) && (
+                    <div className='theia-notification-list-item-content-bottom'>
+                        <div className='theia-notification-source'>
+                            {source && (<span>{source}</span>)}
+                        </div>
+                        <div className='theia-notification-buttons'>
+                            {actions && actions.map((action, index) => (
+                                <button key={messageId + `-action-${index}`} className='theia-button'
+                                    data-message-id={messageId} data-action={action}
+                                    onClick={this.onAction}>
+                                    {action}
+                                </button>
+                            ))}
+                        </div>
+                    </div>
+                )}
+            </div>
+            {this.renderProgressBar()}
+        </div>);
+    }
+
+    private renderProgressBar(): React.ReactNode {
+        if (!this.isProgress) {
+            return undefined;
+        }
+        if (!Number.isNaN(this.props.notification.progress)) {
+            return <div className='theia-notification-item-progress'>
+                <div className='theia-notification-item-progressbar' style={{ width: `${this.props.notification.progress}%` }} />
+            </div>;
+        }
+        return <div className='theia-progress-bar-container'>
+            <div className='theia-progress-bar' />
+        </div>
+    }
+
+    private get isProgress(): boolean {
+        return typeof this.props.notification.progress === 'number';
+    }
+
+}

arduino-ide-extension/src/browser/theia/messages/notification-toasts-component.tsx

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { NotificationComponent } from './notification-component';
+import { NotificationToastsComponent as TheiaNotificationToastsComponent } from '@theia/messages/lib/browser/notification-toasts-component'
+
+export class NotificationToastsComponent extends TheiaNotificationToastsComponent {
+
+    render(): React.ReactNode {
+        return (
+            <div className={`theia-notifications-container theia-notification-toasts ${this.state.visibilityState === 'toasts' ? 'open' : 'closed'}`}>
+                <div className='theia-notification-list'>
+                    {this.state.toasts.map(notification => <NotificationComponent key={notification.messageId} notification={notification} manager={this.props.manager} />)}
+                </div>
+            </div>
+        );
+    }
+
+}

arduino-ide-extension/src/browser/theia/messages/notifications-manager.ts

@@ -0,0 +1,37 @@
+import { injectable } from 'inversify';
+import { CancellationToken } from '@theia/core/lib/common/cancellation';
+import { ProgressMessage, ProgressUpdate } from '@theia/core/lib/common/message-service-protocol';
+import { NotificationManager as TheiaNotificationManager } from '@theia/messages/lib/browser/notifications-manager';
+
+@injectable()
+export class NotificationManager extends TheiaNotificationManager {
+
+    async reportProgress(messageId: string, update: ProgressUpdate, originalMessage: ProgressMessage, cancellationToken: CancellationToken): Promise<void> {
+        const notification = this.find(messageId);
+        if (!notification) {
+            return;
+        }
+        if (cancellationToken.isCancellationRequested) {
+            this.clear(messageId);
+        } else {
+            notification.message = originalMessage.text && update.message ? `${originalMessage.text}: ${update.message}` :
+                originalMessage.text || update?.message || notification.message;
+
+            // Unlike in Theia, we allow resetting the progress monitor to NaN to enforce unknown progress.
+            const candidate = this.toPlainProgress(update);
+            notification.progress = typeof candidate === 'number' ? candidate : notification.progress;
+        }
+        this.fireUpdatedEvent();
+    }
+
+    protected toPlainProgress(update: ProgressUpdate): number | undefined {
+        if (!update.work) {
+            return undefined;
+        }
+        if (Number.isNaN(update.work.done) || Number.isNaN(update.work.total)) {
+            return Number.NaN; // This should trigger the unknown monitor.
+        }
+        return Math.min(update.work.done / update.work.total * 100, 100);
+    }
+
+}

arduino-ide-extension/src/browser/theia/messages/notifications-renderer.tsx

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { injectable } from 'inversify';
+import { NotificationCenterComponent } from './notification-center-component';
+import { NotificationToastsComponent } from './notification-toasts-component';
+import { NotificationsRenderer as TheiaNotificationsRenderer } from '@theia/messages/lib/browser/notifications-renderer';
+
+@injectable()
+export class NotificationsRenderer extends TheiaNotificationsRenderer {
+
+    protected render(): void {
+        ReactDOM.render(<div>
+            <NotificationToastsComponent manager={this.manager} corePreferences={this.corePreferences} />
+            <NotificationCenterComponent manager={this.manager} />
+        </div>, this.container);
+    }
+
+}

arduino-ide-extension/src/browser/theia/monaco/monaco-editor-provider.ts

@@ -0,0 +1,64 @@
+import { inject, injectable } from 'inversify';
+import URI from '@theia/core/lib/common/uri';
+import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
+import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
+import { MonacoEditorProvider as TheiaMonacoEditorProvider } from '@theia/monaco/lib/browser/monaco-editor-provider';
+import { SketchesServiceClientImpl } from '../../../common/protocol/sketches-service-client-impl';
+
+type CancelablePromise = Promise<monaco.referenceSearch.ReferencesModel> & { cancel: () => void };
+interface EditorFactory {
+    (override: monaco.editor.IEditorOverrideServices, toDispose: DisposableCollection): Promise<MonacoEditor>;
+}
+
+@injectable()
+export class MonacoEditorProvider extends TheiaMonacoEditorProvider {
+
+    @inject(SketchesServiceClientImpl)
+    protected readonly sketchesServiceClient: SketchesServiceClientImpl;
+
+    protected async doCreateEditor(uri: URI, factory: EditorFactory): Promise<MonacoEditor> {
+        const editor = await super.doCreateEditor(uri, factory);
+        const toDispose = new DisposableCollection();
+        toDispose.push(this.installCustomReferencesController(editor));
+        toDispose.push(editor.onDispose(() => toDispose.dispose()));
+        return editor;
+    }
+
+    private installCustomReferencesController(editor: MonacoEditor): Disposable {
+        const control = editor.getControl();
+        const referencesController = control._contributions['editor.contrib.referencesController'];
+        const originalToggleWidget = referencesController.toggleWidget;
+        const toDispose = new DisposableCollection();
+        const toDisposeBeforeToggleWidget = new DisposableCollection();
+        referencesController.toggleWidget = (range: monaco.Range, modelPromise: CancelablePromise, peekMode: boolean) => {
+            toDisposeBeforeToggleWidget.dispose();
+            originalToggleWidget.bind(referencesController)(range, modelPromise, peekMode);
+            if (referencesController._widget) {
+                if ('onDidClose' in referencesController._widget) {
+                    toDisposeBeforeToggleWidget.push((referencesController._widget as any).onDidClose(() => toDisposeBeforeToggleWidget.dispose()));
+                }
+                const preview = (referencesController._widget as any)._preview as monaco.editor.ICodeEditor;
+                if (preview) {
+                    toDisposeBeforeToggleWidget.push(preview.onDidChangeModel(() => this.updateReadOnlyState(preview)))
+                    this.updateReadOnlyState(preview);
+                }
+            }
+        };
+        toDispose.push(Disposable.create(() => toDisposeBeforeToggleWidget.dispose()));
+        toDispose.push(Disposable.create(() => referencesController.toggleWidget = originalToggleWidget));
+        return toDispose;
+    }
+
+    private updateReadOnlyState(editor: monaco.editor.ICodeEditor | undefined): void {
+        if (!editor) {
+            return;
+        }
+        const model = editor.getModel();
+        if (!model) {
+            return;
+        }
+        const readOnly = this.sketchesServiceClient.isReadOnly(model.uri);
+        editor.updateOptions({ readOnly });
+    }
+
+}

arduino-ide-extension/src/browser/theia/monaco/monaco-text-model-service.ts

@@ -1,22 +1,29 @@
-import { injectable } from 'inversify';
+import { inject, injectable } from 'inversify';
 import { Resource } from '@theia/core/lib/common/resource';
-import { MaybePromise } from '@theia/core/lib/common/types';
-import { Log, Loggable } from '@theia/core/lib/common/logger';
+import { ILogger, Log, Loggable } from '@theia/core/lib/common/logger';
 import { MonacoEditorModel } from '@theia/monaco/lib/browser/monaco-editor-model';
+import { EditorPreferences } from '@theia/editor/lib/browser/editor-preferences';
+import { MonacoToProtocolConverter } from '@theia/monaco/lib/browser/monaco-to-protocol-converter';
+import { ProtocolToMonacoConverter } from '@theia/monaco/lib/browser/protocol-to-monaco-converter';
 import { MonacoTextModelService as TheiaMonacoTextModelService } from '@theia/monaco/lib/browser/monaco-text-model-service';
+import { SketchesServiceClientImpl } from '../../../common/protocol/sketches-service-client-impl';
 
 @injectable()
 export class MonacoTextModelService extends TheiaMonacoTextModelService {
 
-    protected createModel(resource: Resource): MaybePromise<MonacoEditorModel> {
+    @inject(SketchesServiceClientImpl)
+    protected readonly sketchesServiceClient: SketchesServiceClientImpl;
+
+    protected async createModel(resource: Resource): Promise<MonacoEditorModel> {
         const factory = this.factories.getContributions().find(({ scheme }) => resource.uri.scheme === scheme);
-        return factory ? factory.createModel(resource) : new SilentMonacoEditorModel(resource, this.m2p, this.p2m, this.logger);
+        const readOnly = this.sketchesServiceClient.isReadOnly(resource.uri);
+        return factory ? factory.createModel(resource) : new MaybeReadonlyMonacoEditorModel(resource, this.m2p, this.p2m, this.logger, undefined, readOnly);
     }
 
 }
 
 // https://github.com/eclipse-theia/theia/pull/8491
-export class SilentMonacoEditorModel extends MonacoEditorModel {
+class SilentMonacoEditorModel extends MonacoEditorModel {
 
     protected trace(loggable: Loggable): void {
         if (this.logger) {
@@ -27,3 +34,41 @@ export class SilentMonacoEditorModel extends MonacoEditorModel {
     }
 
 }
+
+class MaybeReadonlyMonacoEditorModel extends SilentMonacoEditorModel {
+
+    constructor(
+        protected readonly resource: Resource,
+        protected readonly m2p: MonacoToProtocolConverter,
+        protected readonly p2m: ProtocolToMonacoConverter,
+        protected readonly logger?: ILogger,
+        protected readonly editorPreferences?: EditorPreferences,
+        protected readonly _readOnly?: boolean,
+    ) {
+        super(resource, m2p, p2m, logger, editorPreferences)
+    }
+
+    get readOnly(): boolean {
+        if (typeof this._readOnly === 'boolean') {
+            return this._readOnly;
+        }
+        return this.resource.saveContents === undefined;
+    }
+
+    protected setDirty(dirty: boolean): void {
+        if (this._readOnly === true) {
+            // NOOP
+            return;
+        }
+        if (dirty === this._dirty) {
+            return;
+        }
+        this._dirty = dirty;
+        if (dirty === false) {
+            (this as any).updateSavedVersionId();
+        }
+        this.onDirtyChangedEmitter.fire(undefined);
+    }
+
+
+}

arduino-ide-extension/src/browser/theia/workspace/workspace-service.ts

@@ -6,10 +6,13 @@ import { MessageService } from '@theia/core/lib/common/message-service';
 import { ApplicationServer } from '@theia/core/lib/common/application-protocol';
 import { FrontendApplication } from '@theia/core/lib/browser/frontend-application';
 import { FocusTracker, Widget } from '@theia/core/lib/browser';
+import { FrontendApplicationStateService } from '@theia/core/lib/browser/frontend-application-state';
 import { WorkspaceService as TheiaWorkspaceService } from '@theia/workspace/lib/browser/workspace-service';
 import { ConfigService } from '../../../common/protocol/config-service';
 import { SketchesService, Sketch, SketchContainer } from '../../../common/protocol/sketches-service';
 import { ArduinoWorkspaceRootResolver } from '../../arduino-workspace-resolver';
+import { BoardsServiceProvider } from '../../boards/boards-service-provider';
+import { BoardsConfig } from '../../boards/boards-config';
 
 @injectable()
 export class WorkspaceService extends TheiaWorkspaceService {
@@ -29,10 +32,18 @@ export class WorkspaceService extends TheiaWorkspaceService {
     @inject(ApplicationServer)
     protected readonly applicationServer: ApplicationServer;
 
+    @inject(FrontendApplicationStateService)
+    protected readonly appStateService: FrontendApplicationStateService;
+
+    @inject(BoardsServiceProvider)
+    protected readonly boardsServiceProvider: BoardsServiceProvider;
+
+    private application: FrontendApplication;
     private workspaceUri?: Promise<string | undefined>;
-    private version?: string
+    private version?: string;
 
     async onStart(application: FrontendApplication): Promise<void> {
+        this.application = application;
         const info = await this.applicationServer.getApplicationInfo();
         this.version = info?.version;
         application.shell.onDidChangeCurrentWidget(this.onCurrentWidgetChange.bind(this));
@@ -62,17 +73,25 @@ export class WorkspaceService extends TheiaWorkspaceService {
                 }
                 return (await this.sketchService.createNewSketch()).uri;
             } catch (err) {
+                this.appStateService.reachedState('ready').then(() => this.application.shell.update());
                 this.logger.fatal(`Failed to determine the sketch directory: ${err}`)
                 this.messageService.error(
                     'There was an error creating the sketch directory. ' +
                     'See the log for more details. ' +
-                    'The application will probably not work as expected.')
+                    'The application will probably not work as expected.');
                 return super.getDefaultWorkspaceUri();
             }
         })();
         return this.workspaceUri;
     }
 
+    protected openNewWindow(workspacePath: string): void {
+        const { boardsConfig } = this.boardsServiceProvider;
+        const url = BoardsConfig.Config.setConfig(boardsConfig, new URL(window.location.href)); // Set the current boards config for the new browser window.
+        url.hash = workspacePath;
+        this.windowService.openNewWindow(url.toString());
+    }
+
     private async isValid(uri: string): Promise<boolean> {
         const exists = await this.fileService.exists(new URI(uri));
         if (!exists) {

arduino-ide-extension/src/browser/widgets/component-list/component-list.tsx

@@ -42,6 +42,7 @@ export namespace ComponentList {
     export interface Props<T extends ArduinoComponent> {
         readonly items: T[];
         readonly itemLabel: (item: T) => string;
+        readonly itemDeprecated: (item: T) => boolean;
         readonly itemRenderer: ListItemRenderer<T>;
         readonly install: (item: T, version?: Installable.Version) => Promise<void>;
         readonly uninstall: (item: T) => Promise<void>;

arduino-ide-extension/src/browser/widgets/component-list/filterable-list-container.tsx

@@ -3,16 +3,15 @@ import debounce = require('lodash.debounce');
 import { Event } from '@theia/core/lib/common/event';
 import { CommandService } from '@theia/core/lib/common/command';
 import { MessageService } from '@theia/core/lib/common/message-service';
-import { OutputCommands } from '@theia/output/lib/browser/output-commands';
 import { ConfirmDialog } from '@theia/core/lib/browser/dialogs';
 import { Searchable } from '../../../common/protocol/searchable';
 import { Installable } from '../../../common/protocol/installable';
 import { ArduinoComponent } from '../../../common/protocol/arduino-component';
-import { InstallationProgressDialog, UninstallationProgressDialog } from '../progress-dialog';
 import { SearchBar } from './search-bar';
 import { ListWidget } from './list-widget';
 import { ComponentList } from './component-list';
 import { ListItemRenderer } from './list-item-renderer';
+import { ResponseServiceImpl } from '../../response-service-impl';
 
 export class FilterableListContainer<T extends ArduinoComponent> extends React.Component<FilterableListContainer.Props<T>, FilterableListContainer.State<T>> {
 
@@ -57,10 +56,11 @@ export class FilterableListContainer<T extends ArduinoComponent> extends React.C
     }
 
     protected renderComponentList(): React.ReactNode {
-        const { itemLabel, resolveContainer, itemRenderer } = this.props;
+        const { itemLabel, itemDeprecated, resolveContainer, itemRenderer } = this.props;
         return <ComponentList<T>
             items={this.state.items}
             itemLabel={itemLabel}
+            itemDeprecated={itemDeprecated}
             itemRenderer={itemRenderer}
             install={this.install.bind(this)}
             uninstall={this.uninstall.bind(this)}
@@ -79,25 +79,28 @@ export class FilterableListContainer<T extends ArduinoComponent> extends React.C
     }
 
     protected sort(items: T[]): T[] {
-        const { itemLabel } = this.props;
-        return items.sort((left, right) => itemLabel(left).localeCompare(itemLabel(right)));
+        // debugger;
+        const { itemLabel, itemDeprecated } = this.props;
+        return items.sort((left, right) => {
+
+            // always put deprecated items at the bottom of the list
+            if (itemDeprecated(left)) {
+                return 1;
+            }
+
+            return itemLabel(left).localeCompare(itemLabel(right))
+        });
     }
 
     protected async install(item: T, version: Installable.Version): Promise<void> {
-        const { install, searchable, itemLabel } = this.props;
-        const dialog = new InstallationProgressDialog(itemLabel(item), version);
-        try {
-            dialog.open();
-            await this.clearArduinoChannel();
-            await install({ item, version });
-            const items = await searchable.search({ query: this.state.filterText });
-            this.setState({ items: this.sort(items) });
-        } catch (error) {
-            this.props.messageService.error(error instanceof Error ? error.message : String(error));
-            throw error;
-        } finally {
-            dialog.close();
-        }
+        const { install, searchable } = this.props;
+        await Installable.doWithProgress({
+            ...this.props,
+            progressText: `Processing ${item.name}:${version}`,
+            run: ({ progressId }) => install({ item, progressId, version })
+        });
+        const items = await searchable.search({ query: this.state.filterText });
+        this.setState({ items: this.sort(items) });
     }
 
     protected async uninstall(item: T): Promise<void> {
@@ -110,21 +113,14 @@ export class FilterableListContainer<T extends ArduinoComponent> extends React.C
         if (!ok) {
             return;
         }
-        const { uninstall, searchable, itemLabel } = this.props;
-        const dialog = new UninstallationProgressDialog(itemLabel(item));
-        try {
-            await this.clearArduinoChannel();
-            dialog.open();
-            await uninstall({ item });
-            const items = await searchable.search({ query: this.state.filterText });
-            this.setState({ items: this.sort(items) });
-        } finally {
-            dialog.close();
-        }
-    }
-
-    private async clearArduinoChannel(): Promise<void> {
-        return this.props.commandService.executeCommand(OutputCommands.CLEAR.id, { name: 'Arduino' });
+        const { uninstall, searchable } = this.props;
+        await Installable.doWithProgress({
+            ...this.props,
+            progressText: `Processing ${item.name}${item.installedVersion ? `:${item.installedVersion}` : ''}`,
+            run: ({ progressId }) => uninstall({ item, progressId })
+        });
+        const items = await searchable.search({ query: this.state.filterText });
+        this.setState({ items: this.sort(items) });
     }
 
 }
@@ -135,13 +131,15 @@ export namespace FilterableListContainer {
         readonly container: ListWidget<T>;
         readonly searchable: Searchable<T>;
         readonly itemLabel: (item: T) => string;
+        readonly itemDeprecated: (item: T) => boolean;
         readonly itemRenderer: ListItemRenderer<T>;
         readonly resolveContainer: (element: HTMLElement) => void;
         readonly resolveFocus: (element: HTMLElement | undefined) => void;
         readonly filterTextChangeEvent: Event<string | undefined>;
-        readonly install: ({ item, version }: { item: T, version: Installable.Version }) => Promise<void>;
-        readonly uninstall: ({ item }: { item: T }) => Promise<void>;
         readonly messageService: MessageService;
+        readonly responseService: ResponseServiceImpl;
+        readonly install: ({ item, progressId, version }: { item: T, progressId: string, version: Installable.Version }) => Promise<void>;
+        readonly uninstall: ({ item, progressId }: { item: T, progressId: string }) => Promise<void>;
         readonly commandService: CommandService;
     }
 

arduino-ide-extension/src/browser/widgets/component-list/list-widget.tsx

@@ -1,5 +1,6 @@
 import * as React from 'react';
 import { injectable, postConstruct, inject } from 'inversify';
+import { Widget } from '@phosphor/widgets';
 import { Message } from '@phosphor/messaging';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import { Emitter } from '@theia/core/lib/common/event';
@@ -7,12 +8,11 @@ import { MaybePromise } from '@theia/core/lib/common/types';
 import { ReactWidget } from '@theia/core/lib/browser/widgets/react-widget';
 import { CommandService } from '@theia/core/lib/common/command';
 import { MessageService } from '@theia/core/lib/common/message-service';
-import { Installable } from '../../../common/protocol/installable';
-import { Searchable } from '../../../common/protocol/searchable';
-import { ArduinoComponent } from '../../../common/protocol/arduino-component';
+import { Installable, Searchable, ArduinoComponent } from '../../../common/protocol';
 import { FilterableListContainer } from './filterable-list-container';
 import { ListItemRenderer } from './list-item-renderer';
 import { NotificationCenter } from '../../notification-center';
+import { ResponseServiceImpl } from '../../response-service-impl';
 
 @injectable()
 export abstract class ListWidget<T extends ArduinoComponent> extends ReactWidget {
@@ -23,6 +23,9 @@ export abstract class ListWidget<T extends ArduinoComponent> extends ReactWidget
     @inject(CommandService)
     protected readonly commandService: CommandService;
 
+    @inject(ResponseServiceImpl)
+    protected readonly responseService: ResponseServiceImpl;
+
     @inject(NotificationCenter)
     protected readonly notificationCenter: NotificationCenter;
 
@@ -63,26 +66,31 @@ export abstract class ListWidget<T extends ArduinoComponent> extends ReactWidget
         return this.deferredContainer.promise;
     }
 
-    protected onActivateRequest(msg: Message): void {
-        super.onActivateRequest(msg);
+    protected onActivateRequest(message: Message): void {
+        super.onActivateRequest(message);
         (this.focusNode || this.node).focus();
     }
 
-    protected onUpdateRequest(msg: Message): void {
-        super.onUpdateRequest(msg);
+    protected onUpdateRequest(message: Message): void {
+        super.onUpdateRequest(message);
         this.render();
     }
 
+    protected onResize(message: Widget.ResizeMessage): void {
+        super.onResize(message);
+        this.updateScrollBar();
+    }
+
     protected onFocusResolved = (element: HTMLElement | undefined) => {
         this.focusNode = element;
     };
 
-    protected async install({ item, version }: { item: T, version: Installable.Version }): Promise<void> {
-        return this.options.installable.install({ item, version });
+    protected async install({ item, progressId, version }: { item: T, progressId: string, version: Installable.Version }): Promise<void> {
+        return this.options.installable.install({ item, progressId, version });
     }
 
-    protected async uninstall({ item }: { item: T }): Promise<void> {
-        return this.options.installable.uninstall({ item });
+    protected async uninstall({ item, progressId }: { item: T, progressId: string }): Promise<void> {
+        return this.options.installable.uninstall({ item, progressId });
     }
 
     render(): React.ReactNode {
@@ -94,10 +102,12 @@ export abstract class ListWidget<T extends ArduinoComponent> extends ReactWidget
             install={this.install.bind(this)}
             uninstall={this.uninstall.bind(this)}
             itemLabel={this.options.itemLabel}
+            itemDeprecated={this.options.itemDeprecated}
             itemRenderer={this.options.itemRenderer}
             filterTextChangeEvent={this.filterTextChangeEmitter.event}
             messageService={this.messageService}
-            commandService={this.commandService} />;
+            commandService={this.commandService}
+            responseService={this.responseService} />;
     }
 
     /**
@@ -124,6 +134,7 @@ export namespace ListWidget {
         readonly installable: Installable<T>;
         readonly searchable: Searchable<T>;
         readonly itemLabel: (item: T) => string;
+        readonly itemDeprecated: (item: T) => boolean;
         readonly itemRenderer: ListItemRenderer<T>;
     }
 }

arduino-ide-extension/src/browser/widgets/progress-dialog.tsx

@@ -1,23 +0,0 @@
-import { AbstractDialog } from '@theia/core/lib/browser';
-
-export class InstallationProgressDialog extends AbstractDialog<undefined> {
-
-    readonly value = undefined;
-
-    constructor(componentName: string, version: string) {
-        super({ title: 'Installation in progress' });
-        this.contentNode.textContent = `Installing ${componentName} [${version}]. Please wait...`;
-    }
-
-}
-
-export class UninstallationProgressDialog extends AbstractDialog<undefined> {
-
-    readonly value = undefined;
-
-    constructor(componentName: string) {
-        super({ title: 'Uninstallation in progress' });
-        this.contentNode.textContent = `Uninstalling ${componentName}. Please wait...`;
-    }
-
-}

arduino-ide-extension/src/common/protocol/arduino-component.ts

@@ -2,6 +2,7 @@ import { Installable } from './installable';
 
 export interface ArduinoComponent {
     readonly name: string;
+    readonly deprecated: boolean;
     readonly author: string;
     readonly summary: string;
     readonly description: string;

arduino-ide-extension/src/common/protocol/config-service.ts

@@ -2,6 +2,7 @@ export const ConfigServicePath = '/services/config-service';
 export const ConfigService = Symbol('ConfigService');
 export interface ConfigService {
     getVersion(): Promise<Readonly<{ version: string, commit: string, status?: string }>>;
+    getCliConfigFileUri(): Promise<string>;
     getConfiguration(): Promise<Config>;
     setConfiguration(config: Config): Promise<void>;
     isInDataDir(uri: string): Promise<boolean>;

arduino-ide-extension/src/common/protocol/examples-service.ts

@@ -4,7 +4,7 @@ export const ExamplesServicePath = '/services/example-service';
 export const ExamplesService = Symbol('ExamplesService');
 export interface ExamplesService {
     builtIns(): Promise<SketchContainer[]>;
-    installed(options: { fqbn: string }): Promise<{ user: SketchContainer[], current: SketchContainer[], any: SketchContainer[] }>;
+    installed(options: { fqbn?: string }): Promise<{ user: SketchContainer[], current: SketchContainer[], any: SketchContainer[] }>;
 }
 
 

arduino-ide-extension/src/common/protocol/index.ts

@@ -11,5 +11,5 @@ export * from './searchable';
 export * from './sketches-service';
 export * from './examples-service';
 export * from './executable-service';
-export * from './output-service';
+export * from './response-service';
 export * from './notification-service';

arduino-ide-extension/src/common/protocol/installable.ts

@@ -1,20 +1,26 @@
 import * as semver from 'semver';
+import { Progress } from '@theia/core/lib/common/message-service-protocol';
+import { CancellationToken, CancellationTokenSource } from '@theia/core/lib/common/cancellation';
 import { naturalCompare } from './../utils';
 import { ArduinoComponent } from './arduino-component';
+import { MessageService } from '@theia/core';
+import { ResponseServiceImpl } from '../../browser/response-service-impl';
 
 export interface Installable<T extends ArduinoComponent> {
     /**
      * If `options.version` is specified, that will be installed. Otherwise, `item.availableVersions[0]`.
      */
-    install(options: { item: T, version?: Installable.Version }): Promise<void>;
+    install(options: { item: T, progressId?: string, version?: Installable.Version }): Promise<void>;
 
     /**
      * Uninstalls the given component. It is a NOOP if not installed.
      */
-    uninstall(options: { item: T }): Promise<void>;
+    uninstall(options: { item: T, progressId?: string }): Promise<void>;
 }
 export namespace Installable {
+
     export type Version = string;
+
     export namespace Version {
         /**
          * Most recent version comes first, then the previous versions. (`1.8.1`, `1.6.3`, `1.6.2`, `1.6.1` and so on.)
@@ -26,4 +32,70 @@ export namespace Installable {
             return naturalCompare(left, right);
         };
     }
+
+    export async function installWithProgress<T extends ArduinoComponent>(options: {
+        installable: Installable<T>,
+        messageService: MessageService,
+        responseService: ResponseServiceImpl,
+        item: T,
+        version: Installable.Version
+    }): Promise<void> {
+
+        const { item, version } = options;
+        return doWithProgress({
+            ...options,
+            progressText: `Processing ${item.name}:${version}`,
+            run: ({ progressId }) => options.installable.install({ item: options.item, version: options.version, progressId })
+        });
+    }
+
+    export async function uninstallWithProgress<T extends ArduinoComponent>(options: {
+        installable: Installable<T>,
+        messageService: MessageService,
+        responseService: ResponseServiceImpl,
+        item: T
+    }): Promise<void> {
+
+        const { item } = options;
+        return doWithProgress({
+            ...options,
+            progressText: `Processing ${item.name}${item.installedVersion ? `:${item.installedVersion}` : ''}`,
+            run: ({ progressId }) => options.installable.uninstall({ item: options.item, progressId })
+        });
+    }
+
+    export async function doWithProgress(options: {
+        run: ({ progressId }: { progressId: string }) => Promise<void>,
+        messageService: MessageService,
+        responseService: ResponseServiceImpl,
+        progressText: string
+    }): Promise<void> {
+
+        return withProgress(options.progressText, options.messageService, async (progress, _) => {
+            const progressId = progress.id;
+            const toDispose = options.responseService.onProgressDidChange(progressMessage => {
+                if (progressId === progressMessage.progressId) {
+                    const { message, work } = progressMessage;
+                    progress.report({ message, work });
+                }
+            });
+            try {
+                options.responseService.clearArduinoChannel();
+                await options.run({ progressId });
+            } finally {
+                toDispose.dispose();
+            }
+        });
+    }
+
+    async function withProgress(text: string, messageService: MessageService, cb: (progress: Progress, token: CancellationToken) => Promise<void>): Promise<void> {
+        const cancellationSource = new CancellationTokenSource();
+        const { token } = cancellationSource;
+        const progress = await messageService.showProgress({ text, options: { cancelable: false } }, () => cancellationSource.cancel());
+        try {
+            await cb(progress, token);
+        } finally {
+            progress.cancel();
+        }
+    }
 }

arduino-ide-extension/src/common/protocol/library-service.ts

@@ -9,8 +9,8 @@ export interface LibraryService extends Installable<LibraryPackage>, Searchable<
     /**
      * When `installDependencies` is not set, it is `true` by default. If you want to skip the installation of required dependencies, set it to `false`.
      */
-    install(options: { item: LibraryPackage, version?: Installable.Version, installDependencies?: boolean }): Promise<void>;
-    installZip(options: { zipUri: string, overwrite?: boolean }): Promise<void>;
+    install(options: { item: LibraryPackage, progressId?: string, version?: Installable.Version, installDependencies?: boolean }): Promise<void>;
+    installZip(options: { zipUri: string, progressId?: string, overwrite?: boolean }): Promise<void>;
     /**
      * Set `filterSelf` to `true` if you want to avoid having `item` in the result set.
      * Note: as of today (22.02.2021), the CLI works like this: `./arduino-cli lib deps Adaino@0.1.0 ✕ Adaino 0.1.0 must be installed.`.

arduino-ide-extension/src/common/protocol/output-service.ts

@@ -1,10 +0,0 @@
-export interface OutputMessage {
-    readonly chunk: string;
-    readonly severity?: 'error' | 'warning' | 'info'; // Currently not used!
-}
-
-export const OutputServicePath = '/services/output-service';
-export const OutputService = Symbol('OutputService');
-export interface OutputService {
-    append(message: OutputMessage): void;
-}

arduino-ide-extension/src/common/protocol/response-service.ts

@@ -0,0 +1,23 @@
+export interface OutputMessage {
+    readonly chunk: string;
+    readonly severity?: 'error' | 'warning' | 'info'; // Currently not used!
+}
+
+export interface ProgressMessage {
+    readonly progressId: string;
+    readonly message: string;
+    readonly work?: ProgressMessage.Work;
+}
+export namespace ProgressMessage {
+    export interface Work {
+        readonly done: number;
+        readonly total: number;
+    }
+}
+
+export const ResponseServicePath = '/services/response-service';
+export const ResponseService = Symbol('ResponseService');
+export interface ResponseService {
+    appendToOutput(message: OutputMessage): void;
+    reportProgress(message: ProgressMessage): void;
+}

arduino-ide-extension/src/common/protocol/sketches-service-client-impl.ts

@@ -1,14 +1,15 @@
 import { inject, injectable } from 'inversify';
 import URI from '@theia/core/lib/common/uri';
+import { Emitter } from '@theia/core/lib/common/event';
 import { notEmpty } from '@theia/core/lib/common/objects';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { MessageService } from '@theia/core/lib/common/message-service';
+import { FileChangeType } from '@theia/filesystem/lib/common/files';
 import { WorkspaceService } from '@theia/workspace/lib/browser/workspace-service';
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
+import { FrontendApplicationContribution } from '@theia/core/lib/browser/frontend-application';
 import { Sketch, SketchesService } from '../../common/protocol';
-import { FrontendApplicationContribution } from '@theia/core/lib/browser';
 import { ConfigService } from './config-service';
-import { DisposableCollection, Emitter } from '@theia/core';
-import { FileChangeType } from '@theia/filesystem/lib/browser';
 import { SketchContainer } from './sketches-service';
 
 @injectable()
@@ -129,4 +130,16 @@ export class SketchesServiceClientImpl implements FrontendApplicationContributio
         }, 100);
     }
 
+    /**
+     * `true` if the `uri` is not contained in any of the opened workspaces. Otherwise, `false`.
+     */
+    isReadOnly(uri: URI | monaco.Uri | string): boolean {
+        const toCheck = uri instanceof URI ? uri : new URI(uri);
+        if (toCheck.scheme === 'user-storage') {
+            return false;
+        }
+        const readOnly = !this.workspaceService.tryGetRoots().some(({ resource }) => resource.isEqualOrParent(toCheck));
+        return readOnly;
+    }
+
 }

arduino-ide-extension/src/common/protocol/sketches-service.ts

@@ -87,7 +87,7 @@ export namespace Sketch {
     export namespace Extensions {
         export const MAIN = ['.ino', '.pde'];
         export const SOURCE = ['.c', '.cpp', '.s'];
-        export const ADDITIONAL = ['.h', '.c', '.hpp', '.hh', '.cpp', '.s', '.json'];
+        export const ADDITIONAL = ['.h', '.c', '.hpp', '.hh', '.cpp', '.S', '.json', '.md', '.adoc'];
         export const ALL = Array.from(new Set([...MAIN, ...SOURCE, ...ADDITIONAL]));
     }
     export function isInSketch(uri: string | URI, sketch: Sketch): boolean {

arduino-ide-extension/src/electron-browser/theia/core/electron-main-menu-factory.ts

@@ -1,7 +1,8 @@
 import { injectable } from 'inversify'
 import { remote } from 'electron';
+import { isOSX } from '@theia/core/lib/common/os';
 import { Keybinding } from '@theia/core/lib/common/keybinding';
-import { CompositeMenuNode } from '@theia/core/lib/common/menu';
+import { CompositeMenuNode, MAIN_MENU_BAR, MenuPath } from '@theia/core/lib/common/menu';
 import { ElectronMainMenuFactory as TheiaElectronMainMenuFactory, ElectronMenuOptions } from '@theia/core/lib/electron-browser/menu/electron-main-menu-factory';
 import { ArduinoMenus, PlaceholderMenuNode } from '../../../browser/menu/arduino-menus';
 
@@ -10,7 +11,33 @@ export class ElectronMainMenuFactory extends TheiaElectronMainMenuFactory {
 
     createMenuBar(): Electron.Menu {
         this._toggledCommands.clear(); // https://github.com/eclipse-theia/theia/issues/8977
-        return super.createMenuBar();
+        const menuModel = this.menuProvider.getMenu(MAIN_MENU_BAR);
+        const template = this.fillMenuTemplate([], menuModel);
+        if (isOSX) {
+            template.unshift(this.createOSXMenu());
+        }
+        const menu = remote.Menu.buildFromTemplate(this.escapeAmpersand(template));
+        this._menu = menu;
+        return menu;
+    }
+
+    createContextMenu(menuPath: MenuPath, args?: any[]): Electron.Menu {
+        const menuModel = this.menuProvider.getMenu(menuPath);
+        const template = this.fillMenuTemplate([], menuModel, args, { showDisabled: false });
+        return remote.Menu.buildFromTemplate(this.escapeAmpersand(template));
+    }
+
+    // TODO: remove after https://github.com/eclipse-theia/theia/pull/9231
+    private escapeAmpersand(template: Electron.MenuItemConstructorOptions[]): Electron.MenuItemConstructorOptions[] {
+        for (const option of template) {
+            if (option.label) {
+                option.label = option.label.replace(/\&+/g, '&$&');
+            }
+            if (option.submenu) {
+                this.escapeAmpersand(option.submenu as Electron.MenuItemConstructorOptions[]);
+            }
+        }
+        return template;
     }
 
     protected acceleratorFor(keybinding: Keybinding): string {
@@ -26,15 +53,17 @@ export class ElectronMainMenuFactory extends TheiaElectronMainMenuFactory {
         const { submenu } = super.createOSXMenu();
         const label = 'Arduino IDE';
         if (!!submenu && !(submenu instanceof remote.Menu)) {
-            const [/* about */, /* settings */, ...rest] = submenu;
+            const [/* about */, /* preferences */, ...rest] = submenu;
             const about = this.fillMenuTemplate([], this.menuProvider.getMenu(ArduinoMenus.HELP__ABOUT_GROUP));
-            const settings = this.fillMenuTemplate([], this.menuProvider.getMenu(ArduinoMenus.FILE__SETTINGS_GROUP));
+            const preferences = this.fillMenuTemplate([], this.menuProvider.getMenu(ArduinoMenus.FILE__PREFERENCES_GROUP));
+            const advanced = this.fillMenuTemplate([], this.menuProvider.getMenu(ArduinoMenus.FILE__ADVANCED_GROUP));
             return {
                 label,
                 submenu: [
                     ...about,
                     { type: 'separator' },
-                    ...settings,
+                    ...preferences,
+                    ...advanced,
                     { type: 'separator' },
                     ...rest
                 ]

arduino-ide-extension/src/electron-main/theia/electron-main-application.ts

@@ -82,16 +82,6 @@ export class ElectronMainApplication extends TheiaElectronMainApplication {
         return electronWindow;
     }
 
-    protected async getDefaultBrowserWindowOptions(): Promise<TheiaBrowserWindowOptions> {
-        const options = await super.getDefaultBrowserWindowOptions();
-        return {
-            ...options,
-            // Set and use a custom minimum window size: https://github.com/arduino/arduino-pro-ide/issues/337#issuecomment-687017281
-            minWidth: 900,
-            minHeight: 800
-        };
-    }
-
     protected async startBackend(): Promise<number> {
         // Check if we should run everything as one process.
         const noBackendFork = process.argv.indexOf('--no-cluster') !== -1;

arduino-ide-extension/src/electron-main/theia/electron-main-window-service.ts

@@ -11,7 +11,8 @@ export class ElectronMainWindowServiceImpl extends TheiaElectronMainWindowServic
 
     openNewWindow(url: string, { external }: NewWindowOptions): undefined {
         if (!external) {
-            const existing = this.app.windows.find(window => window.webContents.getURL() === url);
+            const sanitizedUrl = this.sanitize(url);
+            const existing = this.app.windows.find(window => this.sanitize(window.webContents.getURL()) === sanitizedUrl);
             if (existing) {
                 existing.focus();
                 return;
@@ -20,5 +21,14 @@ export class ElectronMainWindowServiceImpl extends TheiaElectronMainWindowServic
         return super.openNewWindow(url, { external });
     }
 
+    private sanitize(url: string): string {
+        const copy = new URL(url);
+        const searchParams: string[] = [];
+        copy.searchParams.forEach((_, key) => searchParams.push(key));
+        for (const param of searchParams) {
+            copy.searchParams.delete(param);
+        }
+        return copy.toString();
+    }
 
 }

arduino-ide-extension/src/node/arduino-ide-backend-module.ts

@@ -29,11 +29,13 @@ import { ExamplesServiceImpl } from './examples-service-impl';
 import { ExamplesService, ExamplesServicePath } from '../common/protocol/examples-service';
 import { ExecutableService, ExecutableServicePath } from '../common/protocol/executable-service';
 import { ExecutableServiceImpl } from './executable-service-impl';
-import { OutputServicePath, OutputService } from '../common/protocol/output-service';
+import { ResponseServicePath, ResponseService } from '../common/protocol/response-service';
 import { NotificationServiceServerImpl } from './notification-service-server';
 import { NotificationServiceServer, NotificationServiceClient, NotificationServicePath } from '../common/protocol';
 import { BackendApplication } from './theia/core/backend-application';
 import { BoardDiscovery } from './board-discovery';
+import { DefaultGitInit } from './theia/git/git-init';
+import { GitInit } from '@theia/git/lib/node/init/git-init';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(BackendApplication).toSelf().inSingletonScope();
@@ -125,7 +127,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
     // Output service per connection.
     bind(ConnectionContainerModule).toConstantValue(ConnectionContainerModule.create(({ bindFrontendService }) => {
-        bindFrontendService(OutputServicePath, OutputService);
+        bindFrontendService(ResponseServicePath, ResponseService);
     }));
 
     // Notify all connected frontend instances
@@ -164,4 +166,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
         return parentLogger.child('monitor-service');
     }).inSingletonScope().whenTargetNamed('monitor-service');
 
+    bind(DefaultGitInit).toSelf();
+    rebind(GitInit).toService(DefaultGitInit);
+
 });

arduino-ide-extension/src/node/board-discovery.ts

@@ -2,8 +2,8 @@ import { injectable, inject, postConstruct, named } from 'inversify';
 import { ClientDuplexStream } from '@grpc/grpc-js';
 import { ILogger } from '@theia/core/lib/common/logger';
 import { deepClone } from '@theia/core/lib/common/objects';
-import { CoreClientProvider } from './core-client-provider';
-import { BoardListWatchReq, BoardListWatchResp } from './cli-protocol/commands/board_pb';
+import { CoreClientAware } from './core-client-provider';
+import { BoardListWatchRequest, BoardListWatchResponse } from './cli-protocol/cc/arduino/cli/commands/v1/board_pb';
 import { Board, Port, NotificationServiceServer, AvailablePorts, AttachedBoardsChangeEvent } from '../common/protocol';
 
 /**
@@ -12,19 +12,16 @@ import { Board, Port, NotificationServiceServer, AvailablePorts, AttachedBoardsC
  * Unlike other services, this is not connection scoped.
  */
 @injectable()
-export class BoardDiscovery {
+export class BoardDiscovery extends CoreClientAware {
 
     @inject(ILogger)
     @named('discovery')
     protected discoveryLogger: ILogger;
 
-    @inject(CoreClientProvider)
-    protected readonly coreClientProvider: CoreClientProvider;
-
     @inject(NotificationServiceServer)
     protected readonly notificationService: NotificationServiceServer;
 
-    protected boardWatchDuplex: ClientDuplexStream<BoardListWatchReq, BoardListWatchResp> | undefined;
+    protected boardWatchDuplex: ClientDuplexStream<BoardListWatchRequest, BoardListWatchResponse> | undefined;
 
     /**
      * Keys are the `address` of the ports. \
@@ -46,10 +43,10 @@ export class BoardDiscovery {
     protected async init(): Promise<void> {
         const coreClient = await this.coreClient();
         const { client, instance } = coreClient;
-        const req = new BoardListWatchReq();
+        const req = new BoardListWatchRequest();
         req.setInstance(instance);
         this.boardWatchDuplex = client.boardListWatch();
-        this.boardWatchDuplex.on('data', (resp: BoardListWatchResp) => {
+        this.boardWatchDuplex.on('data', (resp: BoardListWatchResponse) => {
             const detectedPort = resp.getPort();
             if (detectedPort) {
 
@@ -133,23 +130,4 @@ export class BoardDiscovery {
         return availablePorts;
     }
 
-    private async coreClient(): Promise<CoreClientProvider.Client> {
-        const coreClient = await new Promise<CoreClientProvider.Client>(async resolve => {
-            const client = await this.coreClientProvider.client();
-            if (client) {
-                resolve(client);
-                return;
-            }
-            const toDispose = this.coreClientProvider.onClientReady(async () => {
-                const client = await this.coreClientProvider.client();
-                if (client) {
-                    toDispose.dispose();
-                    resolve(client);
-                    return;
-                }
-            });
-        });
-        return coreClient;
-    }
-
 }

arduino-ide-extension/src/node/boards-service-impl.ts

@@ -4,17 +4,18 @@ import { notEmpty } from '@theia/core/lib/common/objects';
 import {
     BoardsService,
     Installable,
-    BoardsPackage, Board, Port, BoardDetails, Tool, ConfigOption, ConfigValue, Programmer, OutputService, NotificationServiceServer, AvailablePorts, BoardWithPackage
+    BoardsPackage, Board, Port, BoardDetails, Tool, ConfigOption, ConfigValue, Programmer, ResponseService, NotificationServiceServer, AvailablePorts, BoardWithPackage
 } from '../common/protocol';
 import {
-    PlatformSearchReq, PlatformSearchResp, PlatformInstallReq, PlatformInstallResp, PlatformListReq,
-    PlatformListResp, PlatformUninstallResp, PlatformUninstallReq
-} from './cli-protocol/commands/core_pb';
-import { Platform } from './cli-protocol/commands/common_pb';
+    PlatformInstallRequest, PlatformListRequest, PlatformListResponse, PlatformSearchRequest,
+    PlatformSearchResponse, PlatformUninstallRequest
+} from './cli-protocol/cc/arduino/cli/commands/v1/core_pb';
+import { Platform } from './cli-protocol/cc/arduino/cli/commands/v1/common_pb';
 import { BoardDiscovery } from './board-discovery';
 import { CoreClientAware } from './core-client-provider';
-import { BoardDetailsReq, BoardDetailsResp, BoardSearchReq } from './cli-protocol/commands/board_pb';
-import { ListProgrammersAvailableForUploadReq, ListProgrammersAvailableForUploadResp } from './cli-protocol/commands/upload_pb';
+import { BoardDetailsRequest, BoardDetailsResponse, BoardSearchRequest } from './cli-protocol/cc/arduino/cli/commands/v1/board_pb';
+import { ListProgrammersAvailableForUploadRequest, ListProgrammersAvailableForUploadResponse } from './cli-protocol/cc/arduino/cli/commands/v1/upload_pb';
+import { InstallWithProgress } from './grpc-installable';
 
 @injectable()
 export class BoardsServiceImpl extends CoreClientAware implements BoardsService {
@@ -26,8 +27,8 @@ export class BoardsServiceImpl extends CoreClientAware implements BoardsService
     @named('discovery')
     protected discoveryLogger: ILogger;
 
-    @inject(OutputService)
-    protected readonly outputService: OutputService;
+    @inject(ResponseService)
+    protected readonly responseService: ResponseService;
 
     @inject(NotificationServiceServer)
     protected readonly notificationService: NotificationServiceServer;
@@ -51,10 +52,10 @@ export class BoardsServiceImpl extends CoreClientAware implements BoardsService
         const coreClient = await this.coreClient();
         const { client, instance } = coreClient;
         const { fqbn } = options;
-        const detailsReq = new BoardDetailsReq();
+        const detailsReq = new BoardDetailsRequest();
         detailsReq.setInstance(instance);
         detailsReq.setFqbn(fqbn);
-        const detailsResp = await new Promise<BoardDetailsResp | undefined>((resolve, reject) => client.boardDetails(detailsReq, (err, resp) => {
+        const detailsResp = await new Promise<BoardDetailsResponse | undefined>((resolve, reject) => client.boardDetails(detailsReq, (err, resp) => {
             if (err) {
                 // Required cores are not installed manually: https://github.com/arduino/arduino-cli/issues/954
                 if ((err.message.indexOf('missing platform release') !== -1 && err.message.indexOf('referenced by board') !== -1)
@@ -63,6 +64,11 @@ export class BoardsServiceImpl extends CoreClientAware implements BoardsService
                     resolve(undefined);
                     return;
                 }
+                // It's a hack to handle https://github.com/arduino/arduino-cli/issues/1262 gracefully.
+                if (err.message.indexOf('unknown package') !== -1) {
+                    resolve(undefined);
+                    return;
+                }
                 reject(err);
                 return;
             }
@@ -75,7 +81,7 @@ export class BoardsServiceImpl extends CoreClientAware implements BoardsService
 
         const debuggingSupported = detailsResp.getDebuggingSupported();
 
-        const requiredTools = detailsResp.getToolsdependenciesList().map(t => <Tool>{
+        const requiredTools = detailsResp.getToolsDependenciesList().map(t => <Tool>{
             name: t.getName(),
             packager: t.getPackager(),
             version: t.getVersion()
@@ -91,10 +97,10 @@ export class BoardsServiceImpl extends CoreClientAware implements BoardsService
             })
         });
 
-        const listReq = new ListProgrammersAvailableForUploadReq();
+        const listReq = new ListProgrammersAvailableForUploadRequest();
         listReq.setInstance(instance);
         listReq.setFqbn(fqbn);
-        const listResp = await new Promise<ListProgrammersAvailableForUploadResp>((resolve, reject) => client.listProgrammersAvailableForUpload(listReq, (err, resp) => {
+        const listResp = await new Promise<ListProgrammersAvailableForUploadResponse>((resolve, reject) => client.listProgrammersAvailableForUpload(listReq, (err, resp) => {
             if (err) {
                 reject(err);
                 return;
@@ -110,7 +116,7 @@ export class BoardsServiceImpl extends CoreClientAware implements BoardsService
 
         let VID = 'N/A';
         let PID = 'N/A';
-        const usbId = detailsResp.getIdentificationPrefList().map(item => item.getUsbid()).find(notEmpty);
+        const usbId = detailsResp.getIdentificationPrefsList().map(item => item.getUsbId()).find(notEmpty);
         if (usbId) {
             VID = usbId.getVid();
             PID = usbId.getPid();
@@ -147,7 +153,7 @@ export class BoardsServiceImpl extends CoreClientAware implements BoardsService
 
     async searchBoards({ query }: { query?: string }): Promise<BoardWithPackage[]> {
         const { instance, client } = await this.coreClient();
-        const req = new BoardSearchReq();
+        const req = new BoardSearchRequest();
         req.setSearchArgs(query || '');
         req.setInstance(instance);
         const boards = await new Promise<BoardWithPackage[]>((resolve, reject) => {
@@ -178,18 +184,18 @@ export class BoardsServiceImpl extends CoreClientAware implements BoardsService
         const coreClient = await this.coreClient();
         const { client, instance } = coreClient;
 
-        const installedPlatformsReq = new PlatformListReq();
+        const installedPlatformsReq = new PlatformListRequest();
         installedPlatformsReq.setInstance(instance);
-        const installedPlatformsResp = await new Promise<PlatformListResp>((resolve, reject) =>
+        const installedPlatformsResp = await new Promise<PlatformListResponse>((resolve, reject) =>
             client.platformList(installedPlatformsReq, (err, resp) => (!!err ? reject : resolve)(!!err ? err : resp))
         );
-        const installedPlatforms = installedPlatformsResp.getInstalledPlatformList();
+        const installedPlatforms = installedPlatformsResp.getInstalledPlatformsList();
 
-        const req = new PlatformSearchReq();
+        const req = new PlatformSearchRequest();
         req.setSearchArgs(options.query || '');
         req.setAllVersions(true);
         req.setInstance(instance);
-        const resp = await new Promise<PlatformSearchResp>((resolve, reject) => client.platformSearch(req, (err, resp) => (!!err ? reject : resolve)(!!err ? err : resp)));
+        const resp = await new Promise<PlatformSearchResponse>((resolve, reject) => client.platformSearch(req, (err, resp) => (!!err ? reject : resolve)(!!err ? err : resp)));
         const packages = new Map<string, BoardsPackage>();
         const toPackage = (platform: Platform) => {
             let installedVersion: string | undefined;
@@ -204,6 +210,7 @@ export class BoardsServiceImpl extends CoreClientAware implements BoardsService
                 availableVersions: [platform.getLatest()],
                 description: platform.getBoardsList().map(b => b.getName()).join(', '),
                 installable: true,
+                deprecated: platform.getDeprecated(),
                 summary: 'Boards included in this package:',
                 installedVersion,
                 boards: platform.getBoardsList().map(b => <Board>{ name: b.getName(), fqbn: b.getFqbn() }),
@@ -254,7 +261,7 @@ export class BoardsServiceImpl extends CoreClientAware implements BoardsService
         return [...packages.values()];
     }
 
-    async install(options: { item: BoardsPackage, version?: Installable.Version }): Promise<void> {
+    async install(options: { item: BoardsPackage, progressId?: string, version?: Installable.Version }): Promise<void> {
         const item = options.item;
         const version = !!options.version ? options.version : item.availableVersions[0];
         const coreClient = await this.coreClient();
@@ -262,7 +269,7 @@ export class BoardsServiceImpl extends CoreClientAware implements BoardsService
 
         const [platform, architecture] = item.id.split(':');
 
-        const req = new PlatformInstallReq();
+        const req = new PlatformInstallRequest();
         req.setInstance(instance);
         req.setArchitecture(architecture);
         req.setPlatformPackage(platform);
@@ -270,17 +277,12 @@ export class BoardsServiceImpl extends CoreClientAware implements BoardsService
 
         console.info('>>> Starting boards package installation...', item);
         const resp = client.platformInstall(req);
-        resp.on('data', (r: PlatformInstallResp) => {
-            const prog = r.getProgress();
-            if (prog && prog.getFile()) {
-                this.outputService.append({ chunk: `downloading ${prog.getFile()}\n` });
-            }
-        });
+        resp.on('data', InstallWithProgress.createDataCallback({ progressId: options.progressId, responseService: this.responseService }));
         await new Promise<void>((resolve, reject) => {
             resp.on('end', resolve);
             resp.on('error', error => {
-                this.outputService.append({ chunk: `Failed to install platform: ${item.id}.\n` });
-                this.outputService.append({ chunk: error.toString() });
+                this.responseService.appendToOutput({ chunk: `Failed to install platform: ${item.id}.\n` });
+                this.responseService.appendToOutput({ chunk: error.toString() });
                 reject(error);
             });
         });
@@ -291,27 +293,21 @@ export class BoardsServiceImpl extends CoreClientAware implements BoardsService
         console.info('<<< Boards package installation done.', item);
     }
 
-    async uninstall(options: { item: BoardsPackage }): Promise<void> {
-        const item = options.item;
+    async uninstall(options: { item: BoardsPackage, progressId?: string }): Promise<void> {
+        const { item, progressId } = options;
         const coreClient = await this.coreClient();
         const { client, instance } = coreClient;
 
         const [platform, architecture] = item.id.split(':');
 
-        const req = new PlatformUninstallReq();
+        const req = new PlatformUninstallRequest();
         req.setInstance(instance);
         req.setArchitecture(architecture);
         req.setPlatformPackage(platform);
 
         console.info('>>> Starting boards package uninstallation...', item);
-        let logged = false;
         const resp = client.platformUninstall(req);
-        resp.on('data', (_: PlatformUninstallResp) => {
-            if (!logged) {
-                this.outputService.append({ chunk: `uninstalling ${item.id}\n` });
-                logged = true;
-            }
-        })
+        resp.on('data', InstallWithProgress.createDataCallback({ progressId, responseService: this.responseService }));
         await new Promise<void>((resolve, reject) => {
             resp.on('end', resolve);
             resp.on('error', reject);

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/board_pb.d.ts

@@ -1,137 +1,133 @@
-// package: cc.arduino.cli.commands
-// file: commands/board.proto
+// package: cc.arduino.cli.commands.v1
+// file: cc/arduino/cli/commands/v1/board.proto
 
 /* tslint:disable */
 /* eslint-disable */
 
 import * as jspb from "google-protobuf";
-import * as commands_common_pb from "../commands/common_pb";
+import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino/cli/commands/v1/common_pb";
 
-export class BoardDetailsReq extends jspb.Message { 
+export class BoardDetailsRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): BoardDetailsReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): BoardDetailsRequest;
 
     getFqbn(): string;
-    setFqbn(value: string): BoardDetailsReq;
+    setFqbn(value: string): BoardDetailsRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BoardDetailsReq.AsObject;
-    static toObject(includeInstance: boolean, msg: BoardDetailsReq): BoardDetailsReq.AsObject;
+    toObject(includeInstance?: boolean): BoardDetailsRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: BoardDetailsRequest): BoardDetailsRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BoardDetailsReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BoardDetailsReq;
-    static deserializeBinaryFromReader(message: BoardDetailsReq, reader: jspb.BinaryReader): BoardDetailsReq;
+    static serializeBinaryToWriter(message: BoardDetailsRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BoardDetailsRequest;
+    static deserializeBinaryFromReader(message: BoardDetailsRequest, reader: jspb.BinaryReader): BoardDetailsRequest;
 }
 
-export namespace BoardDetailsReq {
+export namespace BoardDetailsRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         fqbn: string,
     }
 }
 
-export class BoardDetailsResp extends jspb.Message { 
+export class BoardDetailsResponse extends jspb.Message { 
     getFqbn(): string;
-    setFqbn(value: string): BoardDetailsResp;
+    setFqbn(value: string): BoardDetailsResponse;
 
     getName(): string;
-    setName(value: string): BoardDetailsResp;
+    setName(value: string): BoardDetailsResponse;
 
     getVersion(): string;
-    setVersion(value: string): BoardDetailsResp;
+    setVersion(value: string): BoardDetailsResponse;
 
-    getPropertiesid(): string;
-    setPropertiesid(value: string): BoardDetailsResp;
+    getPropertiesId(): string;
+    setPropertiesId(value: string): BoardDetailsResponse;
 
     getAlias(): string;
-    setAlias(value: string): BoardDetailsResp;
+    setAlias(value: string): BoardDetailsResponse;
 
     getOfficial(): boolean;
-    setOfficial(value: boolean): BoardDetailsResp;
+    setOfficial(value: boolean): BoardDetailsResponse;
 
     getPinout(): string;
-    setPinout(value: string): BoardDetailsResp;
+    setPinout(value: string): BoardDetailsResponse;
 
 
     hasPackage(): boolean;
     clearPackage(): void;
     getPackage(): Package | undefined;
-    setPackage(value?: Package): BoardDetailsResp;
+    setPackage(value?: Package): BoardDetailsResponse;
 
 
     hasPlatform(): boolean;
     clearPlatform(): void;
     getPlatform(): BoardPlatform | undefined;
-    setPlatform(value?: BoardPlatform): BoardDetailsResp;
+    setPlatform(value?: BoardPlatform): BoardDetailsResponse;
 
-    clearToolsdependenciesList(): void;
-    getToolsdependenciesList(): Array<ToolsDependencies>;
-    setToolsdependenciesList(value: Array<ToolsDependencies>): BoardDetailsResp;
-    addToolsdependencies(value?: ToolsDependencies, index?: number): ToolsDependencies;
+    clearToolsDependenciesList(): void;
+    getToolsDependenciesList(): Array<ToolsDependencies>;
+    setToolsDependenciesList(value: Array<ToolsDependencies>): BoardDetailsResponse;
+    addToolsDependencies(value?: ToolsDependencies, index?: number): ToolsDependencies;
 
     clearConfigOptionsList(): void;
     getConfigOptionsList(): Array<ConfigOption>;
-    setConfigOptionsList(value: Array<ConfigOption>): BoardDetailsResp;
+    setConfigOptionsList(value: Array<ConfigOption>): BoardDetailsResponse;
     addConfigOptions(value?: ConfigOption, index?: number): ConfigOption;
 
-    clearIdentificationPrefList(): void;
-    getIdentificationPrefList(): Array<IdentificationPref>;
-    setIdentificationPrefList(value: Array<IdentificationPref>): BoardDetailsResp;
-    addIdentificationPref(value?: IdentificationPref, index?: number): IdentificationPref;
+    clearIdentificationPrefsList(): void;
+    getIdentificationPrefsList(): Array<IdentificationPref>;
+    setIdentificationPrefsList(value: Array<IdentificationPref>): BoardDetailsResponse;
+    addIdentificationPrefs(value?: IdentificationPref, index?: number): IdentificationPref;
 
     clearProgrammersList(): void;
-    getProgrammersList(): Array<commands_common_pb.Programmer>;
-    setProgrammersList(value: Array<commands_common_pb.Programmer>): BoardDetailsResp;
-    addProgrammers(value?: commands_common_pb.Programmer, index?: number): commands_common_pb.Programmer;
+    getProgrammersList(): Array<cc_arduino_cli_commands_v1_common_pb.Programmer>;
+    setProgrammersList(value: Array<cc_arduino_cli_commands_v1_common_pb.Programmer>): BoardDetailsResponse;
+    addProgrammers(value?: cc_arduino_cli_commands_v1_common_pb.Programmer, index?: number): cc_arduino_cli_commands_v1_common_pb.Programmer;
 
     getDebuggingSupported(): boolean;
-    setDebuggingSupported(value: boolean): BoardDetailsResp;
-
-    getSerialnumber(): string;
-    setSerialnumber(value: string): BoardDetailsResp;
+    setDebuggingSupported(value: boolean): BoardDetailsResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BoardDetailsResp.AsObject;
-    static toObject(includeInstance: boolean, msg: BoardDetailsResp): BoardDetailsResp.AsObject;
+    toObject(includeInstance?: boolean): BoardDetailsResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: BoardDetailsResponse): BoardDetailsResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BoardDetailsResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BoardDetailsResp;
-    static deserializeBinaryFromReader(message: BoardDetailsResp, reader: jspb.BinaryReader): BoardDetailsResp;
+    static serializeBinaryToWriter(message: BoardDetailsResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BoardDetailsResponse;
+    static deserializeBinaryFromReader(message: BoardDetailsResponse, reader: jspb.BinaryReader): BoardDetailsResponse;
 }
 
-export namespace BoardDetailsResp {
+export namespace BoardDetailsResponse {
     export type AsObject = {
         fqbn: string,
         name: string,
         version: string,
-        propertiesid: string,
+        propertiesId: string,
         alias: string,
         official: boolean,
         pinout: string,
         pb_package?: Package.AsObject,
         platform?: BoardPlatform.AsObject,
-        toolsdependenciesList: Array<ToolsDependencies.AsObject>,
+        toolsDependenciesList: Array<ToolsDependencies.AsObject>,
         configOptionsList: Array<ConfigOption.AsObject>,
-        identificationPrefList: Array<IdentificationPref.AsObject>,
-        programmersList: Array<commands_common_pb.Programmer.AsObject>,
+        identificationPrefsList: Array<IdentificationPref.AsObject>,
+        programmersList: Array<cc_arduino_cli_commands_v1_common_pb.Programmer.AsObject>,
         debuggingSupported: boolean,
-        serialnumber: string,
     }
 }
 
 export class IdentificationPref extends jspb.Message { 
 
-    hasUsbid(): boolean;
-    clearUsbid(): void;
-    getUsbid(): USBID | undefined;
-    setUsbid(value?: USBID): IdentificationPref;
+    hasUsbId(): boolean;
+    clearUsbId(): void;
+    getUsbId(): USBID | undefined;
+    setUsbId(value?: USBID): IdentificationPref;
 
 
     serializeBinary(): Uint8Array;
@@ -146,7 +142,7 @@ export class IdentificationPref extends jspb.Message {
 
 export namespace IdentificationPref {
     export type AsObject = {
-        usbid?: USBID.AsObject,
+        usbId?: USBID.AsObject,
     }
 }
 
@@ -182,8 +178,8 @@ export class Package extends jspb.Message {
     getUrl(): string;
     setUrl(value: string): Package;
 
-    getWebsiteurl(): string;
-    setWebsiteurl(value: string): Package;
+    getWebsiteUrl(): string;
+    setWebsiteUrl(value: string): Package;
 
     getEmail(): string;
     setEmail(value: string): Package;
@@ -212,7 +208,7 @@ export namespace Package {
     export type AsObject = {
         maintainer: string,
         url: string,
-        websiteurl: string,
+        websiteUrl: string,
         email: string,
         name: string,
         help?: Help.AsObject,
@@ -250,8 +246,8 @@ export class BoardPlatform extends jspb.Message {
     getUrl(): string;
     setUrl(value: string): BoardPlatform;
 
-    getArchivefilename(): string;
-    setArchivefilename(value: string): BoardPlatform;
+    getArchiveFilename(): string;
+    setArchiveFilename(value: string): BoardPlatform;
 
     getChecksum(): string;
     setChecksum(value: string): BoardPlatform;
@@ -278,7 +274,7 @@ export namespace BoardPlatform {
         architecture: string,
         category: string,
         url: string,
-        archivefilename: string,
+        archiveFilename: string,
         checksum: string,
         size: number,
         name: string,
@@ -327,8 +323,8 @@ export class Systems extends jspb.Message {
     getHost(): string;
     setHost(value: string): Systems;
 
-    getArchivefilename(): string;
-    setArchivefilename(value: string): Systems;
+    getArchiveFilename(): string;
+    setArchiveFilename(value: string): Systems;
 
     getUrl(): string;
     setUrl(value: string): Systems;
@@ -351,7 +347,7 @@ export namespace Systems {
     export type AsObject = {
         checksum: string,
         host: string,
-        archivefilename: string,
+        archiveFilename: string,
         url: string,
         size: number,
     }
@@ -417,108 +413,108 @@ export namespace ConfigValue {
     }
 }
 
-export class BoardAttachReq extends jspb.Message { 
+export class BoardAttachRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): BoardAttachReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): BoardAttachRequest;
 
     getBoardUri(): string;
-    setBoardUri(value: string): BoardAttachReq;
+    setBoardUri(value: string): BoardAttachRequest;
 
     getSketchPath(): string;
-    setSketchPath(value: string): BoardAttachReq;
+    setSketchPath(value: string): BoardAttachRequest;
 
     getSearchTimeout(): string;
-    setSearchTimeout(value: string): BoardAttachReq;
+    setSearchTimeout(value: string): BoardAttachRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BoardAttachReq.AsObject;
-    static toObject(includeInstance: boolean, msg: BoardAttachReq): BoardAttachReq.AsObject;
+    toObject(includeInstance?: boolean): BoardAttachRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: BoardAttachRequest): BoardAttachRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BoardAttachReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BoardAttachReq;
-    static deserializeBinaryFromReader(message: BoardAttachReq, reader: jspb.BinaryReader): BoardAttachReq;
+    static serializeBinaryToWriter(message: BoardAttachRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BoardAttachRequest;
+    static deserializeBinaryFromReader(message: BoardAttachRequest, reader: jspb.BinaryReader): BoardAttachRequest;
 }
 
-export namespace BoardAttachReq {
+export namespace BoardAttachRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         boardUri: string,
         sketchPath: string,
         searchTimeout: string,
     }
 }
 
-export class BoardAttachResp extends jspb.Message { 
+export class BoardAttachResponse extends jspb.Message { 
 
     hasTaskProgress(): boolean;
     clearTaskProgress(): void;
-    getTaskProgress(): commands_common_pb.TaskProgress | undefined;
-    setTaskProgress(value?: commands_common_pb.TaskProgress): BoardAttachResp;
+    getTaskProgress(): cc_arduino_cli_commands_v1_common_pb.TaskProgress | undefined;
+    setTaskProgress(value?: cc_arduino_cli_commands_v1_common_pb.TaskProgress): BoardAttachResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BoardAttachResp.AsObject;
-    static toObject(includeInstance: boolean, msg: BoardAttachResp): BoardAttachResp.AsObject;
+    toObject(includeInstance?: boolean): BoardAttachResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: BoardAttachResponse): BoardAttachResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BoardAttachResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BoardAttachResp;
-    static deserializeBinaryFromReader(message: BoardAttachResp, reader: jspb.BinaryReader): BoardAttachResp;
+    static serializeBinaryToWriter(message: BoardAttachResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BoardAttachResponse;
+    static deserializeBinaryFromReader(message: BoardAttachResponse, reader: jspb.BinaryReader): BoardAttachResponse;
 }
 
-export namespace BoardAttachResp {
+export namespace BoardAttachResponse {
     export type AsObject = {
-        taskProgress?: commands_common_pb.TaskProgress.AsObject,
+        taskProgress?: cc_arduino_cli_commands_v1_common_pb.TaskProgress.AsObject,
     }
 }
 
-export class BoardListReq extends jspb.Message { 
+export class BoardListRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): BoardListReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): BoardListRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BoardListReq.AsObject;
-    static toObject(includeInstance: boolean, msg: BoardListReq): BoardListReq.AsObject;
+    toObject(includeInstance?: boolean): BoardListRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: BoardListRequest): BoardListRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BoardListReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BoardListReq;
-    static deserializeBinaryFromReader(message: BoardListReq, reader: jspb.BinaryReader): BoardListReq;
+    static serializeBinaryToWriter(message: BoardListRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BoardListRequest;
+    static deserializeBinaryFromReader(message: BoardListRequest, reader: jspb.BinaryReader): BoardListRequest;
 }
 
-export namespace BoardListReq {
+export namespace BoardListRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
     }
 }
 
-export class BoardListResp extends jspb.Message { 
+export class BoardListResponse extends jspb.Message { 
     clearPortsList(): void;
     getPortsList(): Array<DetectedPort>;
-    setPortsList(value: Array<DetectedPort>): BoardListResp;
+    setPortsList(value: Array<DetectedPort>): BoardListResponse;
     addPorts(value?: DetectedPort, index?: number): DetectedPort;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BoardListResp.AsObject;
-    static toObject(includeInstance: boolean, msg: BoardListResp): BoardListResp.AsObject;
+    toObject(includeInstance?: boolean): BoardListResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: BoardListResponse): BoardListResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BoardListResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BoardListResp;
-    static deserializeBinaryFromReader(message: BoardListResp, reader: jspb.BinaryReader): BoardListResp;
+    static serializeBinaryToWriter(message: BoardListResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BoardListResponse;
+    static deserializeBinaryFromReader(message: BoardListResponse, reader: jspb.BinaryReader): BoardListResponse;
 }
 
-export namespace BoardListResp {
+export namespace BoardListResponse {
     export type AsObject = {
         portsList: Array<DetectedPort.AsObject>,
     }
@@ -563,116 +559,116 @@ export namespace DetectedPort {
     }
 }
 
-export class BoardListAllReq extends jspb.Message { 
+export class BoardListAllRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): BoardListAllReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): BoardListAllRequest;
 
     clearSearchArgsList(): void;
     getSearchArgsList(): Array<string>;
-    setSearchArgsList(value: Array<string>): BoardListAllReq;
+    setSearchArgsList(value: Array<string>): BoardListAllRequest;
     addSearchArgs(value: string, index?: number): string;
 
     getIncludeHiddenBoards(): boolean;
-    setIncludeHiddenBoards(value: boolean): BoardListAllReq;
+    setIncludeHiddenBoards(value: boolean): BoardListAllRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BoardListAllReq.AsObject;
-    static toObject(includeInstance: boolean, msg: BoardListAllReq): BoardListAllReq.AsObject;
+    toObject(includeInstance?: boolean): BoardListAllRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: BoardListAllRequest): BoardListAllRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BoardListAllReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BoardListAllReq;
-    static deserializeBinaryFromReader(message: BoardListAllReq, reader: jspb.BinaryReader): BoardListAllReq;
+    static serializeBinaryToWriter(message: BoardListAllRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BoardListAllRequest;
+    static deserializeBinaryFromReader(message: BoardListAllRequest, reader: jspb.BinaryReader): BoardListAllRequest;
 }
 
-export namespace BoardListAllReq {
+export namespace BoardListAllRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         searchArgsList: Array<string>,
         includeHiddenBoards: boolean,
     }
 }
 
-export class BoardListAllResp extends jspb.Message { 
+export class BoardListAllResponse extends jspb.Message { 
     clearBoardsList(): void;
     getBoardsList(): Array<BoardListItem>;
-    setBoardsList(value: Array<BoardListItem>): BoardListAllResp;
+    setBoardsList(value: Array<BoardListItem>): BoardListAllResponse;
     addBoards(value?: BoardListItem, index?: number): BoardListItem;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BoardListAllResp.AsObject;
-    static toObject(includeInstance: boolean, msg: BoardListAllResp): BoardListAllResp.AsObject;
+    toObject(includeInstance?: boolean): BoardListAllResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: BoardListAllResponse): BoardListAllResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BoardListAllResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BoardListAllResp;
-    static deserializeBinaryFromReader(message: BoardListAllResp, reader: jspb.BinaryReader): BoardListAllResp;
+    static serializeBinaryToWriter(message: BoardListAllResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BoardListAllResponse;
+    static deserializeBinaryFromReader(message: BoardListAllResponse, reader: jspb.BinaryReader): BoardListAllResponse;
 }
 
-export namespace BoardListAllResp {
+export namespace BoardListAllResponse {
     export type AsObject = {
         boardsList: Array<BoardListItem.AsObject>,
     }
 }
 
-export class BoardListWatchReq extends jspb.Message { 
+export class BoardListWatchRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): BoardListWatchReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): BoardListWatchRequest;
 
     getInterrupt(): boolean;
-    setInterrupt(value: boolean): BoardListWatchReq;
+    setInterrupt(value: boolean): BoardListWatchRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BoardListWatchReq.AsObject;
-    static toObject(includeInstance: boolean, msg: BoardListWatchReq): BoardListWatchReq.AsObject;
+    toObject(includeInstance?: boolean): BoardListWatchRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: BoardListWatchRequest): BoardListWatchRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BoardListWatchReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BoardListWatchReq;
-    static deserializeBinaryFromReader(message: BoardListWatchReq, reader: jspb.BinaryReader): BoardListWatchReq;
+    static serializeBinaryToWriter(message: BoardListWatchRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BoardListWatchRequest;
+    static deserializeBinaryFromReader(message: BoardListWatchRequest, reader: jspb.BinaryReader): BoardListWatchRequest;
 }
 
-export namespace BoardListWatchReq {
+export namespace BoardListWatchRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         interrupt: boolean,
     }
 }
 
-export class BoardListWatchResp extends jspb.Message { 
+export class BoardListWatchResponse extends jspb.Message { 
     getEventType(): string;
-    setEventType(value: string): BoardListWatchResp;
+    setEventType(value: string): BoardListWatchResponse;
 
 
     hasPort(): boolean;
     clearPort(): void;
     getPort(): DetectedPort | undefined;
-    setPort(value?: DetectedPort): BoardListWatchResp;
+    setPort(value?: DetectedPort): BoardListWatchResponse;
 
     getError(): string;
-    setError(value: string): BoardListWatchResp;
+    setError(value: string): BoardListWatchResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BoardListWatchResp.AsObject;
-    static toObject(includeInstance: boolean, msg: BoardListWatchResp): BoardListWatchResp.AsObject;
+    toObject(includeInstance?: boolean): BoardListWatchResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: BoardListWatchResponse): BoardListWatchResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BoardListWatchResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BoardListWatchResp;
-    static deserializeBinaryFromReader(message: BoardListWatchResp, reader: jspb.BinaryReader): BoardListWatchResp;
+    static serializeBinaryToWriter(message: BoardListWatchResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BoardListWatchResponse;
+    static deserializeBinaryFromReader(message: BoardListWatchResponse, reader: jspb.BinaryReader): BoardListWatchResponse;
 }
 
-export namespace BoardListWatchResp {
+export namespace BoardListWatchResponse {
     export type AsObject = {
         eventType: string,
         port?: DetectedPort.AsObject,
@@ -699,8 +695,8 @@ export class BoardListItem extends jspb.Message {
 
     hasPlatform(): boolean;
     clearPlatform(): void;
-    getPlatform(): commands_common_pb.Platform | undefined;
-    setPlatform(value?: commands_common_pb.Platform): BoardListItem;
+    getPlatform(): cc_arduino_cli_commands_v1_common_pb.Platform | undefined;
+    setPlatform(value?: cc_arduino_cli_commands_v1_common_pb.Platform): BoardListItem;
 
 
     serializeBinary(): Uint8Array;
@@ -720,60 +716,60 @@ export namespace BoardListItem {
         isHidden: boolean,
         vid: string,
         pid: string,
-        platform?: commands_common_pb.Platform.AsObject,
+        platform?: cc_arduino_cli_commands_v1_common_pb.Platform.AsObject,
     }
 }
 
-export class BoardSearchReq extends jspb.Message { 
+export class BoardSearchRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): BoardSearchReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): BoardSearchRequest;
 
     getSearchArgs(): string;
-    setSearchArgs(value: string): BoardSearchReq;
+    setSearchArgs(value: string): BoardSearchRequest;
 
     getIncludeHiddenBoards(): boolean;
-    setIncludeHiddenBoards(value: boolean): BoardSearchReq;
+    setIncludeHiddenBoards(value: boolean): BoardSearchRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BoardSearchReq.AsObject;
-    static toObject(includeInstance: boolean, msg: BoardSearchReq): BoardSearchReq.AsObject;
+    toObject(includeInstance?: boolean): BoardSearchRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: BoardSearchRequest): BoardSearchRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BoardSearchReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BoardSearchReq;
-    static deserializeBinaryFromReader(message: BoardSearchReq, reader: jspb.BinaryReader): BoardSearchReq;
+    static serializeBinaryToWriter(message: BoardSearchRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BoardSearchRequest;
+    static deserializeBinaryFromReader(message: BoardSearchRequest, reader: jspb.BinaryReader): BoardSearchRequest;
 }
 
-export namespace BoardSearchReq {
+export namespace BoardSearchRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         searchArgs: string,
         includeHiddenBoards: boolean,
     }
 }
 
-export class BoardSearchResp extends jspb.Message { 
+export class BoardSearchResponse extends jspb.Message { 
     clearBoardsList(): void;
     getBoardsList(): Array<BoardListItem>;
-    setBoardsList(value: Array<BoardListItem>): BoardSearchResp;
+    setBoardsList(value: Array<BoardListItem>): BoardSearchResponse;
     addBoards(value?: BoardListItem, index?: number): BoardListItem;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BoardSearchResp.AsObject;
-    static toObject(includeInstance: boolean, msg: BoardSearchResp): BoardSearchResp.AsObject;
+    toObject(includeInstance?: boolean): BoardSearchResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: BoardSearchResponse): BoardSearchResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BoardSearchResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BoardSearchResp;
-    static deserializeBinaryFromReader(message: BoardSearchResp, reader: jspb.BinaryReader): BoardSearchResp;
+    static serializeBinaryToWriter(message: BoardSearchResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BoardSearchResponse;
+    static deserializeBinaryFromReader(message: BoardSearchResponse, reader: jspb.BinaryReader): BoardSearchResponse;
 }
 
-export namespace BoardSearchResp {
+export namespace BoardSearchResponse {
     export type AsObject = {
         boardsList: Array<BoardListItem.AsObject>,
     }

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/commands_grpc_pb.d.ts

@@ -0,0 +1,619 @@
+// package: cc.arduino.cli.commands.v1
+// file: cc/arduino/cli/commands/v1/commands.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as grpc from "@grpc/grpc-js";
+import {handleClientStreamingCall} from "@grpc/grpc-js/build/src/server-call";
+import * as cc_arduino_cli_commands_v1_commands_pb from "../../../../../cc/arduino/cli/commands/v1/commands_pb";
+import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino/cli/commands/v1/common_pb";
+import * as cc_arduino_cli_commands_v1_board_pb from "../../../../../cc/arduino/cli/commands/v1/board_pb";
+import * as cc_arduino_cli_commands_v1_compile_pb from "../../../../../cc/arduino/cli/commands/v1/compile_pb";
+import * as cc_arduino_cli_commands_v1_core_pb from "../../../../../cc/arduino/cli/commands/v1/core_pb";
+import * as cc_arduino_cli_commands_v1_upload_pb from "../../../../../cc/arduino/cli/commands/v1/upload_pb";
+import * as cc_arduino_cli_commands_v1_lib_pb from "../../../../../cc/arduino/cli/commands/v1/lib_pb";
+
+interface IArduinoCoreServiceService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+    init: IArduinoCoreServiceService_IInit;
+    destroy: IArduinoCoreServiceService_IDestroy;
+    rescan: IArduinoCoreServiceService_IRescan;
+    updateIndex: IArduinoCoreServiceService_IUpdateIndex;
+    updateLibrariesIndex: IArduinoCoreServiceService_IUpdateLibrariesIndex;
+    updateCoreLibrariesIndex: IArduinoCoreServiceService_IUpdateCoreLibrariesIndex;
+    outdated: IArduinoCoreServiceService_IOutdated;
+    upgrade: IArduinoCoreServiceService_IUpgrade;
+    version: IArduinoCoreServiceService_IVersion;
+    loadSketch: IArduinoCoreServiceService_ILoadSketch;
+    archiveSketch: IArduinoCoreServiceService_IArchiveSketch;
+    boardDetails: IArduinoCoreServiceService_IBoardDetails;
+    boardAttach: IArduinoCoreServiceService_IBoardAttach;
+    boardList: IArduinoCoreServiceService_IBoardList;
+    boardListAll: IArduinoCoreServiceService_IBoardListAll;
+    boardSearch: IArduinoCoreServiceService_IBoardSearch;
+    boardListWatch: IArduinoCoreServiceService_IBoardListWatch;
+    compile: IArduinoCoreServiceService_ICompile;
+    platformInstall: IArduinoCoreServiceService_IPlatformInstall;
+    platformDownload: IArduinoCoreServiceService_IPlatformDownload;
+    platformUninstall: IArduinoCoreServiceService_IPlatformUninstall;
+    platformUpgrade: IArduinoCoreServiceService_IPlatformUpgrade;
+    upload: IArduinoCoreServiceService_IUpload;
+    uploadUsingProgrammer: IArduinoCoreServiceService_IUploadUsingProgrammer;
+    listProgrammersAvailableForUpload: IArduinoCoreServiceService_IListProgrammersAvailableForUpload;
+    burnBootloader: IArduinoCoreServiceService_IBurnBootloader;
+    platformSearch: IArduinoCoreServiceService_IPlatformSearch;
+    platformList: IArduinoCoreServiceService_IPlatformList;
+    libraryDownload: IArduinoCoreServiceService_ILibraryDownload;
+    libraryInstall: IArduinoCoreServiceService_ILibraryInstall;
+    zipLibraryInstall: IArduinoCoreServiceService_IZipLibraryInstall;
+    gitLibraryInstall: IArduinoCoreServiceService_IGitLibraryInstall;
+    libraryUninstall: IArduinoCoreServiceService_ILibraryUninstall;
+    libraryUpgradeAll: IArduinoCoreServiceService_ILibraryUpgradeAll;
+    libraryResolveDependencies: IArduinoCoreServiceService_ILibraryResolveDependencies;
+    librarySearch: IArduinoCoreServiceService_ILibrarySearch;
+    libraryList: IArduinoCoreServiceService_ILibraryList;
+}
+
+interface IArduinoCoreServiceService_IInit extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_commands_pb.InitRequest, cc_arduino_cli_commands_v1_commands_pb.InitResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/Init";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.InitRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.InitRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.InitResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.InitResponse>;
+}
+interface IArduinoCoreServiceService_IDestroy extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_commands_pb.DestroyRequest, cc_arduino_cli_commands_v1_commands_pb.DestroyResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/Destroy";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.DestroyRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.DestroyRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.DestroyResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.DestroyResponse>;
+}
+interface IArduinoCoreServiceService_IRescan extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_commands_pb.RescanRequest, cc_arduino_cli_commands_v1_commands_pb.RescanResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/Rescan";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.RescanRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.RescanRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.RescanResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.RescanResponse>;
+}
+interface IArduinoCoreServiceService_IUpdateIndex extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_commands_pb.UpdateIndexRequest, cc_arduino_cli_commands_v1_commands_pb.UpdateIndexResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/UpdateIndex";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.UpdateIndexRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.UpdateIndexRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.UpdateIndexResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.UpdateIndexResponse>;
+}
+interface IArduinoCoreServiceService_IUpdateLibrariesIndex extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexRequest, cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/UpdateLibrariesIndex";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexResponse>;
+}
+interface IArduinoCoreServiceService_IUpdateCoreLibrariesIndex extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexRequest, cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/UpdateCoreLibrariesIndex";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexResponse>;
+}
+interface IArduinoCoreServiceService_IOutdated extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_commands_pb.OutdatedRequest, cc_arduino_cli_commands_v1_commands_pb.OutdatedResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/Outdated";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.OutdatedRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.OutdatedRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.OutdatedResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.OutdatedResponse>;
+}
+interface IArduinoCoreServiceService_IUpgrade extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_commands_pb.UpgradeRequest, cc_arduino_cli_commands_v1_commands_pb.UpgradeResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/Upgrade";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.UpgradeRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.UpgradeRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.UpgradeResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.UpgradeResponse>;
+}
+interface IArduinoCoreServiceService_IVersion extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_commands_pb.VersionRequest, cc_arduino_cli_commands_v1_commands_pb.VersionResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/Version";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.VersionRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.VersionRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.VersionResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.VersionResponse>;
+}
+interface IArduinoCoreServiceService_ILoadSketch extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_commands_pb.LoadSketchRequest, cc_arduino_cli_commands_v1_commands_pb.LoadSketchResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/LoadSketch";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.LoadSketchRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.LoadSketchRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.LoadSketchResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.LoadSketchResponse>;
+}
+interface IArduinoCoreServiceService_IArchiveSketch extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchRequest, cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/ArchiveSketch";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchResponse>;
+}
+interface IArduinoCoreServiceService_IBoardDetails extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_board_pb.BoardDetailsRequest, cc_arduino_cli_commands_v1_board_pb.BoardDetailsResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/BoardDetails";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_board_pb.BoardDetailsRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_board_pb.BoardDetailsRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_board_pb.BoardDetailsResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_board_pb.BoardDetailsResponse>;
+}
+interface IArduinoCoreServiceService_IBoardAttach extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_board_pb.BoardAttachRequest, cc_arduino_cli_commands_v1_board_pb.BoardAttachResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/BoardAttach";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_board_pb.BoardAttachRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_board_pb.BoardAttachRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_board_pb.BoardAttachResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_board_pb.BoardAttachResponse>;
+}
+interface IArduinoCoreServiceService_IBoardList extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_board_pb.BoardListRequest, cc_arduino_cli_commands_v1_board_pb.BoardListResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/BoardList";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_board_pb.BoardListRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_board_pb.BoardListRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_board_pb.BoardListResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_board_pb.BoardListResponse>;
+}
+interface IArduinoCoreServiceService_IBoardListAll extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_board_pb.BoardListAllRequest, cc_arduino_cli_commands_v1_board_pb.BoardListAllResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/BoardListAll";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_board_pb.BoardListAllRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_board_pb.BoardListAllRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_board_pb.BoardListAllResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_board_pb.BoardListAllResponse>;
+}
+interface IArduinoCoreServiceService_IBoardSearch extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/BoardSearch";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse>;
+}
+interface IArduinoCoreServiceService_IBoardListWatch extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/BoardListWatch";
+    requestStream: true;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
+}
+interface IArduinoCoreServiceService_ICompile extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_compile_pb.CompileRequest, cc_arduino_cli_commands_v1_compile_pb.CompileResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/Compile";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_compile_pb.CompileRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_compile_pb.CompileRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_compile_pb.CompileResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_compile_pb.CompileResponse>;
+}
+interface IArduinoCoreServiceService_IPlatformInstall extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_core_pb.PlatformInstallRequest, cc_arduino_cli_commands_v1_core_pb.PlatformInstallResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/PlatformInstall";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_core_pb.PlatformInstallRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_core_pb.PlatformInstallRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_core_pb.PlatformInstallResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_core_pb.PlatformInstallResponse>;
+}
+interface IArduinoCoreServiceService_IPlatformDownload extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_core_pb.PlatformDownloadRequest, cc_arduino_cli_commands_v1_core_pb.PlatformDownloadResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/PlatformDownload";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_core_pb.PlatformDownloadRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_core_pb.PlatformDownloadRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_core_pb.PlatformDownloadResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_core_pb.PlatformDownloadResponse>;
+}
+interface IArduinoCoreServiceService_IPlatformUninstall extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_core_pb.PlatformUninstallRequest, cc_arduino_cli_commands_v1_core_pb.PlatformUninstallResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/PlatformUninstall";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_core_pb.PlatformUninstallRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_core_pb.PlatformUninstallRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_core_pb.PlatformUninstallResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_core_pb.PlatformUninstallResponse>;
+}
+interface IArduinoCoreServiceService_IPlatformUpgrade extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeRequest, cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/PlatformUpgrade";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeResponse>;
+}
+interface IArduinoCoreServiceService_IUpload extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_upload_pb.UploadRequest, cc_arduino_cli_commands_v1_upload_pb.UploadResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/Upload";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_upload_pb.UploadRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_upload_pb.UploadRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_upload_pb.UploadResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_upload_pb.UploadResponse>;
+}
+interface IArduinoCoreServiceService_IUploadUsingProgrammer extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerRequest, cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/UploadUsingProgrammer";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerResponse>;
+}
+interface IArduinoCoreServiceService_IListProgrammersAvailableForUpload extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadRequest, cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/ListProgrammersAvailableForUpload";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadResponse>;
+}
+interface IArduinoCoreServiceService_IBurnBootloader extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderRequest, cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/BurnBootloader";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderResponse>;
+}
+interface IArduinoCoreServiceService_IPlatformSearch extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_core_pb.PlatformSearchRequest, cc_arduino_cli_commands_v1_core_pb.PlatformSearchResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/PlatformSearch";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_core_pb.PlatformSearchRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_core_pb.PlatformSearchRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_core_pb.PlatformSearchResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_core_pb.PlatformSearchResponse>;
+}
+interface IArduinoCoreServiceService_IPlatformList extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_core_pb.PlatformListRequest, cc_arduino_cli_commands_v1_core_pb.PlatformListResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/PlatformList";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_core_pb.PlatformListRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_core_pb.PlatformListRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_core_pb.PlatformListResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_core_pb.PlatformListResponse>;
+}
+interface IArduinoCoreServiceService_ILibraryDownload extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadRequest, cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/LibraryDownload";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadResponse>;
+}
+interface IArduinoCoreServiceService_ILibraryInstall extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_lib_pb.LibraryInstallRequest, cc_arduino_cli_commands_v1_lib_pb.LibraryInstallResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/LibraryInstall";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibraryInstallRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibraryInstallRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibraryInstallResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibraryInstallResponse>;
+}
+interface IArduinoCoreServiceService_IZipLibraryInstall extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallRequest, cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/ZipLibraryInstall";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallResponse>;
+}
+interface IArduinoCoreServiceService_IGitLibraryInstall extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallRequest, cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/GitLibraryInstall";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallResponse>;
+}
+interface IArduinoCoreServiceService_ILibraryUninstall extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallRequest, cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/LibraryUninstall";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallResponse>;
+}
+interface IArduinoCoreServiceService_ILibraryUpgradeAll extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllRequest, cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/LibraryUpgradeAll";
+    requestStream: false;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllResponse>;
+}
+interface IArduinoCoreServiceService_ILibraryResolveDependencies extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesRequest, cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/LibraryResolveDependencies";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesResponse>;
+}
+interface IArduinoCoreServiceService_ILibrarySearch extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_lib_pb.LibrarySearchRequest, cc_arduino_cli_commands_v1_lib_pb.LibrarySearchResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/LibrarySearch";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibrarySearchRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibrarySearchRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibrarySearchResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibrarySearchResponse>;
+}
+interface IArduinoCoreServiceService_ILibraryList extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_lib_pb.LibraryListRequest, cc_arduino_cli_commands_v1_lib_pb.LibraryListResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/LibraryList";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibraryListRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibraryListRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_lib_pb.LibraryListResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_lib_pb.LibraryListResponse>;
+}
+
+export const ArduinoCoreServiceService: IArduinoCoreServiceService;
+
+export interface IArduinoCoreServiceServer {
+    init: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_commands_pb.InitRequest, cc_arduino_cli_commands_v1_commands_pb.InitResponse>;
+    destroy: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_commands_pb.DestroyRequest, cc_arduino_cli_commands_v1_commands_pb.DestroyResponse>;
+    rescan: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_commands_pb.RescanRequest, cc_arduino_cli_commands_v1_commands_pb.RescanResponse>;
+    updateIndex: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_commands_pb.UpdateIndexRequest, cc_arduino_cli_commands_v1_commands_pb.UpdateIndexResponse>;
+    updateLibrariesIndex: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexRequest, cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexResponse>;
+    updateCoreLibrariesIndex: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexRequest, cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexResponse>;
+    outdated: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_commands_pb.OutdatedRequest, cc_arduino_cli_commands_v1_commands_pb.OutdatedResponse>;
+    upgrade: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_commands_pb.UpgradeRequest, cc_arduino_cli_commands_v1_commands_pb.UpgradeResponse>;
+    version: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_commands_pb.VersionRequest, cc_arduino_cli_commands_v1_commands_pb.VersionResponse>;
+    loadSketch: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_commands_pb.LoadSketchRequest, cc_arduino_cli_commands_v1_commands_pb.LoadSketchResponse>;
+    archiveSketch: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchRequest, cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchResponse>;
+    boardDetails: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_board_pb.BoardDetailsRequest, cc_arduino_cli_commands_v1_board_pb.BoardDetailsResponse>;
+    boardAttach: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_board_pb.BoardAttachRequest, cc_arduino_cli_commands_v1_board_pb.BoardAttachResponse>;
+    boardList: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_board_pb.BoardListRequest, cc_arduino_cli_commands_v1_board_pb.BoardListResponse>;
+    boardListAll: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_board_pb.BoardListAllRequest, cc_arduino_cli_commands_v1_board_pb.BoardListAllResponse>;
+    boardSearch: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse>;
+    boardListWatch: grpc.handleBidiStreamingCall<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
+    compile: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_compile_pb.CompileRequest, cc_arduino_cli_commands_v1_compile_pb.CompileResponse>;
+    platformInstall: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_core_pb.PlatformInstallRequest, cc_arduino_cli_commands_v1_core_pb.PlatformInstallResponse>;
+    platformDownload: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_core_pb.PlatformDownloadRequest, cc_arduino_cli_commands_v1_core_pb.PlatformDownloadResponse>;
+    platformUninstall: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_core_pb.PlatformUninstallRequest, cc_arduino_cli_commands_v1_core_pb.PlatformUninstallResponse>;
+    platformUpgrade: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeRequest, cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeResponse>;
+    upload: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_upload_pb.UploadRequest, cc_arduino_cli_commands_v1_upload_pb.UploadResponse>;
+    uploadUsingProgrammer: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerRequest, cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerResponse>;
+    listProgrammersAvailableForUpload: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadRequest, cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadResponse>;
+    burnBootloader: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderRequest, cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderResponse>;
+    platformSearch: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_core_pb.PlatformSearchRequest, cc_arduino_cli_commands_v1_core_pb.PlatformSearchResponse>;
+    platformList: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_core_pb.PlatformListRequest, cc_arduino_cli_commands_v1_core_pb.PlatformListResponse>;
+    libraryDownload: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadRequest, cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadResponse>;
+    libraryInstall: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_lib_pb.LibraryInstallRequest, cc_arduino_cli_commands_v1_lib_pb.LibraryInstallResponse>;
+    zipLibraryInstall: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallRequest, cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallResponse>;
+    gitLibraryInstall: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallRequest, cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallResponse>;
+    libraryUninstall: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallRequest, cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallResponse>;
+    libraryUpgradeAll: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllRequest, cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllResponse>;
+    libraryResolveDependencies: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesRequest, cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesResponse>;
+    librarySearch: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_lib_pb.LibrarySearchRequest, cc_arduino_cli_commands_v1_lib_pb.LibrarySearchResponse>;
+    libraryList: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_lib_pb.LibraryListRequest, cc_arduino_cli_commands_v1_lib_pb.LibraryListResponse>;
+}
+
+export interface IArduinoCoreServiceClient {
+    init(request: cc_arduino_cli_commands_v1_commands_pb.InitRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.InitResponse>;
+    init(request: cc_arduino_cli_commands_v1_commands_pb.InitRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.InitResponse>;
+    destroy(request: cc_arduino_cli_commands_v1_commands_pb.DestroyRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.DestroyResponse) => void): grpc.ClientUnaryCall;
+    destroy(request: cc_arduino_cli_commands_v1_commands_pb.DestroyRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.DestroyResponse) => void): grpc.ClientUnaryCall;
+    destroy(request: cc_arduino_cli_commands_v1_commands_pb.DestroyRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.DestroyResponse) => void): grpc.ClientUnaryCall;
+    rescan(request: cc_arduino_cli_commands_v1_commands_pb.RescanRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.RescanResponse) => void): grpc.ClientUnaryCall;
+    rescan(request: cc_arduino_cli_commands_v1_commands_pb.RescanRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.RescanResponse) => void): grpc.ClientUnaryCall;
+    rescan(request: cc_arduino_cli_commands_v1_commands_pb.RescanRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.RescanResponse) => void): grpc.ClientUnaryCall;
+    updateIndex(request: cc_arduino_cli_commands_v1_commands_pb.UpdateIndexRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpdateIndexResponse>;
+    updateIndex(request: cc_arduino_cli_commands_v1_commands_pb.UpdateIndexRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpdateIndexResponse>;
+    updateLibrariesIndex(request: cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexResponse>;
+    updateLibrariesIndex(request: cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexResponse>;
+    updateCoreLibrariesIndex(request: cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexResponse>;
+    updateCoreLibrariesIndex(request: cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexResponse>;
+    outdated(request: cc_arduino_cli_commands_v1_commands_pb.OutdatedRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.OutdatedResponse) => void): grpc.ClientUnaryCall;
+    outdated(request: cc_arduino_cli_commands_v1_commands_pb.OutdatedRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.OutdatedResponse) => void): grpc.ClientUnaryCall;
+    outdated(request: cc_arduino_cli_commands_v1_commands_pb.OutdatedRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.OutdatedResponse) => void): grpc.ClientUnaryCall;
+    upgrade(request: cc_arduino_cli_commands_v1_commands_pb.UpgradeRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpgradeResponse>;
+    upgrade(request: cc_arduino_cli_commands_v1_commands_pb.UpgradeRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpgradeResponse>;
+    version(request: cc_arduino_cli_commands_v1_commands_pb.VersionRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.VersionResponse) => void): grpc.ClientUnaryCall;
+    version(request: cc_arduino_cli_commands_v1_commands_pb.VersionRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.VersionResponse) => void): grpc.ClientUnaryCall;
+    version(request: cc_arduino_cli_commands_v1_commands_pb.VersionRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.VersionResponse) => void): grpc.ClientUnaryCall;
+    loadSketch(request: cc_arduino_cli_commands_v1_commands_pb.LoadSketchRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.LoadSketchResponse) => void): grpc.ClientUnaryCall;
+    loadSketch(request: cc_arduino_cli_commands_v1_commands_pb.LoadSketchRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.LoadSketchResponse) => void): grpc.ClientUnaryCall;
+    loadSketch(request: cc_arduino_cli_commands_v1_commands_pb.LoadSketchRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.LoadSketchResponse) => void): grpc.ClientUnaryCall;
+    archiveSketch(request: cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchResponse) => void): grpc.ClientUnaryCall;
+    archiveSketch(request: cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchResponse) => void): grpc.ClientUnaryCall;
+    archiveSketch(request: cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchResponse) => void): grpc.ClientUnaryCall;
+    boardDetails(request: cc_arduino_cli_commands_v1_board_pb.BoardDetailsRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardDetailsResponse) => void): grpc.ClientUnaryCall;
+    boardDetails(request: cc_arduino_cli_commands_v1_board_pb.BoardDetailsRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardDetailsResponse) => void): grpc.ClientUnaryCall;
+    boardDetails(request: cc_arduino_cli_commands_v1_board_pb.BoardDetailsRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardDetailsResponse) => void): grpc.ClientUnaryCall;
+    boardAttach(request: cc_arduino_cli_commands_v1_board_pb.BoardAttachRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_board_pb.BoardAttachResponse>;
+    boardAttach(request: cc_arduino_cli_commands_v1_board_pb.BoardAttachRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_board_pb.BoardAttachResponse>;
+    boardList(request: cc_arduino_cli_commands_v1_board_pb.BoardListRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardListResponse) => void): grpc.ClientUnaryCall;
+    boardList(request: cc_arduino_cli_commands_v1_board_pb.BoardListRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardListResponse) => void): grpc.ClientUnaryCall;
+    boardList(request: cc_arduino_cli_commands_v1_board_pb.BoardListRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardListResponse) => void): grpc.ClientUnaryCall;
+    boardListAll(request: cc_arduino_cli_commands_v1_board_pb.BoardListAllRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardListAllResponse) => void): grpc.ClientUnaryCall;
+    boardListAll(request: cc_arduino_cli_commands_v1_board_pb.BoardListAllRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardListAllResponse) => void): grpc.ClientUnaryCall;
+    boardListAll(request: cc_arduino_cli_commands_v1_board_pb.BoardListAllRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardListAllResponse) => void): grpc.ClientUnaryCall;
+    boardSearch(request: cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse) => void): grpc.ClientUnaryCall;
+    boardSearch(request: cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse) => void): grpc.ClientUnaryCall;
+    boardSearch(request: cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse) => void): grpc.ClientUnaryCall;
+    boardListWatch(): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
+    boardListWatch(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
+    boardListWatch(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
+    compile(request: cc_arduino_cli_commands_v1_compile_pb.CompileRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_compile_pb.CompileResponse>;
+    compile(request: cc_arduino_cli_commands_v1_compile_pb.CompileRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_compile_pb.CompileResponse>;
+    platformInstall(request: cc_arduino_cli_commands_v1_core_pb.PlatformInstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformInstallResponse>;
+    platformInstall(request: cc_arduino_cli_commands_v1_core_pb.PlatformInstallRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformInstallResponse>;
+    platformDownload(request: cc_arduino_cli_commands_v1_core_pb.PlatformDownloadRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformDownloadResponse>;
+    platformDownload(request: cc_arduino_cli_commands_v1_core_pb.PlatformDownloadRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformDownloadResponse>;
+    platformUninstall(request: cc_arduino_cli_commands_v1_core_pb.PlatformUninstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformUninstallResponse>;
+    platformUninstall(request: cc_arduino_cli_commands_v1_core_pb.PlatformUninstallRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformUninstallResponse>;
+    platformUpgrade(request: cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeResponse>;
+    platformUpgrade(request: cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeResponse>;
+    upload(request: cc_arduino_cli_commands_v1_upload_pb.UploadRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_upload_pb.UploadResponse>;
+    upload(request: cc_arduino_cli_commands_v1_upload_pb.UploadRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_upload_pb.UploadResponse>;
+    uploadUsingProgrammer(request: cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerResponse>;
+    uploadUsingProgrammer(request: cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerResponse>;
+    listProgrammersAvailableForUpload(request: cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadResponse) => void): grpc.ClientUnaryCall;
+    listProgrammersAvailableForUpload(request: cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadResponse) => void): grpc.ClientUnaryCall;
+    listProgrammersAvailableForUpload(request: cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadResponse) => void): grpc.ClientUnaryCall;
+    burnBootloader(request: cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderResponse>;
+    burnBootloader(request: cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderResponse>;
+    platformSearch(request: cc_arduino_cli_commands_v1_core_pb.PlatformSearchRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_core_pb.PlatformSearchResponse) => void): grpc.ClientUnaryCall;
+    platformSearch(request: cc_arduino_cli_commands_v1_core_pb.PlatformSearchRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_core_pb.PlatformSearchResponse) => void): grpc.ClientUnaryCall;
+    platformSearch(request: cc_arduino_cli_commands_v1_core_pb.PlatformSearchRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_core_pb.PlatformSearchResponse) => void): grpc.ClientUnaryCall;
+    platformList(request: cc_arduino_cli_commands_v1_core_pb.PlatformListRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_core_pb.PlatformListResponse) => void): grpc.ClientUnaryCall;
+    platformList(request: cc_arduino_cli_commands_v1_core_pb.PlatformListRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_core_pb.PlatformListResponse) => void): grpc.ClientUnaryCall;
+    platformList(request: cc_arduino_cli_commands_v1_core_pb.PlatformListRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_core_pb.PlatformListResponse) => void): grpc.ClientUnaryCall;
+    libraryDownload(request: cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadResponse>;
+    libraryDownload(request: cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadResponse>;
+    libraryInstall(request: cc_arduino_cli_commands_v1_lib_pb.LibraryInstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryInstallResponse>;
+    libraryInstall(request: cc_arduino_cli_commands_v1_lib_pb.LibraryInstallRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryInstallResponse>;
+    zipLibraryInstall(request: cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallResponse>;
+    zipLibraryInstall(request: cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallResponse>;
+    gitLibraryInstall(request: cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallResponse>;
+    gitLibraryInstall(request: cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallResponse>;
+    libraryUninstall(request: cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallResponse>;
+    libraryUninstall(request: cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallResponse>;
+    libraryUpgradeAll(request: cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllResponse>;
+    libraryUpgradeAll(request: cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllResponse>;
+    libraryResolveDependencies(request: cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesResponse) => void): grpc.ClientUnaryCall;
+    libraryResolveDependencies(request: cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesResponse) => void): grpc.ClientUnaryCall;
+    libraryResolveDependencies(request: cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesResponse) => void): grpc.ClientUnaryCall;
+    librarySearch(request: cc_arduino_cli_commands_v1_lib_pb.LibrarySearchRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibrarySearchResponse) => void): grpc.ClientUnaryCall;
+    librarySearch(request: cc_arduino_cli_commands_v1_lib_pb.LibrarySearchRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibrarySearchResponse) => void): grpc.ClientUnaryCall;
+    librarySearch(request: cc_arduino_cli_commands_v1_lib_pb.LibrarySearchRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibrarySearchResponse) => void): grpc.ClientUnaryCall;
+    libraryList(request: cc_arduino_cli_commands_v1_lib_pb.LibraryListRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibraryListResponse) => void): grpc.ClientUnaryCall;
+    libraryList(request: cc_arduino_cli_commands_v1_lib_pb.LibraryListRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibraryListResponse) => void): grpc.ClientUnaryCall;
+    libraryList(request: cc_arduino_cli_commands_v1_lib_pb.LibraryListRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibraryListResponse) => void): grpc.ClientUnaryCall;
+}
+
+export class ArduinoCoreServiceClient extends grpc.Client implements IArduinoCoreServiceClient {
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: Partial<grpc.ClientOptions>);
+    public init(request: cc_arduino_cli_commands_v1_commands_pb.InitRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.InitResponse>;
+    public init(request: cc_arduino_cli_commands_v1_commands_pb.InitRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.InitResponse>;
+    public destroy(request: cc_arduino_cli_commands_v1_commands_pb.DestroyRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.DestroyResponse) => void): grpc.ClientUnaryCall;
+    public destroy(request: cc_arduino_cli_commands_v1_commands_pb.DestroyRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.DestroyResponse) => void): grpc.ClientUnaryCall;
+    public destroy(request: cc_arduino_cli_commands_v1_commands_pb.DestroyRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.DestroyResponse) => void): grpc.ClientUnaryCall;
+    public rescan(request: cc_arduino_cli_commands_v1_commands_pb.RescanRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.RescanResponse) => void): grpc.ClientUnaryCall;
+    public rescan(request: cc_arduino_cli_commands_v1_commands_pb.RescanRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.RescanResponse) => void): grpc.ClientUnaryCall;
+    public rescan(request: cc_arduino_cli_commands_v1_commands_pb.RescanRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.RescanResponse) => void): grpc.ClientUnaryCall;
+    public updateIndex(request: cc_arduino_cli_commands_v1_commands_pb.UpdateIndexRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpdateIndexResponse>;
+    public updateIndex(request: cc_arduino_cli_commands_v1_commands_pb.UpdateIndexRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpdateIndexResponse>;
+    public updateLibrariesIndex(request: cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexResponse>;
+    public updateLibrariesIndex(request: cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpdateLibrariesIndexResponse>;
+    public updateCoreLibrariesIndex(request: cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexResponse>;
+    public updateCoreLibrariesIndex(request: cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpdateCoreLibrariesIndexResponse>;
+    public outdated(request: cc_arduino_cli_commands_v1_commands_pb.OutdatedRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.OutdatedResponse) => void): grpc.ClientUnaryCall;
+    public outdated(request: cc_arduino_cli_commands_v1_commands_pb.OutdatedRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.OutdatedResponse) => void): grpc.ClientUnaryCall;
+    public outdated(request: cc_arduino_cli_commands_v1_commands_pb.OutdatedRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.OutdatedResponse) => void): grpc.ClientUnaryCall;
+    public upgrade(request: cc_arduino_cli_commands_v1_commands_pb.UpgradeRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpgradeResponse>;
+    public upgrade(request: cc_arduino_cli_commands_v1_commands_pb.UpgradeRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_commands_pb.UpgradeResponse>;
+    public version(request: cc_arduino_cli_commands_v1_commands_pb.VersionRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.VersionResponse) => void): grpc.ClientUnaryCall;
+    public version(request: cc_arduino_cli_commands_v1_commands_pb.VersionRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.VersionResponse) => void): grpc.ClientUnaryCall;
+    public version(request: cc_arduino_cli_commands_v1_commands_pb.VersionRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.VersionResponse) => void): grpc.ClientUnaryCall;
+    public loadSketch(request: cc_arduino_cli_commands_v1_commands_pb.LoadSketchRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.LoadSketchResponse) => void): grpc.ClientUnaryCall;
+    public loadSketch(request: cc_arduino_cli_commands_v1_commands_pb.LoadSketchRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.LoadSketchResponse) => void): grpc.ClientUnaryCall;
+    public loadSketch(request: cc_arduino_cli_commands_v1_commands_pb.LoadSketchRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.LoadSketchResponse) => void): grpc.ClientUnaryCall;
+    public archiveSketch(request: cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchResponse) => void): grpc.ClientUnaryCall;
+    public archiveSketch(request: cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchResponse) => void): grpc.ClientUnaryCall;
+    public archiveSketch(request: cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_commands_pb.ArchiveSketchResponse) => void): grpc.ClientUnaryCall;
+    public boardDetails(request: cc_arduino_cli_commands_v1_board_pb.BoardDetailsRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardDetailsResponse) => void): grpc.ClientUnaryCall;
+    public boardDetails(request: cc_arduino_cli_commands_v1_board_pb.BoardDetailsRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardDetailsResponse) => void): grpc.ClientUnaryCall;
+    public boardDetails(request: cc_arduino_cli_commands_v1_board_pb.BoardDetailsRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardDetailsResponse) => void): grpc.ClientUnaryCall;
+    public boardAttach(request: cc_arduino_cli_commands_v1_board_pb.BoardAttachRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_board_pb.BoardAttachResponse>;
+    public boardAttach(request: cc_arduino_cli_commands_v1_board_pb.BoardAttachRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_board_pb.BoardAttachResponse>;
+    public boardList(request: cc_arduino_cli_commands_v1_board_pb.BoardListRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardListResponse) => void): grpc.ClientUnaryCall;
+    public boardList(request: cc_arduino_cli_commands_v1_board_pb.BoardListRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardListResponse) => void): grpc.ClientUnaryCall;
+    public boardList(request: cc_arduino_cli_commands_v1_board_pb.BoardListRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardListResponse) => void): grpc.ClientUnaryCall;
+    public boardListAll(request: cc_arduino_cli_commands_v1_board_pb.BoardListAllRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardListAllResponse) => void): grpc.ClientUnaryCall;
+    public boardListAll(request: cc_arduino_cli_commands_v1_board_pb.BoardListAllRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardListAllResponse) => void): grpc.ClientUnaryCall;
+    public boardListAll(request: cc_arduino_cli_commands_v1_board_pb.BoardListAllRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardListAllResponse) => void): grpc.ClientUnaryCall;
+    public boardSearch(request: cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse) => void): grpc.ClientUnaryCall;
+    public boardSearch(request: cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse) => void): grpc.ClientUnaryCall;
+    public boardSearch(request: cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse) => void): grpc.ClientUnaryCall;
+    public boardListWatch(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
+    public boardListWatch(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
+    public compile(request: cc_arduino_cli_commands_v1_compile_pb.CompileRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_compile_pb.CompileResponse>;
+    public compile(request: cc_arduino_cli_commands_v1_compile_pb.CompileRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_compile_pb.CompileResponse>;
+    public platformInstall(request: cc_arduino_cli_commands_v1_core_pb.PlatformInstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformInstallResponse>;
+    public platformInstall(request: cc_arduino_cli_commands_v1_core_pb.PlatformInstallRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformInstallResponse>;
+    public platformDownload(request: cc_arduino_cli_commands_v1_core_pb.PlatformDownloadRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformDownloadResponse>;
+    public platformDownload(request: cc_arduino_cli_commands_v1_core_pb.PlatformDownloadRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformDownloadResponse>;
+    public platformUninstall(request: cc_arduino_cli_commands_v1_core_pb.PlatformUninstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformUninstallResponse>;
+    public platformUninstall(request: cc_arduino_cli_commands_v1_core_pb.PlatformUninstallRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformUninstallResponse>;
+    public platformUpgrade(request: cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeResponse>;
+    public platformUpgrade(request: cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformUpgradeResponse>;
+    public upload(request: cc_arduino_cli_commands_v1_upload_pb.UploadRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_upload_pb.UploadResponse>;
+    public upload(request: cc_arduino_cli_commands_v1_upload_pb.UploadRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_upload_pb.UploadResponse>;
+    public uploadUsingProgrammer(request: cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerResponse>;
+    public uploadUsingProgrammer(request: cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_upload_pb.UploadUsingProgrammerResponse>;
+    public listProgrammersAvailableForUpload(request: cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadResponse) => void): grpc.ClientUnaryCall;
+    public listProgrammersAvailableForUpload(request: cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadResponse) => void): grpc.ClientUnaryCall;
+    public listProgrammersAvailableForUpload(request: cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_upload_pb.ListProgrammersAvailableForUploadResponse) => void): grpc.ClientUnaryCall;
+    public burnBootloader(request: cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderResponse>;
+    public burnBootloader(request: cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_upload_pb.BurnBootloaderResponse>;
+    public platformSearch(request: cc_arduino_cli_commands_v1_core_pb.PlatformSearchRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_core_pb.PlatformSearchResponse) => void): grpc.ClientUnaryCall;
+    public platformSearch(request: cc_arduino_cli_commands_v1_core_pb.PlatformSearchRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_core_pb.PlatformSearchResponse) => void): grpc.ClientUnaryCall;
+    public platformSearch(request: cc_arduino_cli_commands_v1_core_pb.PlatformSearchRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_core_pb.PlatformSearchResponse) => void): grpc.ClientUnaryCall;
+    public platformList(request: cc_arduino_cli_commands_v1_core_pb.PlatformListRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_core_pb.PlatformListResponse) => void): grpc.ClientUnaryCall;
+    public platformList(request: cc_arduino_cli_commands_v1_core_pb.PlatformListRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_core_pb.PlatformListResponse) => void): grpc.ClientUnaryCall;
+    public platformList(request: cc_arduino_cli_commands_v1_core_pb.PlatformListRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_core_pb.PlatformListResponse) => void): grpc.ClientUnaryCall;
+    public libraryDownload(request: cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadResponse>;
+    public libraryDownload(request: cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadResponse>;
+    public libraryInstall(request: cc_arduino_cli_commands_v1_lib_pb.LibraryInstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryInstallResponse>;
+    public libraryInstall(request: cc_arduino_cli_commands_v1_lib_pb.LibraryInstallRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryInstallResponse>;
+    public zipLibraryInstall(request: cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallResponse>;
+    public zipLibraryInstall(request: cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.ZipLibraryInstallResponse>;
+    public gitLibraryInstall(request: cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallResponse>;
+    public gitLibraryInstall(request: cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallResponse>;
+    public libraryUninstall(request: cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallResponse>;
+    public libraryUninstall(request: cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryUninstallResponse>;
+    public libraryUpgradeAll(request: cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllResponse>;
+    public libraryUpgradeAll(request: cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_lib_pb.LibraryUpgradeAllResponse>;
+    public libraryResolveDependencies(request: cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesResponse) => void): grpc.ClientUnaryCall;
+    public libraryResolveDependencies(request: cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesResponse) => void): grpc.ClientUnaryCall;
+    public libraryResolveDependencies(request: cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibraryResolveDependenciesResponse) => void): grpc.ClientUnaryCall;
+    public librarySearch(request: cc_arduino_cli_commands_v1_lib_pb.LibrarySearchRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibrarySearchResponse) => void): grpc.ClientUnaryCall;
+    public librarySearch(request: cc_arduino_cli_commands_v1_lib_pb.LibrarySearchRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibrarySearchResponse) => void): grpc.ClientUnaryCall;
+    public librarySearch(request: cc_arduino_cli_commands_v1_lib_pb.LibrarySearchRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibrarySearchResponse) => void): grpc.ClientUnaryCall;
+    public libraryList(request: cc_arduino_cli_commands_v1_lib_pb.LibraryListRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibraryListResponse) => void): grpc.ClientUnaryCall;
+    public libraryList(request: cc_arduino_cli_commands_v1_lib_pb.LibraryListRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibraryListResponse) => void): grpc.ClientUnaryCall;
+    public libraryList(request: cc_arduino_cli_commands_v1_lib_pb.LibraryListRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_lib_pb.LibraryListResponse) => void): grpc.ClientUnaryCall;
+}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/commands_pb.d.ts

@@ -0,0 +1,585 @@
+// package: cc.arduino.cli.commands.v1
+// file: cc/arduino/cli/commands/v1/commands.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as jspb from "google-protobuf";
+import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino/cli/commands/v1/common_pb";
+import * as cc_arduino_cli_commands_v1_board_pb from "../../../../../cc/arduino/cli/commands/v1/board_pb";
+import * as cc_arduino_cli_commands_v1_compile_pb from "../../../../../cc/arduino/cli/commands/v1/compile_pb";
+import * as cc_arduino_cli_commands_v1_core_pb from "../../../../../cc/arduino/cli/commands/v1/core_pb";
+import * as cc_arduino_cli_commands_v1_upload_pb from "../../../../../cc/arduino/cli/commands/v1/upload_pb";
+import * as cc_arduino_cli_commands_v1_lib_pb from "../../../../../cc/arduino/cli/commands/v1/lib_pb";
+
+export class InitRequest extends jspb.Message { 
+    getLibraryManagerOnly(): boolean;
+    setLibraryManagerOnly(value: boolean): InitRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): InitRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: InitRequest): InitRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: InitRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): InitRequest;
+    static deserializeBinaryFromReader(message: InitRequest, reader: jspb.BinaryReader): InitRequest;
+}
+
+export namespace InitRequest {
+    export type AsObject = {
+        libraryManagerOnly: boolean,
+    }
+}
+
+export class InitResponse extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): InitResponse;
+
+    clearPlatformsIndexErrorsList(): void;
+    getPlatformsIndexErrorsList(): Array<string>;
+    setPlatformsIndexErrorsList(value: Array<string>): InitResponse;
+    addPlatformsIndexErrors(value: string, index?: number): string;
+
+    getLibrariesIndexError(): string;
+    setLibrariesIndexError(value: string): InitResponse;
+
+
+    hasDownloadProgress(): boolean;
+    clearDownloadProgress(): void;
+    getDownloadProgress(): cc_arduino_cli_commands_v1_common_pb.DownloadProgress | undefined;
+    setDownloadProgress(value?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress): InitResponse;
+
+
+    hasTaskProgress(): boolean;
+    clearTaskProgress(): void;
+    getTaskProgress(): cc_arduino_cli_commands_v1_common_pb.TaskProgress | undefined;
+    setTaskProgress(value?: cc_arduino_cli_commands_v1_common_pb.TaskProgress): InitResponse;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): InitResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: InitResponse): InitResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: InitResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): InitResponse;
+    static deserializeBinaryFromReader(message: InitResponse, reader: jspb.BinaryReader): InitResponse;
+}
+
+export namespace InitResponse {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+        platformsIndexErrorsList: Array<string>,
+        librariesIndexError: string,
+        downloadProgress?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress.AsObject,
+        taskProgress?: cc_arduino_cli_commands_v1_common_pb.TaskProgress.AsObject,
+    }
+}
+
+export class DestroyRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): DestroyRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DestroyRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: DestroyRequest): DestroyRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DestroyRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DestroyRequest;
+    static deserializeBinaryFromReader(message: DestroyRequest, reader: jspb.BinaryReader): DestroyRequest;
+}
+
+export namespace DestroyRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+    }
+}
+
+export class DestroyResponse extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DestroyResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: DestroyResponse): DestroyResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DestroyResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DestroyResponse;
+    static deserializeBinaryFromReader(message: DestroyResponse, reader: jspb.BinaryReader): DestroyResponse;
+}
+
+export namespace DestroyResponse {
+    export type AsObject = {
+    }
+}
+
+export class RescanRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): RescanRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): RescanRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: RescanRequest): RescanRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: RescanRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): RescanRequest;
+    static deserializeBinaryFromReader(message: RescanRequest, reader: jspb.BinaryReader): RescanRequest;
+}
+
+export namespace RescanRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+    }
+}
+
+export class RescanResponse extends jspb.Message { 
+    clearPlatformsIndexErrorsList(): void;
+    getPlatformsIndexErrorsList(): Array<string>;
+    setPlatformsIndexErrorsList(value: Array<string>): RescanResponse;
+    addPlatformsIndexErrors(value: string, index?: number): string;
+
+    getLibrariesIndexError(): string;
+    setLibrariesIndexError(value: string): RescanResponse;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): RescanResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: RescanResponse): RescanResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: RescanResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): RescanResponse;
+    static deserializeBinaryFromReader(message: RescanResponse, reader: jspb.BinaryReader): RescanResponse;
+}
+
+export namespace RescanResponse {
+    export type AsObject = {
+        platformsIndexErrorsList: Array<string>,
+        librariesIndexError: string,
+    }
+}
+
+export class UpdateIndexRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): UpdateIndexRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UpdateIndexRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: UpdateIndexRequest): UpdateIndexRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UpdateIndexRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UpdateIndexRequest;
+    static deserializeBinaryFromReader(message: UpdateIndexRequest, reader: jspb.BinaryReader): UpdateIndexRequest;
+}
+
+export namespace UpdateIndexRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+    }
+}
+
+export class UpdateIndexResponse extends jspb.Message { 
+
+    hasDownloadProgress(): boolean;
+    clearDownloadProgress(): void;
+    getDownloadProgress(): cc_arduino_cli_commands_v1_common_pb.DownloadProgress | undefined;
+    setDownloadProgress(value?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress): UpdateIndexResponse;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UpdateIndexResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: UpdateIndexResponse): UpdateIndexResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UpdateIndexResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UpdateIndexResponse;
+    static deserializeBinaryFromReader(message: UpdateIndexResponse, reader: jspb.BinaryReader): UpdateIndexResponse;
+}
+
+export namespace UpdateIndexResponse {
+    export type AsObject = {
+        downloadProgress?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress.AsObject,
+    }
+}
+
+export class UpdateLibrariesIndexRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): UpdateLibrariesIndexRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UpdateLibrariesIndexRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: UpdateLibrariesIndexRequest): UpdateLibrariesIndexRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UpdateLibrariesIndexRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UpdateLibrariesIndexRequest;
+    static deserializeBinaryFromReader(message: UpdateLibrariesIndexRequest, reader: jspb.BinaryReader): UpdateLibrariesIndexRequest;
+}
+
+export namespace UpdateLibrariesIndexRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+    }
+}
+
+export class UpdateLibrariesIndexResponse extends jspb.Message { 
+
+    hasDownloadProgress(): boolean;
+    clearDownloadProgress(): void;
+    getDownloadProgress(): cc_arduino_cli_commands_v1_common_pb.DownloadProgress | undefined;
+    setDownloadProgress(value?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress): UpdateLibrariesIndexResponse;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UpdateLibrariesIndexResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: UpdateLibrariesIndexResponse): UpdateLibrariesIndexResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UpdateLibrariesIndexResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UpdateLibrariesIndexResponse;
+    static deserializeBinaryFromReader(message: UpdateLibrariesIndexResponse, reader: jspb.BinaryReader): UpdateLibrariesIndexResponse;
+}
+
+export namespace UpdateLibrariesIndexResponse {
+    export type AsObject = {
+        downloadProgress?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress.AsObject,
+    }
+}
+
+export class UpdateCoreLibrariesIndexRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): UpdateCoreLibrariesIndexRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UpdateCoreLibrariesIndexRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: UpdateCoreLibrariesIndexRequest): UpdateCoreLibrariesIndexRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UpdateCoreLibrariesIndexRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UpdateCoreLibrariesIndexRequest;
+    static deserializeBinaryFromReader(message: UpdateCoreLibrariesIndexRequest, reader: jspb.BinaryReader): UpdateCoreLibrariesIndexRequest;
+}
+
+export namespace UpdateCoreLibrariesIndexRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+    }
+}
+
+export class UpdateCoreLibrariesIndexResponse extends jspb.Message { 
+
+    hasDownloadProgress(): boolean;
+    clearDownloadProgress(): void;
+    getDownloadProgress(): cc_arduino_cli_commands_v1_common_pb.DownloadProgress | undefined;
+    setDownloadProgress(value?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress): UpdateCoreLibrariesIndexResponse;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UpdateCoreLibrariesIndexResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: UpdateCoreLibrariesIndexResponse): UpdateCoreLibrariesIndexResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UpdateCoreLibrariesIndexResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UpdateCoreLibrariesIndexResponse;
+    static deserializeBinaryFromReader(message: UpdateCoreLibrariesIndexResponse, reader: jspb.BinaryReader): UpdateCoreLibrariesIndexResponse;
+}
+
+export namespace UpdateCoreLibrariesIndexResponse {
+    export type AsObject = {
+        downloadProgress?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress.AsObject,
+    }
+}
+
+export class OutdatedRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): OutdatedRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): OutdatedRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: OutdatedRequest): OutdatedRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: OutdatedRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): OutdatedRequest;
+    static deserializeBinaryFromReader(message: OutdatedRequest, reader: jspb.BinaryReader): OutdatedRequest;
+}
+
+export namespace OutdatedRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+    }
+}
+
+export class OutdatedResponse extends jspb.Message { 
+    clearOutdatedLibrariesList(): void;
+    getOutdatedLibrariesList(): Array<cc_arduino_cli_commands_v1_lib_pb.InstalledLibrary>;
+    setOutdatedLibrariesList(value: Array<cc_arduino_cli_commands_v1_lib_pb.InstalledLibrary>): OutdatedResponse;
+    addOutdatedLibraries(value?: cc_arduino_cli_commands_v1_lib_pb.InstalledLibrary, index?: number): cc_arduino_cli_commands_v1_lib_pb.InstalledLibrary;
+
+    clearOutdatedPlatformsList(): void;
+    getOutdatedPlatformsList(): Array<cc_arduino_cli_commands_v1_common_pb.Platform>;
+    setOutdatedPlatformsList(value: Array<cc_arduino_cli_commands_v1_common_pb.Platform>): OutdatedResponse;
+    addOutdatedPlatforms(value?: cc_arduino_cli_commands_v1_common_pb.Platform, index?: number): cc_arduino_cli_commands_v1_common_pb.Platform;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): OutdatedResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: OutdatedResponse): OutdatedResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: OutdatedResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): OutdatedResponse;
+    static deserializeBinaryFromReader(message: OutdatedResponse, reader: jspb.BinaryReader): OutdatedResponse;
+}
+
+export namespace OutdatedResponse {
+    export type AsObject = {
+        outdatedLibrariesList: Array<cc_arduino_cli_commands_v1_lib_pb.InstalledLibrary.AsObject>,
+        outdatedPlatformsList: Array<cc_arduino_cli_commands_v1_common_pb.Platform.AsObject>,
+    }
+}
+
+export class UpgradeRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): UpgradeRequest;
+
+    getSkipPostInstall(): boolean;
+    setSkipPostInstall(value: boolean): UpgradeRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UpgradeRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: UpgradeRequest): UpgradeRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UpgradeRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UpgradeRequest;
+    static deserializeBinaryFromReader(message: UpgradeRequest, reader: jspb.BinaryReader): UpgradeRequest;
+}
+
+export namespace UpgradeRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+        skipPostInstall: boolean,
+    }
+}
+
+export class UpgradeResponse extends jspb.Message { 
+
+    hasProgress(): boolean;
+    clearProgress(): void;
+    getProgress(): cc_arduino_cli_commands_v1_common_pb.DownloadProgress | undefined;
+    setProgress(value?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress): UpgradeResponse;
+
+
+    hasTaskProgress(): boolean;
+    clearTaskProgress(): void;
+    getTaskProgress(): cc_arduino_cli_commands_v1_common_pb.TaskProgress | undefined;
+    setTaskProgress(value?: cc_arduino_cli_commands_v1_common_pb.TaskProgress): UpgradeResponse;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UpgradeResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: UpgradeResponse): UpgradeResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UpgradeResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UpgradeResponse;
+    static deserializeBinaryFromReader(message: UpgradeResponse, reader: jspb.BinaryReader): UpgradeResponse;
+}
+
+export namespace UpgradeResponse {
+    export type AsObject = {
+        progress?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress.AsObject,
+        taskProgress?: cc_arduino_cli_commands_v1_common_pb.TaskProgress.AsObject,
+    }
+}
+
+export class VersionRequest extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): VersionRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: VersionRequest): VersionRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: VersionRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): VersionRequest;
+    static deserializeBinaryFromReader(message: VersionRequest, reader: jspb.BinaryReader): VersionRequest;
+}
+
+export namespace VersionRequest {
+    export type AsObject = {
+    }
+}
+
+export class VersionResponse extends jspb.Message { 
+    getVersion(): string;
+    setVersion(value: string): VersionResponse;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): VersionResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: VersionResponse): VersionResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: VersionResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): VersionResponse;
+    static deserializeBinaryFromReader(message: VersionResponse, reader: jspb.BinaryReader): VersionResponse;
+}
+
+export namespace VersionResponse {
+    export type AsObject = {
+        version: string,
+    }
+}
+
+export class LoadSketchRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): LoadSketchRequest;
+
+    getSketchPath(): string;
+    setSketchPath(value: string): LoadSketchRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): LoadSketchRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: LoadSketchRequest): LoadSketchRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: LoadSketchRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LoadSketchRequest;
+    static deserializeBinaryFromReader(message: LoadSketchRequest, reader: jspb.BinaryReader): LoadSketchRequest;
+}
+
+export namespace LoadSketchRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+        sketchPath: string,
+    }
+}
+
+export class LoadSketchResponse extends jspb.Message { 
+    getMainFile(): string;
+    setMainFile(value: string): LoadSketchResponse;
+
+    getLocationPath(): string;
+    setLocationPath(value: string): LoadSketchResponse;
+
+    clearOtherSketchFilesList(): void;
+    getOtherSketchFilesList(): Array<string>;
+    setOtherSketchFilesList(value: Array<string>): LoadSketchResponse;
+    addOtherSketchFiles(value: string, index?: number): string;
+
+    clearAdditionalFilesList(): void;
+    getAdditionalFilesList(): Array<string>;
+    setAdditionalFilesList(value: Array<string>): LoadSketchResponse;
+    addAdditionalFiles(value: string, index?: number): string;
+
+    clearRootFolderFilesList(): void;
+    getRootFolderFilesList(): Array<string>;
+    setRootFolderFilesList(value: Array<string>): LoadSketchResponse;
+    addRootFolderFiles(value: string, index?: number): string;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): LoadSketchResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: LoadSketchResponse): LoadSketchResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: LoadSketchResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LoadSketchResponse;
+    static deserializeBinaryFromReader(message: LoadSketchResponse, reader: jspb.BinaryReader): LoadSketchResponse;
+}
+
+export namespace LoadSketchResponse {
+    export type AsObject = {
+        mainFile: string,
+        locationPath: string,
+        otherSketchFilesList: Array<string>,
+        additionalFilesList: Array<string>,
+        rootFolderFilesList: Array<string>,
+    }
+}
+
+export class ArchiveSketchRequest extends jspb.Message { 
+    getSketchPath(): string;
+    setSketchPath(value: string): ArchiveSketchRequest;
+
+    getArchivePath(): string;
+    setArchivePath(value: string): ArchiveSketchRequest;
+
+    getIncludeBuildDir(): boolean;
+    setIncludeBuildDir(value: boolean): ArchiveSketchRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ArchiveSketchRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: ArchiveSketchRequest): ArchiveSketchRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ArchiveSketchRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ArchiveSketchRequest;
+    static deserializeBinaryFromReader(message: ArchiveSketchRequest, reader: jspb.BinaryReader): ArchiveSketchRequest;
+}
+
+export namespace ArchiveSketchRequest {
+    export type AsObject = {
+        sketchPath: string,
+        archivePath: string,
+        includeBuildDir: boolean,
+    }
+}
+
+export class ArchiveSketchResponse extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ArchiveSketchResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: ArchiveSketchResponse): ArchiveSketchResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ArchiveSketchResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ArchiveSketchResponse;
+    static deserializeBinaryFromReader(message: ArchiveSketchResponse, reader: jspb.BinaryReader): ArchiveSketchResponse;
+}
+
+export namespace ArchiveSketchResponse {
+    export type AsObject = {
+    }
+}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/common_pb.d.ts

@@ -1,5 +1,5 @@
-// package: cc.arduino.cli.commands
-// file: commands/common.proto
+// package: cc.arduino.cli.commands.v1
+// file: cc/arduino/cli/commands/v1/common.proto
 
 /* tslint:disable */
 /* eslint-disable */
@@ -149,8 +149,11 @@ export class Platform extends jspb.Message {
     setBoardsList(value: Array<Board>): Platform;
     addBoards(value?: Board, index?: number): Board;
 
-    getManuallyinstalled(): boolean;
-    setManuallyinstalled(value: boolean): Platform;
+    getManuallyInstalled(): boolean;
+    setManuallyInstalled(value: boolean): Platform;
+
+    getDeprecated(): boolean;
+    setDeprecated(value: boolean): Platform;
 
 
     serializeBinary(): Uint8Array;
@@ -173,7 +176,8 @@ export namespace Platform {
         website: string,
         email: string,
         boardsList: Array<Board.AsObject>,
-        manuallyinstalled: boolean,
+        manuallyInstalled: boolean,
+        deprecated: boolean,
     }
 }
 

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/compile_pb.d.ts

@@ -0,0 +1,199 @@
+// package: cc.arduino.cli.commands.v1
+// file: cc/arduino/cli/commands/v1/compile.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as jspb from "google-protobuf";
+import * as google_protobuf_wrappers_pb from "google-protobuf/google/protobuf/wrappers_pb";
+import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino/cli/commands/v1/common_pb";
+import * as cc_arduino_cli_commands_v1_lib_pb from "../../../../../cc/arduino/cli/commands/v1/lib_pb";
+
+export class CompileRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): CompileRequest;
+
+    getFqbn(): string;
+    setFqbn(value: string): CompileRequest;
+
+    getSketchPath(): string;
+    setSketchPath(value: string): CompileRequest;
+
+    getShowProperties(): boolean;
+    setShowProperties(value: boolean): CompileRequest;
+
+    getPreprocess(): boolean;
+    setPreprocess(value: boolean): CompileRequest;
+
+    getBuildCachePath(): string;
+    setBuildCachePath(value: string): CompileRequest;
+
+    getBuildPath(): string;
+    setBuildPath(value: string): CompileRequest;
+
+    clearBuildPropertiesList(): void;
+    getBuildPropertiesList(): Array<string>;
+    setBuildPropertiesList(value: Array<string>): CompileRequest;
+    addBuildProperties(value: string, index?: number): string;
+
+    getWarnings(): string;
+    setWarnings(value: string): CompileRequest;
+
+    getVerbose(): boolean;
+    setVerbose(value: boolean): CompileRequest;
+
+    getQuiet(): boolean;
+    setQuiet(value: boolean): CompileRequest;
+
+    getVidPid(): string;
+    setVidPid(value: string): CompileRequest;
+
+    getJobs(): number;
+    setJobs(value: number): CompileRequest;
+
+    clearLibrariesList(): void;
+    getLibrariesList(): Array<string>;
+    setLibrariesList(value: Array<string>): CompileRequest;
+    addLibraries(value: string, index?: number): string;
+
+    getOptimizeForDebug(): boolean;
+    setOptimizeForDebug(value: boolean): CompileRequest;
+
+    getExportDir(): string;
+    setExportDir(value: string): CompileRequest;
+
+    getClean(): boolean;
+    setClean(value: boolean): CompileRequest;
+
+    getCreateCompilationDatabaseOnly(): boolean;
+    setCreateCompilationDatabaseOnly(value: boolean): CompileRequest;
+
+
+    getSourceOverrideMap(): jspb.Map<string, string>;
+    clearSourceOverrideMap(): void;
+
+
+    hasExportBinaries(): boolean;
+    clearExportBinaries(): void;
+    getExportBinaries(): google_protobuf_wrappers_pb.BoolValue | undefined;
+    setExportBinaries(value?: google_protobuf_wrappers_pb.BoolValue): CompileRequest;
+
+    clearLibraryList(): void;
+    getLibraryList(): Array<string>;
+    setLibraryList(value: Array<string>): CompileRequest;
+    addLibrary(value: string, index?: number): string;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CompileRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: CompileRequest): CompileRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CompileRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CompileRequest;
+    static deserializeBinaryFromReader(message: CompileRequest, reader: jspb.BinaryReader): CompileRequest;
+}
+
+export namespace CompileRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+        fqbn: string,
+        sketchPath: string,
+        showProperties: boolean,
+        preprocess: boolean,
+        buildCachePath: string,
+        buildPath: string,
+        buildPropertiesList: Array<string>,
+        warnings: string,
+        verbose: boolean,
+        quiet: boolean,
+        vidPid: string,
+        jobs: number,
+        librariesList: Array<string>,
+        optimizeForDebug: boolean,
+        exportDir: string,
+        clean: boolean,
+        createCompilationDatabaseOnly: boolean,
+
+        sourceOverrideMap: Array<[string, string]>,
+        exportBinaries?: google_protobuf_wrappers_pb.BoolValue.AsObject,
+        libraryList: Array<string>,
+    }
+}
+
+export class CompileResponse extends jspb.Message { 
+    getOutStream(): Uint8Array | string;
+    getOutStream_asU8(): Uint8Array;
+    getOutStream_asB64(): string;
+    setOutStream(value: Uint8Array | string): CompileResponse;
+
+    getErrStream(): Uint8Array | string;
+    getErrStream_asU8(): Uint8Array;
+    getErrStream_asB64(): string;
+    setErrStream(value: Uint8Array | string): CompileResponse;
+
+    getBuildPath(): string;
+    setBuildPath(value: string): CompileResponse;
+
+    clearUsedLibrariesList(): void;
+    getUsedLibrariesList(): Array<cc_arduino_cli_commands_v1_lib_pb.Library>;
+    setUsedLibrariesList(value: Array<cc_arduino_cli_commands_v1_lib_pb.Library>): CompileResponse;
+    addUsedLibraries(value?: cc_arduino_cli_commands_v1_lib_pb.Library, index?: number): cc_arduino_cli_commands_v1_lib_pb.Library;
+
+    clearExecutableSectionsSizeList(): void;
+    getExecutableSectionsSizeList(): Array<ExecutableSectionSize>;
+    setExecutableSectionsSizeList(value: Array<ExecutableSectionSize>): CompileResponse;
+    addExecutableSectionsSize(value?: ExecutableSectionSize, index?: number): ExecutableSectionSize;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CompileResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: CompileResponse): CompileResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CompileResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CompileResponse;
+    static deserializeBinaryFromReader(message: CompileResponse, reader: jspb.BinaryReader): CompileResponse;
+}
+
+export namespace CompileResponse {
+    export type AsObject = {
+        outStream: Uint8Array | string,
+        errStream: Uint8Array | string,
+        buildPath: string,
+        usedLibrariesList: Array<cc_arduino_cli_commands_v1_lib_pb.Library.AsObject>,
+        executableSectionsSizeList: Array<ExecutableSectionSize.AsObject>,
+    }
+}
+
+export class ExecutableSectionSize extends jspb.Message { 
+    getName(): string;
+    setName(value: string): ExecutableSectionSize;
+
+    getSize(): number;
+    setSize(value: number): ExecutableSectionSize;
+
+    getMaxSize(): number;
+    setMaxSize(value: number): ExecutableSectionSize;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ExecutableSectionSize.AsObject;
+    static toObject(includeInstance: boolean, msg: ExecutableSectionSize): ExecutableSectionSize.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ExecutableSectionSize, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ExecutableSectionSize;
+    static deserializeBinaryFromReader(message: ExecutableSectionSize, reader: jspb.BinaryReader): ExecutableSectionSize;
+}
+
+export namespace ExecutableSectionSize {
+    export type AsObject = {
+        name: string,
+        size: number,
+        maxSize: number,
+    }
+}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/core_pb.d.ts

@@ -0,0 +1,372 @@
+// package: cc.arduino.cli.commands.v1
+// file: cc/arduino/cli/commands/v1/core.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as jspb from "google-protobuf";
+import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino/cli/commands/v1/common_pb";
+
+export class PlatformInstallRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): PlatformInstallRequest;
+
+    getPlatformPackage(): string;
+    setPlatformPackage(value: string): PlatformInstallRequest;
+
+    getArchitecture(): string;
+    setArchitecture(value: string): PlatformInstallRequest;
+
+    getVersion(): string;
+    setVersion(value: string): PlatformInstallRequest;
+
+    getSkipPostInstall(): boolean;
+    setSkipPostInstall(value: boolean): PlatformInstallRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): PlatformInstallRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: PlatformInstallRequest): PlatformInstallRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: PlatformInstallRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): PlatformInstallRequest;
+    static deserializeBinaryFromReader(message: PlatformInstallRequest, reader: jspb.BinaryReader): PlatformInstallRequest;
+}
+
+export namespace PlatformInstallRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+        platformPackage: string,
+        architecture: string,
+        version: string,
+        skipPostInstall: boolean,
+    }
+}
+
+export class PlatformInstallResponse extends jspb.Message { 
+
+    hasProgress(): boolean;
+    clearProgress(): void;
+    getProgress(): cc_arduino_cli_commands_v1_common_pb.DownloadProgress | undefined;
+    setProgress(value?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress): PlatformInstallResponse;
+
+
+    hasTaskProgress(): boolean;
+    clearTaskProgress(): void;
+    getTaskProgress(): cc_arduino_cli_commands_v1_common_pb.TaskProgress | undefined;
+    setTaskProgress(value?: cc_arduino_cli_commands_v1_common_pb.TaskProgress): PlatformInstallResponse;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): PlatformInstallResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: PlatformInstallResponse): PlatformInstallResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: PlatformInstallResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): PlatformInstallResponse;
+    static deserializeBinaryFromReader(message: PlatformInstallResponse, reader: jspb.BinaryReader): PlatformInstallResponse;
+}
+
+export namespace PlatformInstallResponse {
+    export type AsObject = {
+        progress?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress.AsObject,
+        taskProgress?: cc_arduino_cli_commands_v1_common_pb.TaskProgress.AsObject,
+    }
+}
+
+export class PlatformDownloadRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): PlatformDownloadRequest;
+
+    getPlatformPackage(): string;
+    setPlatformPackage(value: string): PlatformDownloadRequest;
+
+    getArchitecture(): string;
+    setArchitecture(value: string): PlatformDownloadRequest;
+
+    getVersion(): string;
+    setVersion(value: string): PlatformDownloadRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): PlatformDownloadRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: PlatformDownloadRequest): PlatformDownloadRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: PlatformDownloadRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): PlatformDownloadRequest;
+    static deserializeBinaryFromReader(message: PlatformDownloadRequest, reader: jspb.BinaryReader): PlatformDownloadRequest;
+}
+
+export namespace PlatformDownloadRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+        platformPackage: string,
+        architecture: string,
+        version: string,
+    }
+}
+
+export class PlatformDownloadResponse extends jspb.Message { 
+
+    hasProgress(): boolean;
+    clearProgress(): void;
+    getProgress(): cc_arduino_cli_commands_v1_common_pb.DownloadProgress | undefined;
+    setProgress(value?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress): PlatformDownloadResponse;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): PlatformDownloadResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: PlatformDownloadResponse): PlatformDownloadResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: PlatformDownloadResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): PlatformDownloadResponse;
+    static deserializeBinaryFromReader(message: PlatformDownloadResponse, reader: jspb.BinaryReader): PlatformDownloadResponse;
+}
+
+export namespace PlatformDownloadResponse {
+    export type AsObject = {
+        progress?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress.AsObject,
+    }
+}
+
+export class PlatformUninstallRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): PlatformUninstallRequest;
+
+    getPlatformPackage(): string;
+    setPlatformPackage(value: string): PlatformUninstallRequest;
+
+    getArchitecture(): string;
+    setArchitecture(value: string): PlatformUninstallRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): PlatformUninstallRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: PlatformUninstallRequest): PlatformUninstallRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: PlatformUninstallRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): PlatformUninstallRequest;
+    static deserializeBinaryFromReader(message: PlatformUninstallRequest, reader: jspb.BinaryReader): PlatformUninstallRequest;
+}
+
+export namespace PlatformUninstallRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+        platformPackage: string,
+        architecture: string,
+    }
+}
+
+export class PlatformUninstallResponse extends jspb.Message { 
+
+    hasTaskProgress(): boolean;
+    clearTaskProgress(): void;
+    getTaskProgress(): cc_arduino_cli_commands_v1_common_pb.TaskProgress | undefined;
+    setTaskProgress(value?: cc_arduino_cli_commands_v1_common_pb.TaskProgress): PlatformUninstallResponse;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): PlatformUninstallResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: PlatformUninstallResponse): PlatformUninstallResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: PlatformUninstallResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): PlatformUninstallResponse;
+    static deserializeBinaryFromReader(message: PlatformUninstallResponse, reader: jspb.BinaryReader): PlatformUninstallResponse;
+}
+
+export namespace PlatformUninstallResponse {
+    export type AsObject = {
+        taskProgress?: cc_arduino_cli_commands_v1_common_pb.TaskProgress.AsObject,
+    }
+}
+
+export class PlatformUpgradeRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): PlatformUpgradeRequest;
+
+    getPlatformPackage(): string;
+    setPlatformPackage(value: string): PlatformUpgradeRequest;
+
+    getArchitecture(): string;
+    setArchitecture(value: string): PlatformUpgradeRequest;
+
+    getSkipPostInstall(): boolean;
+    setSkipPostInstall(value: boolean): PlatformUpgradeRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): PlatformUpgradeRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: PlatformUpgradeRequest): PlatformUpgradeRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: PlatformUpgradeRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): PlatformUpgradeRequest;
+    static deserializeBinaryFromReader(message: PlatformUpgradeRequest, reader: jspb.BinaryReader): PlatformUpgradeRequest;
+}
+
+export namespace PlatformUpgradeRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+        platformPackage: string,
+        architecture: string,
+        skipPostInstall: boolean,
+    }
+}
+
+export class PlatformUpgradeResponse extends jspb.Message { 
+
+    hasProgress(): boolean;
+    clearProgress(): void;
+    getProgress(): cc_arduino_cli_commands_v1_common_pb.DownloadProgress | undefined;
+    setProgress(value?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress): PlatformUpgradeResponse;
+
+
+    hasTaskProgress(): boolean;
+    clearTaskProgress(): void;
+    getTaskProgress(): cc_arduino_cli_commands_v1_common_pb.TaskProgress | undefined;
+    setTaskProgress(value?: cc_arduino_cli_commands_v1_common_pb.TaskProgress): PlatformUpgradeResponse;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): PlatformUpgradeResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: PlatformUpgradeResponse): PlatformUpgradeResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: PlatformUpgradeResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): PlatformUpgradeResponse;
+    static deserializeBinaryFromReader(message: PlatformUpgradeResponse, reader: jspb.BinaryReader): PlatformUpgradeResponse;
+}
+
+export namespace PlatformUpgradeResponse {
+    export type AsObject = {
+        progress?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress.AsObject,
+        taskProgress?: cc_arduino_cli_commands_v1_common_pb.TaskProgress.AsObject,
+    }
+}
+
+export class PlatformSearchRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): PlatformSearchRequest;
+
+    getSearchArgs(): string;
+    setSearchArgs(value: string): PlatformSearchRequest;
+
+    getAllVersions(): boolean;
+    setAllVersions(value: boolean): PlatformSearchRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): PlatformSearchRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: PlatformSearchRequest): PlatformSearchRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: PlatformSearchRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): PlatformSearchRequest;
+    static deserializeBinaryFromReader(message: PlatformSearchRequest, reader: jspb.BinaryReader): PlatformSearchRequest;
+}
+
+export namespace PlatformSearchRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+        searchArgs: string,
+        allVersions: boolean,
+    }
+}
+
+export class PlatformSearchResponse extends jspb.Message { 
+    clearSearchOutputList(): void;
+    getSearchOutputList(): Array<cc_arduino_cli_commands_v1_common_pb.Platform>;
+    setSearchOutputList(value: Array<cc_arduino_cli_commands_v1_common_pb.Platform>): PlatformSearchResponse;
+    addSearchOutput(value?: cc_arduino_cli_commands_v1_common_pb.Platform, index?: number): cc_arduino_cli_commands_v1_common_pb.Platform;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): PlatformSearchResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: PlatformSearchResponse): PlatformSearchResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: PlatformSearchResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): PlatformSearchResponse;
+    static deserializeBinaryFromReader(message: PlatformSearchResponse, reader: jspb.BinaryReader): PlatformSearchResponse;
+}
+
+export namespace PlatformSearchResponse {
+    export type AsObject = {
+        searchOutputList: Array<cc_arduino_cli_commands_v1_common_pb.Platform.AsObject>,
+    }
+}
+
+export class PlatformListRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): PlatformListRequest;
+
+    getUpdatableOnly(): boolean;
+    setUpdatableOnly(value: boolean): PlatformListRequest;
+
+    getAll(): boolean;
+    setAll(value: boolean): PlatformListRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): PlatformListRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: PlatformListRequest): PlatformListRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: PlatformListRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): PlatformListRequest;
+    static deserializeBinaryFromReader(message: PlatformListRequest, reader: jspb.BinaryReader): PlatformListRequest;
+}
+
+export namespace PlatformListRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+        updatableOnly: boolean,
+        all: boolean,
+    }
+}
+
+export class PlatformListResponse extends jspb.Message { 
+    clearInstalledPlatformsList(): void;
+    getInstalledPlatformsList(): Array<cc_arduino_cli_commands_v1_common_pb.Platform>;
+    setInstalledPlatformsList(value: Array<cc_arduino_cli_commands_v1_common_pb.Platform>): PlatformListResponse;
+    addInstalledPlatforms(value?: cc_arduino_cli_commands_v1_common_pb.Platform, index?: number): cc_arduino_cli_commands_v1_common_pb.Platform;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): PlatformListResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: PlatformListResponse): PlatformListResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: PlatformListResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): PlatformListResponse;
+    static deserializeBinaryFromReader(message: PlatformListResponse, reader: jspb.BinaryReader): PlatformListResponse;
+}
+
+export namespace PlatformListResponse {
+    export type AsObject = {
+        installedPlatformsList: Array<cc_arduino_cli_commands_v1_common_pb.Platform.AsObject>,
+    }
+}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/lib_pb.d.ts

@@ -1,296 +1,296 @@
-// package: cc.arduino.cli.commands
-// file: commands/lib.proto
+// package: cc.arduino.cli.commands.v1
+// file: cc/arduino/cli/commands/v1/lib.proto
 
 /* tslint:disable */
 /* eslint-disable */
 
 import * as jspb from "google-protobuf";
-import * as commands_common_pb from "../commands/common_pb";
+import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino/cli/commands/v1/common_pb";
 
-export class LibraryDownloadReq extends jspb.Message { 
+export class LibraryDownloadRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): LibraryDownloadReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): LibraryDownloadRequest;
 
     getName(): string;
-    setName(value: string): LibraryDownloadReq;
+    setName(value: string): LibraryDownloadRequest;
 
     getVersion(): string;
-    setVersion(value: string): LibraryDownloadReq;
+    setVersion(value: string): LibraryDownloadRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibraryDownloadReq.AsObject;
-    static toObject(includeInstance: boolean, msg: LibraryDownloadReq): LibraryDownloadReq.AsObject;
+    toObject(includeInstance?: boolean): LibraryDownloadRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: LibraryDownloadRequest): LibraryDownloadRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibraryDownloadReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibraryDownloadReq;
-    static deserializeBinaryFromReader(message: LibraryDownloadReq, reader: jspb.BinaryReader): LibraryDownloadReq;
+    static serializeBinaryToWriter(message: LibraryDownloadRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibraryDownloadRequest;
+    static deserializeBinaryFromReader(message: LibraryDownloadRequest, reader: jspb.BinaryReader): LibraryDownloadRequest;
 }
 
-export namespace LibraryDownloadReq {
+export namespace LibraryDownloadRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         name: string,
         version: string,
     }
 }
 
-export class LibraryDownloadResp extends jspb.Message { 
+export class LibraryDownloadResponse extends jspb.Message { 
 
     hasProgress(): boolean;
     clearProgress(): void;
-    getProgress(): commands_common_pb.DownloadProgress | undefined;
-    setProgress(value?: commands_common_pb.DownloadProgress): LibraryDownloadResp;
+    getProgress(): cc_arduino_cli_commands_v1_common_pb.DownloadProgress | undefined;
+    setProgress(value?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress): LibraryDownloadResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibraryDownloadResp.AsObject;
-    static toObject(includeInstance: boolean, msg: LibraryDownloadResp): LibraryDownloadResp.AsObject;
+    toObject(includeInstance?: boolean): LibraryDownloadResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: LibraryDownloadResponse): LibraryDownloadResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibraryDownloadResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibraryDownloadResp;
-    static deserializeBinaryFromReader(message: LibraryDownloadResp, reader: jspb.BinaryReader): LibraryDownloadResp;
+    static serializeBinaryToWriter(message: LibraryDownloadResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibraryDownloadResponse;
+    static deserializeBinaryFromReader(message: LibraryDownloadResponse, reader: jspb.BinaryReader): LibraryDownloadResponse;
 }
 
-export namespace LibraryDownloadResp {
+export namespace LibraryDownloadResponse {
     export type AsObject = {
-        progress?: commands_common_pb.DownloadProgress.AsObject,
+        progress?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress.AsObject,
     }
 }
 
-export class LibraryInstallReq extends jspb.Message { 
+export class LibraryInstallRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): LibraryInstallReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): LibraryInstallRequest;
 
     getName(): string;
-    setName(value: string): LibraryInstallReq;
+    setName(value: string): LibraryInstallRequest;
 
     getVersion(): string;
-    setVersion(value: string): LibraryInstallReq;
+    setVersion(value: string): LibraryInstallRequest;
 
-    getNodeps(): boolean;
-    setNodeps(value: boolean): LibraryInstallReq;
+    getNoDeps(): boolean;
+    setNoDeps(value: boolean): LibraryInstallRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibraryInstallReq.AsObject;
-    static toObject(includeInstance: boolean, msg: LibraryInstallReq): LibraryInstallReq.AsObject;
+    toObject(includeInstance?: boolean): LibraryInstallRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: LibraryInstallRequest): LibraryInstallRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibraryInstallReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibraryInstallReq;
-    static deserializeBinaryFromReader(message: LibraryInstallReq, reader: jspb.BinaryReader): LibraryInstallReq;
+    static serializeBinaryToWriter(message: LibraryInstallRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibraryInstallRequest;
+    static deserializeBinaryFromReader(message: LibraryInstallRequest, reader: jspb.BinaryReader): LibraryInstallRequest;
 }
 
-export namespace LibraryInstallReq {
+export namespace LibraryInstallRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         name: string,
         version: string,
-        nodeps: boolean,
+        noDeps: boolean,
     }
 }
 
-export class LibraryInstallResp extends jspb.Message { 
+export class LibraryInstallResponse extends jspb.Message { 
 
     hasProgress(): boolean;
     clearProgress(): void;
-    getProgress(): commands_common_pb.DownloadProgress | undefined;
-    setProgress(value?: commands_common_pb.DownloadProgress): LibraryInstallResp;
+    getProgress(): cc_arduino_cli_commands_v1_common_pb.DownloadProgress | undefined;
+    setProgress(value?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress): LibraryInstallResponse;
 
 
     hasTaskProgress(): boolean;
     clearTaskProgress(): void;
-    getTaskProgress(): commands_common_pb.TaskProgress | undefined;
-    setTaskProgress(value?: commands_common_pb.TaskProgress): LibraryInstallResp;
+    getTaskProgress(): cc_arduino_cli_commands_v1_common_pb.TaskProgress | undefined;
+    setTaskProgress(value?: cc_arduino_cli_commands_v1_common_pb.TaskProgress): LibraryInstallResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibraryInstallResp.AsObject;
-    static toObject(includeInstance: boolean, msg: LibraryInstallResp): LibraryInstallResp.AsObject;
+    toObject(includeInstance?: boolean): LibraryInstallResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: LibraryInstallResponse): LibraryInstallResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibraryInstallResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibraryInstallResp;
-    static deserializeBinaryFromReader(message: LibraryInstallResp, reader: jspb.BinaryReader): LibraryInstallResp;
+    static serializeBinaryToWriter(message: LibraryInstallResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibraryInstallResponse;
+    static deserializeBinaryFromReader(message: LibraryInstallResponse, reader: jspb.BinaryReader): LibraryInstallResponse;
 }
 
-export namespace LibraryInstallResp {
+export namespace LibraryInstallResponse {
     export type AsObject = {
-        progress?: commands_common_pb.DownloadProgress.AsObject,
-        taskProgress?: commands_common_pb.TaskProgress.AsObject,
+        progress?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress.AsObject,
+        taskProgress?: cc_arduino_cli_commands_v1_common_pb.TaskProgress.AsObject,
     }
 }
 
-export class LibraryUninstallReq extends jspb.Message { 
+export class LibraryUninstallRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): LibraryUninstallReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): LibraryUninstallRequest;
 
     getName(): string;
-    setName(value: string): LibraryUninstallReq;
+    setName(value: string): LibraryUninstallRequest;
 
     getVersion(): string;
-    setVersion(value: string): LibraryUninstallReq;
+    setVersion(value: string): LibraryUninstallRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibraryUninstallReq.AsObject;
-    static toObject(includeInstance: boolean, msg: LibraryUninstallReq): LibraryUninstallReq.AsObject;
+    toObject(includeInstance?: boolean): LibraryUninstallRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: LibraryUninstallRequest): LibraryUninstallRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibraryUninstallReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibraryUninstallReq;
-    static deserializeBinaryFromReader(message: LibraryUninstallReq, reader: jspb.BinaryReader): LibraryUninstallReq;
+    static serializeBinaryToWriter(message: LibraryUninstallRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibraryUninstallRequest;
+    static deserializeBinaryFromReader(message: LibraryUninstallRequest, reader: jspb.BinaryReader): LibraryUninstallRequest;
 }
 
-export namespace LibraryUninstallReq {
+export namespace LibraryUninstallRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         name: string,
         version: string,
     }
 }
 
-export class LibraryUninstallResp extends jspb.Message { 
+export class LibraryUninstallResponse extends jspb.Message { 
 
     hasTaskProgress(): boolean;
     clearTaskProgress(): void;
-    getTaskProgress(): commands_common_pb.TaskProgress | undefined;
-    setTaskProgress(value?: commands_common_pb.TaskProgress): LibraryUninstallResp;
+    getTaskProgress(): cc_arduino_cli_commands_v1_common_pb.TaskProgress | undefined;
+    setTaskProgress(value?: cc_arduino_cli_commands_v1_common_pb.TaskProgress): LibraryUninstallResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibraryUninstallResp.AsObject;
-    static toObject(includeInstance: boolean, msg: LibraryUninstallResp): LibraryUninstallResp.AsObject;
+    toObject(includeInstance?: boolean): LibraryUninstallResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: LibraryUninstallResponse): LibraryUninstallResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibraryUninstallResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibraryUninstallResp;
-    static deserializeBinaryFromReader(message: LibraryUninstallResp, reader: jspb.BinaryReader): LibraryUninstallResp;
+    static serializeBinaryToWriter(message: LibraryUninstallResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibraryUninstallResponse;
+    static deserializeBinaryFromReader(message: LibraryUninstallResponse, reader: jspb.BinaryReader): LibraryUninstallResponse;
 }
 
-export namespace LibraryUninstallResp {
+export namespace LibraryUninstallResponse {
     export type AsObject = {
-        taskProgress?: commands_common_pb.TaskProgress.AsObject,
+        taskProgress?: cc_arduino_cli_commands_v1_common_pb.TaskProgress.AsObject,
     }
 }
 
-export class LibraryUpgradeAllReq extends jspb.Message { 
+export class LibraryUpgradeAllRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): LibraryUpgradeAllReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): LibraryUpgradeAllRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibraryUpgradeAllReq.AsObject;
-    static toObject(includeInstance: boolean, msg: LibraryUpgradeAllReq): LibraryUpgradeAllReq.AsObject;
+    toObject(includeInstance?: boolean): LibraryUpgradeAllRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: LibraryUpgradeAllRequest): LibraryUpgradeAllRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibraryUpgradeAllReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibraryUpgradeAllReq;
-    static deserializeBinaryFromReader(message: LibraryUpgradeAllReq, reader: jspb.BinaryReader): LibraryUpgradeAllReq;
+    static serializeBinaryToWriter(message: LibraryUpgradeAllRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibraryUpgradeAllRequest;
+    static deserializeBinaryFromReader(message: LibraryUpgradeAllRequest, reader: jspb.BinaryReader): LibraryUpgradeAllRequest;
 }
 
-export namespace LibraryUpgradeAllReq {
+export namespace LibraryUpgradeAllRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
     }
 }
 
-export class LibraryUpgradeAllResp extends jspb.Message { 
+export class LibraryUpgradeAllResponse extends jspb.Message { 
 
     hasProgress(): boolean;
     clearProgress(): void;
-    getProgress(): commands_common_pb.DownloadProgress | undefined;
-    setProgress(value?: commands_common_pb.DownloadProgress): LibraryUpgradeAllResp;
+    getProgress(): cc_arduino_cli_commands_v1_common_pb.DownloadProgress | undefined;
+    setProgress(value?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress): LibraryUpgradeAllResponse;
 
 
     hasTaskProgress(): boolean;
     clearTaskProgress(): void;
-    getTaskProgress(): commands_common_pb.TaskProgress | undefined;
-    setTaskProgress(value?: commands_common_pb.TaskProgress): LibraryUpgradeAllResp;
+    getTaskProgress(): cc_arduino_cli_commands_v1_common_pb.TaskProgress | undefined;
+    setTaskProgress(value?: cc_arduino_cli_commands_v1_common_pb.TaskProgress): LibraryUpgradeAllResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibraryUpgradeAllResp.AsObject;
-    static toObject(includeInstance: boolean, msg: LibraryUpgradeAllResp): LibraryUpgradeAllResp.AsObject;
+    toObject(includeInstance?: boolean): LibraryUpgradeAllResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: LibraryUpgradeAllResponse): LibraryUpgradeAllResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibraryUpgradeAllResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibraryUpgradeAllResp;
-    static deserializeBinaryFromReader(message: LibraryUpgradeAllResp, reader: jspb.BinaryReader): LibraryUpgradeAllResp;
+    static serializeBinaryToWriter(message: LibraryUpgradeAllResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibraryUpgradeAllResponse;
+    static deserializeBinaryFromReader(message: LibraryUpgradeAllResponse, reader: jspb.BinaryReader): LibraryUpgradeAllResponse;
 }
 
-export namespace LibraryUpgradeAllResp {
+export namespace LibraryUpgradeAllResponse {
     export type AsObject = {
-        progress?: commands_common_pb.DownloadProgress.AsObject,
-        taskProgress?: commands_common_pb.TaskProgress.AsObject,
+        progress?: cc_arduino_cli_commands_v1_common_pb.DownloadProgress.AsObject,
+        taskProgress?: cc_arduino_cli_commands_v1_common_pb.TaskProgress.AsObject,
     }
 }
 
-export class LibraryResolveDependenciesReq extends jspb.Message { 
+export class LibraryResolveDependenciesRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): LibraryResolveDependenciesReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): LibraryResolveDependenciesRequest;
 
     getName(): string;
-    setName(value: string): LibraryResolveDependenciesReq;
+    setName(value: string): LibraryResolveDependenciesRequest;
 
     getVersion(): string;
-    setVersion(value: string): LibraryResolveDependenciesReq;
+    setVersion(value: string): LibraryResolveDependenciesRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibraryResolveDependenciesReq.AsObject;
-    static toObject(includeInstance: boolean, msg: LibraryResolveDependenciesReq): LibraryResolveDependenciesReq.AsObject;
+    toObject(includeInstance?: boolean): LibraryResolveDependenciesRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: LibraryResolveDependenciesRequest): LibraryResolveDependenciesRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibraryResolveDependenciesReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibraryResolveDependenciesReq;
-    static deserializeBinaryFromReader(message: LibraryResolveDependenciesReq, reader: jspb.BinaryReader): LibraryResolveDependenciesReq;
+    static serializeBinaryToWriter(message: LibraryResolveDependenciesRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibraryResolveDependenciesRequest;
+    static deserializeBinaryFromReader(message: LibraryResolveDependenciesRequest, reader: jspb.BinaryReader): LibraryResolveDependenciesRequest;
 }
 
-export namespace LibraryResolveDependenciesReq {
+export namespace LibraryResolveDependenciesRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         name: string,
         version: string,
     }
 }
 
-export class LibraryResolveDependenciesResp extends jspb.Message { 
+export class LibraryResolveDependenciesResponse extends jspb.Message { 
     clearDependenciesList(): void;
     getDependenciesList(): Array<LibraryDependencyStatus>;
-    setDependenciesList(value: Array<LibraryDependencyStatus>): LibraryResolveDependenciesResp;
+    setDependenciesList(value: Array<LibraryDependencyStatus>): LibraryResolveDependenciesResponse;
     addDependencies(value?: LibraryDependencyStatus, index?: number): LibraryDependencyStatus;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibraryResolveDependenciesResp.AsObject;
-    static toObject(includeInstance: boolean, msg: LibraryResolveDependenciesResp): LibraryResolveDependenciesResp.AsObject;
+    toObject(includeInstance?: boolean): LibraryResolveDependenciesResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: LibraryResolveDependenciesResponse): LibraryResolveDependenciesResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibraryResolveDependenciesResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibraryResolveDependenciesResp;
-    static deserializeBinaryFromReader(message: LibraryResolveDependenciesResp, reader: jspb.BinaryReader): LibraryResolveDependenciesResp;
+    static serializeBinaryToWriter(message: LibraryResolveDependenciesResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibraryResolveDependenciesResponse;
+    static deserializeBinaryFromReader(message: LibraryResolveDependenciesResponse, reader: jspb.BinaryReader): LibraryResolveDependenciesResponse;
 }
 
-export namespace LibraryResolveDependenciesResp {
+export namespace LibraryResolveDependenciesResponse {
     export type AsObject = {
         dependenciesList: Array<LibraryDependencyStatus.AsObject>,
     }
@@ -300,11 +300,11 @@ export class LibraryDependencyStatus extends jspb.Message {
     getName(): string;
     setName(value: string): LibraryDependencyStatus;
 
-    getVersionrequired(): string;
-    setVersionrequired(value: string): LibraryDependencyStatus;
+    getVersionRequired(): string;
+    setVersionRequired(value: string): LibraryDependencyStatus;
 
-    getVersioninstalled(): string;
-    setVersioninstalled(value: string): LibraryDependencyStatus;
+    getVersionInstalled(): string;
+    setVersionInstalled(value: string): LibraryDependencyStatus;
 
 
     serializeBinary(): Uint8Array;
@@ -320,60 +320,60 @@ export class LibraryDependencyStatus extends jspb.Message {
 export namespace LibraryDependencyStatus {
     export type AsObject = {
         name: string,
-        versionrequired: string,
-        versioninstalled: string,
+        versionRequired: string,
+        versionInstalled: string,
     }
 }
 
-export class LibrarySearchReq extends jspb.Message { 
+export class LibrarySearchRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): LibrarySearchReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): LibrarySearchRequest;
 
     getQuery(): string;
-    setQuery(value: string): LibrarySearchReq;
+    setQuery(value: string): LibrarySearchRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibrarySearchReq.AsObject;
-    static toObject(includeInstance: boolean, msg: LibrarySearchReq): LibrarySearchReq.AsObject;
+    toObject(includeInstance?: boolean): LibrarySearchRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: LibrarySearchRequest): LibrarySearchRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibrarySearchReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibrarySearchReq;
-    static deserializeBinaryFromReader(message: LibrarySearchReq, reader: jspb.BinaryReader): LibrarySearchReq;
+    static serializeBinaryToWriter(message: LibrarySearchRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibrarySearchRequest;
+    static deserializeBinaryFromReader(message: LibrarySearchRequest, reader: jspb.BinaryReader): LibrarySearchRequest;
 }
 
-export namespace LibrarySearchReq {
+export namespace LibrarySearchRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         query: string,
     }
 }
 
-export class LibrarySearchResp extends jspb.Message { 
+export class LibrarySearchResponse extends jspb.Message { 
     clearLibrariesList(): void;
     getLibrariesList(): Array<SearchedLibrary>;
-    setLibrariesList(value: Array<SearchedLibrary>): LibrarySearchResp;
+    setLibrariesList(value: Array<SearchedLibrary>): LibrarySearchResponse;
     addLibraries(value?: SearchedLibrary, index?: number): SearchedLibrary;
 
     getStatus(): LibrarySearchStatus;
-    setStatus(value: LibrarySearchStatus): LibrarySearchResp;
+    setStatus(value: LibrarySearchStatus): LibrarySearchResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibrarySearchResp.AsObject;
-    static toObject(includeInstance: boolean, msg: LibrarySearchResp): LibrarySearchResp.AsObject;
+    toObject(includeInstance?: boolean): LibrarySearchResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: LibrarySearchResponse): LibrarySearchResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibrarySearchResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibrarySearchResp;
-    static deserializeBinaryFromReader(message: LibrarySearchResp, reader: jspb.BinaryReader): LibrarySearchResp;
+    static serializeBinaryToWriter(message: LibrarySearchResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibrarySearchResponse;
+    static deserializeBinaryFromReader(message: LibrarySearchResponse, reader: jspb.BinaryReader): LibrarySearchResponse;
 }
 
-export namespace LibrarySearchResp {
+export namespace LibrarySearchResponse {
     export type AsObject = {
         librariesList: Array<SearchedLibrary.AsObject>,
         status: LibrarySearchStatus,
@@ -523,8 +523,8 @@ export class DownloadResource extends jspb.Message {
     getUrl(): string;
     setUrl(value: string): DownloadResource;
 
-    getArchivefilename(): string;
-    setArchivefilename(value: string): DownloadResource;
+    getArchiveFilename(): string;
+    setArchiveFilename(value: string): DownloadResource;
 
     getChecksum(): string;
     setChecksum(value: string): DownloadResource;
@@ -532,8 +532,8 @@ export class DownloadResource extends jspb.Message {
     getSize(): number;
     setSize(value: number): DownloadResource;
 
-    getCachepath(): string;
-    setCachepath(value: string): DownloadResource;
+    getCachePath(): string;
+    setCachePath(value: string): DownloadResource;
 
 
     serializeBinary(): Uint8Array;
@@ -549,46 +549,46 @@ export class DownloadResource extends jspb.Message {
 export namespace DownloadResource {
     export type AsObject = {
         url: string,
-        archivefilename: string,
+        archiveFilename: string,
         checksum: string,
         size: number,
-        cachepath: string,
+        cachePath: string,
     }
 }
 
-export class LibraryListReq extends jspb.Message { 
+export class LibraryListRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): LibraryListReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): LibraryListRequest;
 
     getAll(): boolean;
-    setAll(value: boolean): LibraryListReq;
+    setAll(value: boolean): LibraryListRequest;
 
     getUpdatable(): boolean;
-    setUpdatable(value: boolean): LibraryListReq;
+    setUpdatable(value: boolean): LibraryListRequest;
 
     getName(): string;
-    setName(value: string): LibraryListReq;
+    setName(value: string): LibraryListRequest;
 
     getFqbn(): string;
-    setFqbn(value: string): LibraryListReq;
+    setFqbn(value: string): LibraryListRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibraryListReq.AsObject;
-    static toObject(includeInstance: boolean, msg: LibraryListReq): LibraryListReq.AsObject;
+    toObject(includeInstance?: boolean): LibraryListRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: LibraryListRequest): LibraryListRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibraryListReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibraryListReq;
-    static deserializeBinaryFromReader(message: LibraryListReq, reader: jspb.BinaryReader): LibraryListReq;
+    static serializeBinaryToWriter(message: LibraryListRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibraryListRequest;
+    static deserializeBinaryFromReader(message: LibraryListRequest, reader: jspb.BinaryReader): LibraryListRequest;
 }
 
-export namespace LibraryListReq {
+export namespace LibraryListRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         all: boolean,
         updatable: boolean,
         name: string,
@@ -596,26 +596,26 @@ export namespace LibraryListReq {
     }
 }
 
-export class LibraryListResp extends jspb.Message { 
-    clearInstalledLibraryList(): void;
-    getInstalledLibraryList(): Array<InstalledLibrary>;
-    setInstalledLibraryList(value: Array<InstalledLibrary>): LibraryListResp;
-    addInstalledLibrary(value?: InstalledLibrary, index?: number): InstalledLibrary;
+export class LibraryListResponse extends jspb.Message { 
+    clearInstalledLibrariesList(): void;
+    getInstalledLibrariesList(): Array<InstalledLibrary>;
+    setInstalledLibrariesList(value: Array<InstalledLibrary>): LibraryListResponse;
+    addInstalledLibraries(value?: InstalledLibrary, index?: number): InstalledLibrary;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): LibraryListResp.AsObject;
-    static toObject(includeInstance: boolean, msg: LibraryListResp): LibraryListResp.AsObject;
+    toObject(includeInstance?: boolean): LibraryListResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: LibraryListResponse): LibraryListResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: LibraryListResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): LibraryListResp;
-    static deserializeBinaryFromReader(message: LibraryListResp, reader: jspb.BinaryReader): LibraryListResp;
+    static serializeBinaryToWriter(message: LibraryListResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LibraryListResponse;
+    static deserializeBinaryFromReader(message: LibraryListResponse, reader: jspb.BinaryReader): LibraryListResponse;
 }
 
-export namespace LibraryListResp {
+export namespace LibraryListResponse {
     export type AsObject = {
-        installedLibraryList: Array<InstalledLibrary.AsObject>,
+        installedLibrariesList: Array<InstalledLibrary.AsObject>,
     }
 }
 
@@ -783,131 +783,132 @@ export namespace Library {
     }
 }
 
-export class ZipLibraryInstallReq extends jspb.Message { 
+export class ZipLibraryInstallRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): ZipLibraryInstallReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): ZipLibraryInstallRequest;
 
     getPath(): string;
-    setPath(value: string): ZipLibraryInstallReq;
+    setPath(value: string): ZipLibraryInstallRequest;
 
     getOverwrite(): boolean;
-    setOverwrite(value: boolean): ZipLibraryInstallReq;
+    setOverwrite(value: boolean): ZipLibraryInstallRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): ZipLibraryInstallReq.AsObject;
-    static toObject(includeInstance: boolean, msg: ZipLibraryInstallReq): ZipLibraryInstallReq.AsObject;
+    toObject(includeInstance?: boolean): ZipLibraryInstallRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: ZipLibraryInstallRequest): ZipLibraryInstallRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: ZipLibraryInstallReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): ZipLibraryInstallReq;
-    static deserializeBinaryFromReader(message: ZipLibraryInstallReq, reader: jspb.BinaryReader): ZipLibraryInstallReq;
+    static serializeBinaryToWriter(message: ZipLibraryInstallRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ZipLibraryInstallRequest;
+    static deserializeBinaryFromReader(message: ZipLibraryInstallRequest, reader: jspb.BinaryReader): ZipLibraryInstallRequest;
 }
 
-export namespace ZipLibraryInstallReq {
+export namespace ZipLibraryInstallRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         path: string,
         overwrite: boolean,
     }
 }
 
-export class ZipLibraryInstallResp extends jspb.Message { 
+export class ZipLibraryInstallResponse extends jspb.Message { 
 
     hasTaskProgress(): boolean;
     clearTaskProgress(): void;
-    getTaskProgress(): commands_common_pb.TaskProgress | undefined;
-    setTaskProgress(value?: commands_common_pb.TaskProgress): ZipLibraryInstallResp;
+    getTaskProgress(): cc_arduino_cli_commands_v1_common_pb.TaskProgress | undefined;
+    setTaskProgress(value?: cc_arduino_cli_commands_v1_common_pb.TaskProgress): ZipLibraryInstallResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): ZipLibraryInstallResp.AsObject;
-    static toObject(includeInstance: boolean, msg: ZipLibraryInstallResp): ZipLibraryInstallResp.AsObject;
+    toObject(includeInstance?: boolean): ZipLibraryInstallResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: ZipLibraryInstallResponse): ZipLibraryInstallResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: ZipLibraryInstallResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): ZipLibraryInstallResp;
-    static deserializeBinaryFromReader(message: ZipLibraryInstallResp, reader: jspb.BinaryReader): ZipLibraryInstallResp;
+    static serializeBinaryToWriter(message: ZipLibraryInstallResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ZipLibraryInstallResponse;
+    static deserializeBinaryFromReader(message: ZipLibraryInstallResponse, reader: jspb.BinaryReader): ZipLibraryInstallResponse;
 }
 
-export namespace ZipLibraryInstallResp {
+export namespace ZipLibraryInstallResponse {
     export type AsObject = {
-        taskProgress?: commands_common_pb.TaskProgress.AsObject,
+        taskProgress?: cc_arduino_cli_commands_v1_common_pb.TaskProgress.AsObject,
     }
 }
 
-export class GitLibraryInstallReq extends jspb.Message { 
+export class GitLibraryInstallRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): GitLibraryInstallReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): GitLibraryInstallRequest;
 
     getUrl(): string;
-    setUrl(value: string): GitLibraryInstallReq;
+    setUrl(value: string): GitLibraryInstallRequest;
 
     getOverwrite(): boolean;
-    setOverwrite(value: boolean): GitLibraryInstallReq;
+    setOverwrite(value: boolean): GitLibraryInstallRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GitLibraryInstallReq.AsObject;
-    static toObject(includeInstance: boolean, msg: GitLibraryInstallReq): GitLibraryInstallReq.AsObject;
+    toObject(includeInstance?: boolean): GitLibraryInstallRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: GitLibraryInstallRequest): GitLibraryInstallRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GitLibraryInstallReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GitLibraryInstallReq;
-    static deserializeBinaryFromReader(message: GitLibraryInstallReq, reader: jspb.BinaryReader): GitLibraryInstallReq;
+    static serializeBinaryToWriter(message: GitLibraryInstallRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GitLibraryInstallRequest;
+    static deserializeBinaryFromReader(message: GitLibraryInstallRequest, reader: jspb.BinaryReader): GitLibraryInstallRequest;
 }
 
-export namespace GitLibraryInstallReq {
+export namespace GitLibraryInstallRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         url: string,
         overwrite: boolean,
     }
 }
 
-export class GitLibraryInstallResp extends jspb.Message { 
+export class GitLibraryInstallResponse extends jspb.Message { 
 
     hasTaskProgress(): boolean;
     clearTaskProgress(): void;
-    getTaskProgress(): commands_common_pb.TaskProgress | undefined;
-    setTaskProgress(value?: commands_common_pb.TaskProgress): GitLibraryInstallResp;
+    getTaskProgress(): cc_arduino_cli_commands_v1_common_pb.TaskProgress | undefined;
+    setTaskProgress(value?: cc_arduino_cli_commands_v1_common_pb.TaskProgress): GitLibraryInstallResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GitLibraryInstallResp.AsObject;
-    static toObject(includeInstance: boolean, msg: GitLibraryInstallResp): GitLibraryInstallResp.AsObject;
+    toObject(includeInstance?: boolean): GitLibraryInstallResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: GitLibraryInstallResponse): GitLibraryInstallResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GitLibraryInstallResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GitLibraryInstallResp;
-    static deserializeBinaryFromReader(message: GitLibraryInstallResp, reader: jspb.BinaryReader): GitLibraryInstallResp;
+    static serializeBinaryToWriter(message: GitLibraryInstallResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GitLibraryInstallResponse;
+    static deserializeBinaryFromReader(message: GitLibraryInstallResponse, reader: jspb.BinaryReader): GitLibraryInstallResponse;
 }
 
-export namespace GitLibraryInstallResp {
+export namespace GitLibraryInstallResponse {
     export type AsObject = {
-        taskProgress?: commands_common_pb.TaskProgress.AsObject,
+        taskProgress?: cc_arduino_cli_commands_v1_common_pb.TaskProgress.AsObject,
     }
 }
 
 export enum LibrarySearchStatus {
-    FAILED = 0,
-    SUCCESS = 1,
+    LIBRARY_SEARCH_STATUS_FAILED = 0,
+    LIBRARY_SEARCH_STATUS_SUCCESS = 1,
 }
 
 export enum LibraryLayout {
-    FLAT_LAYOUT = 0,
-    RECURSIVE_LAYOUT = 1,
+    LIBRARY_LAYOUT_FLAT = 0,
+    LIBRARY_LAYOUT_RECURSIVE = 1,
 }
 
 export enum LibraryLocation {
-    IDE_BUILTIN = 0,
-    USER = 1,
-    PLATFORM_BUILTIN = 2,
-    REFERENCED_PLATFORM_BUILTIN = 3,
+    LIBRARY_LOCATION_IDE_BUILTIN = 0,
+    LIBRARY_LOCATION_USER = 1,
+    LIBRARY_LOCATION_PLATFORM_BUILTIN = 2,
+    LIBRARY_LOCATION_REFERENCED_PLATFORM_BUILTIN = 3,
+    LIBRARY_LOCATION_UNMANAGED = 4,
 }

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/upload_pb.d.ts

@@ -1,57 +1,57 @@
-// package: cc.arduino.cli.commands
-// file: commands/upload.proto
+// package: cc.arduino.cli.commands.v1
+// file: cc/arduino/cli/commands/v1/upload.proto
 
 /* tslint:disable */
 /* eslint-disable */
 
 import * as jspb from "google-protobuf";
-import * as commands_common_pb from "../commands/common_pb";
+import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino/cli/commands/v1/common_pb";
 
-export class UploadReq extends jspb.Message { 
+export class UploadRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): UploadReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): UploadRequest;
 
     getFqbn(): string;
-    setFqbn(value: string): UploadReq;
+    setFqbn(value: string): UploadRequest;
 
     getSketchPath(): string;
-    setSketchPath(value: string): UploadReq;
+    setSketchPath(value: string): UploadRequest;
 
     getPort(): string;
-    setPort(value: string): UploadReq;
+    setPort(value: string): UploadRequest;
 
     getVerbose(): boolean;
-    setVerbose(value: boolean): UploadReq;
+    setVerbose(value: boolean): UploadRequest;
 
     getVerify(): boolean;
-    setVerify(value: boolean): UploadReq;
+    setVerify(value: boolean): UploadRequest;
 
     getImportFile(): string;
-    setImportFile(value: string): UploadReq;
+    setImportFile(value: string): UploadRequest;
 
     getImportDir(): string;
-    setImportDir(value: string): UploadReq;
+    setImportDir(value: string): UploadRequest;
 
     getProgrammer(): string;
-    setProgrammer(value: string): UploadReq;
+    setProgrammer(value: string): UploadRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): UploadReq.AsObject;
-    static toObject(includeInstance: boolean, msg: UploadReq): UploadReq.AsObject;
+    toObject(includeInstance?: boolean): UploadRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: UploadRequest): UploadRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: UploadReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): UploadReq;
-    static deserializeBinaryFromReader(message: UploadReq, reader: jspb.BinaryReader): UploadReq;
+    static serializeBinaryToWriter(message: UploadRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UploadRequest;
+    static deserializeBinaryFromReader(message: UploadRequest, reader: jspb.BinaryReader): UploadRequest;
 }
 
-export namespace UploadReq {
+export namespace UploadRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         fqbn: string,
         sketchPath: string,
         port: string,
@@ -63,80 +63,80 @@ export namespace UploadReq {
     }
 }
 
-export class UploadResp extends jspb.Message { 
+export class UploadResponse extends jspb.Message { 
     getOutStream(): Uint8Array | string;
     getOutStream_asU8(): Uint8Array;
     getOutStream_asB64(): string;
-    setOutStream(value: Uint8Array | string): UploadResp;
+    setOutStream(value: Uint8Array | string): UploadResponse;
 
     getErrStream(): Uint8Array | string;
     getErrStream_asU8(): Uint8Array;
     getErrStream_asB64(): string;
-    setErrStream(value: Uint8Array | string): UploadResp;
+    setErrStream(value: Uint8Array | string): UploadResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): UploadResp.AsObject;
-    static toObject(includeInstance: boolean, msg: UploadResp): UploadResp.AsObject;
+    toObject(includeInstance?: boolean): UploadResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: UploadResponse): UploadResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: UploadResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): UploadResp;
-    static deserializeBinaryFromReader(message: UploadResp, reader: jspb.BinaryReader): UploadResp;
+    static serializeBinaryToWriter(message: UploadResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UploadResponse;
+    static deserializeBinaryFromReader(message: UploadResponse, reader: jspb.BinaryReader): UploadResponse;
 }
 
-export namespace UploadResp {
+export namespace UploadResponse {
     export type AsObject = {
         outStream: Uint8Array | string,
         errStream: Uint8Array | string,
     }
 }
 
-export class UploadUsingProgrammerReq extends jspb.Message { 
+export class UploadUsingProgrammerRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): UploadUsingProgrammerReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): UploadUsingProgrammerRequest;
 
     getFqbn(): string;
-    setFqbn(value: string): UploadUsingProgrammerReq;
+    setFqbn(value: string): UploadUsingProgrammerRequest;
 
     getSketchPath(): string;
-    setSketchPath(value: string): UploadUsingProgrammerReq;
+    setSketchPath(value: string): UploadUsingProgrammerRequest;
 
     getPort(): string;
-    setPort(value: string): UploadUsingProgrammerReq;
+    setPort(value: string): UploadUsingProgrammerRequest;
 
     getVerbose(): boolean;
-    setVerbose(value: boolean): UploadUsingProgrammerReq;
+    setVerbose(value: boolean): UploadUsingProgrammerRequest;
 
     getVerify(): boolean;
-    setVerify(value: boolean): UploadUsingProgrammerReq;
+    setVerify(value: boolean): UploadUsingProgrammerRequest;
 
     getImportFile(): string;
-    setImportFile(value: string): UploadUsingProgrammerReq;
+    setImportFile(value: string): UploadUsingProgrammerRequest;
 
     getImportDir(): string;
-    setImportDir(value: string): UploadUsingProgrammerReq;
+    setImportDir(value: string): UploadUsingProgrammerRequest;
 
     getProgrammer(): string;
-    setProgrammer(value: string): UploadUsingProgrammerReq;
+    setProgrammer(value: string): UploadUsingProgrammerRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): UploadUsingProgrammerReq.AsObject;
-    static toObject(includeInstance: boolean, msg: UploadUsingProgrammerReq): UploadUsingProgrammerReq.AsObject;
+    toObject(includeInstance?: boolean): UploadUsingProgrammerRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: UploadUsingProgrammerRequest): UploadUsingProgrammerRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: UploadUsingProgrammerReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): UploadUsingProgrammerReq;
-    static deserializeBinaryFromReader(message: UploadUsingProgrammerReq, reader: jspb.BinaryReader): UploadUsingProgrammerReq;
+    static serializeBinaryToWriter(message: UploadUsingProgrammerRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UploadUsingProgrammerRequest;
+    static deserializeBinaryFromReader(message: UploadUsingProgrammerRequest, reader: jspb.BinaryReader): UploadUsingProgrammerRequest;
 }
 
-export namespace UploadUsingProgrammerReq {
+export namespace UploadUsingProgrammerRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         fqbn: string,
         sketchPath: string,
         port: string,
@@ -148,71 +148,71 @@ export namespace UploadUsingProgrammerReq {
     }
 }
 
-export class UploadUsingProgrammerResp extends jspb.Message { 
+export class UploadUsingProgrammerResponse extends jspb.Message { 
     getOutStream(): Uint8Array | string;
     getOutStream_asU8(): Uint8Array;
     getOutStream_asB64(): string;
-    setOutStream(value: Uint8Array | string): UploadUsingProgrammerResp;
+    setOutStream(value: Uint8Array | string): UploadUsingProgrammerResponse;
 
     getErrStream(): Uint8Array | string;
     getErrStream_asU8(): Uint8Array;
     getErrStream_asB64(): string;
-    setErrStream(value: Uint8Array | string): UploadUsingProgrammerResp;
+    setErrStream(value: Uint8Array | string): UploadUsingProgrammerResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): UploadUsingProgrammerResp.AsObject;
-    static toObject(includeInstance: boolean, msg: UploadUsingProgrammerResp): UploadUsingProgrammerResp.AsObject;
+    toObject(includeInstance?: boolean): UploadUsingProgrammerResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: UploadUsingProgrammerResponse): UploadUsingProgrammerResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: UploadUsingProgrammerResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): UploadUsingProgrammerResp;
-    static deserializeBinaryFromReader(message: UploadUsingProgrammerResp, reader: jspb.BinaryReader): UploadUsingProgrammerResp;
+    static serializeBinaryToWriter(message: UploadUsingProgrammerResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UploadUsingProgrammerResponse;
+    static deserializeBinaryFromReader(message: UploadUsingProgrammerResponse, reader: jspb.BinaryReader): UploadUsingProgrammerResponse;
 }
 
-export namespace UploadUsingProgrammerResp {
+export namespace UploadUsingProgrammerResponse {
     export type AsObject = {
         outStream: Uint8Array | string,
         errStream: Uint8Array | string,
     }
 }
 
-export class BurnBootloaderReq extends jspb.Message { 
+export class BurnBootloaderRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): BurnBootloaderReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): BurnBootloaderRequest;
 
     getFqbn(): string;
-    setFqbn(value: string): BurnBootloaderReq;
+    setFqbn(value: string): BurnBootloaderRequest;
 
     getPort(): string;
-    setPort(value: string): BurnBootloaderReq;
+    setPort(value: string): BurnBootloaderRequest;
 
     getVerbose(): boolean;
-    setVerbose(value: boolean): BurnBootloaderReq;
+    setVerbose(value: boolean): BurnBootloaderRequest;
 
     getVerify(): boolean;
-    setVerify(value: boolean): BurnBootloaderReq;
+    setVerify(value: boolean): BurnBootloaderRequest;
 
     getProgrammer(): string;
-    setProgrammer(value: string): BurnBootloaderReq;
+    setProgrammer(value: string): BurnBootloaderRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BurnBootloaderReq.AsObject;
-    static toObject(includeInstance: boolean, msg: BurnBootloaderReq): BurnBootloaderReq.AsObject;
+    toObject(includeInstance?: boolean): BurnBootloaderRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: BurnBootloaderRequest): BurnBootloaderRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BurnBootloaderReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BurnBootloaderReq;
-    static deserializeBinaryFromReader(message: BurnBootloaderReq, reader: jspb.BinaryReader): BurnBootloaderReq;
+    static serializeBinaryToWriter(message: BurnBootloaderRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BurnBootloaderRequest;
+    static deserializeBinaryFromReader(message: BurnBootloaderRequest, reader: jspb.BinaryReader): BurnBootloaderRequest;
 }
 
-export namespace BurnBootloaderReq {
+export namespace BurnBootloaderRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         fqbn: string,
         port: string,
         verbose: boolean,
@@ -221,82 +221,82 @@ export namespace BurnBootloaderReq {
     }
 }
 
-export class BurnBootloaderResp extends jspb.Message { 
+export class BurnBootloaderResponse extends jspb.Message { 
     getOutStream(): Uint8Array | string;
     getOutStream_asU8(): Uint8Array;
     getOutStream_asB64(): string;
-    setOutStream(value: Uint8Array | string): BurnBootloaderResp;
+    setOutStream(value: Uint8Array | string): BurnBootloaderResponse;
 
     getErrStream(): Uint8Array | string;
     getErrStream_asU8(): Uint8Array;
     getErrStream_asB64(): string;
-    setErrStream(value: Uint8Array | string): BurnBootloaderResp;
+    setErrStream(value: Uint8Array | string): BurnBootloaderResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BurnBootloaderResp.AsObject;
-    static toObject(includeInstance: boolean, msg: BurnBootloaderResp): BurnBootloaderResp.AsObject;
+    toObject(includeInstance?: boolean): BurnBootloaderResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: BurnBootloaderResponse): BurnBootloaderResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BurnBootloaderResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BurnBootloaderResp;
-    static deserializeBinaryFromReader(message: BurnBootloaderResp, reader: jspb.BinaryReader): BurnBootloaderResp;
+    static serializeBinaryToWriter(message: BurnBootloaderResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BurnBootloaderResponse;
+    static deserializeBinaryFromReader(message: BurnBootloaderResponse, reader: jspb.BinaryReader): BurnBootloaderResponse;
 }
 
-export namespace BurnBootloaderResp {
+export namespace BurnBootloaderResponse {
     export type AsObject = {
         outStream: Uint8Array | string,
         errStream: Uint8Array | string,
     }
 }
 
-export class ListProgrammersAvailableForUploadReq extends jspb.Message { 
+export class ListProgrammersAvailableForUploadRequest extends jspb.Message { 
 
     hasInstance(): boolean;
     clearInstance(): void;
-    getInstance(): commands_common_pb.Instance | undefined;
-    setInstance(value?: commands_common_pb.Instance): ListProgrammersAvailableForUploadReq;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): ListProgrammersAvailableForUploadRequest;
 
     getFqbn(): string;
-    setFqbn(value: string): ListProgrammersAvailableForUploadReq;
+    setFqbn(value: string): ListProgrammersAvailableForUploadRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): ListProgrammersAvailableForUploadReq.AsObject;
-    static toObject(includeInstance: boolean, msg: ListProgrammersAvailableForUploadReq): ListProgrammersAvailableForUploadReq.AsObject;
+    toObject(includeInstance?: boolean): ListProgrammersAvailableForUploadRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: ListProgrammersAvailableForUploadRequest): ListProgrammersAvailableForUploadRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: ListProgrammersAvailableForUploadReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): ListProgrammersAvailableForUploadReq;
-    static deserializeBinaryFromReader(message: ListProgrammersAvailableForUploadReq, reader: jspb.BinaryReader): ListProgrammersAvailableForUploadReq;
+    static serializeBinaryToWriter(message: ListProgrammersAvailableForUploadRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ListProgrammersAvailableForUploadRequest;
+    static deserializeBinaryFromReader(message: ListProgrammersAvailableForUploadRequest, reader: jspb.BinaryReader): ListProgrammersAvailableForUploadRequest;
 }
 
-export namespace ListProgrammersAvailableForUploadReq {
+export namespace ListProgrammersAvailableForUploadRequest {
     export type AsObject = {
-        instance?: commands_common_pb.Instance.AsObject,
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         fqbn: string,
     }
 }
 
-export class ListProgrammersAvailableForUploadResp extends jspb.Message { 
+export class ListProgrammersAvailableForUploadResponse extends jspb.Message { 
     clearProgrammersList(): void;
-    getProgrammersList(): Array<commands_common_pb.Programmer>;
-    setProgrammersList(value: Array<commands_common_pb.Programmer>): ListProgrammersAvailableForUploadResp;
-    addProgrammers(value?: commands_common_pb.Programmer, index?: number): commands_common_pb.Programmer;
+    getProgrammersList(): Array<cc_arduino_cli_commands_v1_common_pb.Programmer>;
+    setProgrammersList(value: Array<cc_arduino_cli_commands_v1_common_pb.Programmer>): ListProgrammersAvailableForUploadResponse;
+    addProgrammers(value?: cc_arduino_cli_commands_v1_common_pb.Programmer, index?: number): cc_arduino_cli_commands_v1_common_pb.Programmer;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): ListProgrammersAvailableForUploadResp.AsObject;
-    static toObject(includeInstance: boolean, msg: ListProgrammersAvailableForUploadResp): ListProgrammersAvailableForUploadResp.AsObject;
+    toObject(includeInstance?: boolean): ListProgrammersAvailableForUploadResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: ListProgrammersAvailableForUploadResponse): ListProgrammersAvailableForUploadResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: ListProgrammersAvailableForUploadResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): ListProgrammersAvailableForUploadResp;
-    static deserializeBinaryFromReader(message: ListProgrammersAvailableForUploadResp, reader: jspb.BinaryReader): ListProgrammersAvailableForUploadResp;
+    static serializeBinaryToWriter(message: ListProgrammersAvailableForUploadResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ListProgrammersAvailableForUploadResponse;
+    static deserializeBinaryFromReader(message: ListProgrammersAvailableForUploadResponse, reader: jspb.BinaryReader): ListProgrammersAvailableForUploadResponse;
 }
 
-export namespace ListProgrammersAvailableForUploadResp {
+export namespace ListProgrammersAvailableForUploadResponse {
     export type AsObject = {
-        programmersList: Array<commands_common_pb.Programmer.AsObject>,
+        programmersList: Array<cc_arduino_cli_commands_v1_common_pb.Programmer.AsObject>,
     }
 }

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/debug/v1/debug_grpc_pb.d.ts

@@ -0,0 +1,59 @@
+// package: cc.arduino.cli.debug.v1
+// file: cc/arduino/cli/debug/v1/debug.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as grpc from "@grpc/grpc-js";
+import {handleClientStreamingCall} from "@grpc/grpc-js/build/src/server-call";
+import * as cc_arduino_cli_debug_v1_debug_pb from "../../../../../cc/arduino/cli/debug/v1/debug_pb";
+import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino/cli/commands/v1/common_pb";
+
+interface IDebugServiceService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+    debug: IDebugServiceService_IDebug;
+    getDebugConfig: IDebugServiceService_IGetDebugConfig;
+}
+
+interface IDebugServiceService_IDebug extends grpc.MethodDefinition<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse> {
+    path: "/cc.arduino.cli.debug.v1.DebugService/Debug";
+    requestStream: true;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_debug_v1_debug_pb.DebugRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_debug_v1_debug_pb.DebugRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
+}
+interface IDebugServiceService_IGetDebugConfig extends grpc.MethodDefinition<cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse> {
+    path: "/cc.arduino.cli.debug.v1.DebugService/GetDebugConfig";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse>;
+}
+
+export const DebugServiceService: IDebugServiceService;
+
+export interface IDebugServiceServer {
+    debug: grpc.handleBidiStreamingCall<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
+    getDebugConfig: grpc.handleUnaryCall<cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse>;
+}
+
+export interface IDebugServiceClient {
+    debug(): grpc.ClientDuplexStream<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
+    debug(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
+    debug(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
+    getDebugConfig(request: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
+    getDebugConfig(request: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
+    getDebugConfig(request: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
+}
+
+export class DebugServiceClient extends grpc.Client implements IDebugServiceClient {
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: Partial<grpc.ClientOptions>);
+    public debug(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
+    public debug(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
+    public getDebugConfig(request: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
+    public getDebugConfig(request: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
+    public getDebugConfig(request: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
+}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/debug/v1/debug_grpc_pb.js

@@ -0,0 +1,94 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+// Original file comments:
+// This file is part of arduino-cli.
+//
+// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)
+//
+// This software is released under the GNU General Public License version 3,
+// which covers the main part of arduino-cli.
+// The terms of this license can be found at:
+// https://www.gnu.org/licenses/gpl-3.0.en.html
+//
+// You can be released from the requirements of the above licenses by purchasing
+// a commercial license. Buying such a license is mandatory if you want to
+// modify or otherwise use the software for commercial activities involving the
+// Arduino software without disclosing the source code of your own applications.
+// To purchase a commercial license, send an email to license@arduino.cc.
+//
+'use strict';
+var cc_arduino_cli_debug_v1_debug_pb = require('../../../../../cc/arduino/cli/debug/v1/debug_pb.js');
+var cc_arduino_cli_commands_v1_common_pb = require('../../../../../cc/arduino/cli/commands/v1/common_pb.js');
+
+function serialize_cc_arduino_cli_debug_v1_DebugConfigRequest(arg) {
+  if (!(arg instanceof cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest)) {
+    throw new Error('Expected argument of type cc.arduino.cli.debug.v1.DebugConfigRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_debug_v1_DebugConfigRequest(buffer_arg) {
+  return cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_debug_v1_DebugRequest(arg) {
+  if (!(arg instanceof cc_arduino_cli_debug_v1_debug_pb.DebugRequest)) {
+    throw new Error('Expected argument of type cc.arduino.cli.debug.v1.DebugRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_debug_v1_DebugRequest(buffer_arg) {
+  return cc_arduino_cli_debug_v1_debug_pb.DebugRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_debug_v1_DebugResponse(arg) {
+  if (!(arg instanceof cc_arduino_cli_debug_v1_debug_pb.DebugResponse)) {
+    throw new Error('Expected argument of type cc.arduino.cli.debug.v1.DebugResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_debug_v1_DebugResponse(buffer_arg) {
+  return cc_arduino_cli_debug_v1_debug_pb.DebugResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_debug_v1_GetDebugConfigResponse(arg) {
+  if (!(arg instanceof cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse)) {
+    throw new Error('Expected argument of type cc.arduino.cli.debug.v1.GetDebugConfigResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_debug_v1_GetDebugConfigResponse(buffer_arg) {
+  return cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+
+// DebugService abstracts a debug Session usage
+var DebugServiceService = exports['cc.arduino.cli.debug.v1.DebugService'] = {
+  // Start a debug session and communicate with the debugger tool.
+debug: {
+    path: '/cc.arduino.cli.debug.v1.DebugService/Debug',
+    requestStream: true,
+    responseStream: true,
+    requestType: cc_arduino_cli_debug_v1_debug_pb.DebugRequest,
+    responseType: cc_arduino_cli_debug_v1_debug_pb.DebugResponse,
+    requestSerialize: serialize_cc_arduino_cli_debug_v1_DebugRequest,
+    requestDeserialize: deserialize_cc_arduino_cli_debug_v1_DebugRequest,
+    responseSerialize: serialize_cc_arduino_cli_debug_v1_DebugResponse,
+    responseDeserialize: deserialize_cc_arduino_cli_debug_v1_DebugResponse,
+  },
+  getDebugConfig: {
+    path: '/cc.arduino.cli.debug.v1.DebugService/GetDebugConfig',
+    requestStream: false,
+    responseStream: false,
+    requestType: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest,
+    responseType: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse,
+    requestSerialize: serialize_cc_arduino_cli_debug_v1_DebugConfigRequest,
+    requestDeserialize: deserialize_cc_arduino_cli_debug_v1_DebugConfigRequest,
+    responseSerialize: serialize_cc_arduino_cli_debug_v1_GetDebugConfigResponse,
+    responseDeserialize: deserialize_cc_arduino_cli_debug_v1_GetDebugConfigResponse,
+  },
+};
+

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/debug/v1/debug_pb.d.ts

@@ -0,0 +1,170 @@
+// package: cc.arduino.cli.debug.v1
+// file: cc/arduino/cli/debug/v1/debug.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as jspb from "google-protobuf";
+import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino/cli/commands/v1/common_pb";
+
+export class DebugRequest extends jspb.Message { 
+
+    hasDebugRequest(): boolean;
+    clearDebugRequest(): void;
+    getDebugRequest(): DebugConfigRequest | undefined;
+    setDebugRequest(value?: DebugConfigRequest): DebugRequest;
+
+    getData(): Uint8Array | string;
+    getData_asU8(): Uint8Array;
+    getData_asB64(): string;
+    setData(value: Uint8Array | string): DebugRequest;
+
+    getSendInterrupt(): boolean;
+    setSendInterrupt(value: boolean): DebugRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DebugRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: DebugRequest): DebugRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DebugRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DebugRequest;
+    static deserializeBinaryFromReader(message: DebugRequest, reader: jspb.BinaryReader): DebugRequest;
+}
+
+export namespace DebugRequest {
+    export type AsObject = {
+        debugRequest?: DebugConfigRequest.AsObject,
+        data: Uint8Array | string,
+        sendInterrupt: boolean,
+    }
+}
+
+export class DebugConfigRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): DebugConfigRequest;
+
+    getFqbn(): string;
+    setFqbn(value: string): DebugConfigRequest;
+
+    getSketchPath(): string;
+    setSketchPath(value: string): DebugConfigRequest;
+
+    getPort(): string;
+    setPort(value: string): DebugConfigRequest;
+
+    getInterpreter(): string;
+    setInterpreter(value: string): DebugConfigRequest;
+
+    getImportDir(): string;
+    setImportDir(value: string): DebugConfigRequest;
+
+    getProgrammer(): string;
+    setProgrammer(value: string): DebugConfigRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DebugConfigRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: DebugConfigRequest): DebugConfigRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DebugConfigRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DebugConfigRequest;
+    static deserializeBinaryFromReader(message: DebugConfigRequest, reader: jspb.BinaryReader): DebugConfigRequest;
+}
+
+export namespace DebugConfigRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+        fqbn: string,
+        sketchPath: string,
+        port: string,
+        interpreter: string,
+        importDir: string,
+        programmer: string,
+    }
+}
+
+export class DebugResponse extends jspb.Message { 
+    getData(): Uint8Array | string;
+    getData_asU8(): Uint8Array;
+    getData_asB64(): string;
+    setData(value: Uint8Array | string): DebugResponse;
+
+    getError(): string;
+    setError(value: string): DebugResponse;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DebugResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: DebugResponse): DebugResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DebugResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DebugResponse;
+    static deserializeBinaryFromReader(message: DebugResponse, reader: jspb.BinaryReader): DebugResponse;
+}
+
+export namespace DebugResponse {
+    export type AsObject = {
+        data: Uint8Array | string,
+        error: string,
+    }
+}
+
+export class GetDebugConfigResponse extends jspb.Message { 
+    getExecutable(): string;
+    setExecutable(value: string): GetDebugConfigResponse;
+
+    getToolchain(): string;
+    setToolchain(value: string): GetDebugConfigResponse;
+
+    getToolchainPath(): string;
+    setToolchainPath(value: string): GetDebugConfigResponse;
+
+    getToolchainPrefix(): string;
+    setToolchainPrefix(value: string): GetDebugConfigResponse;
+
+    getServer(): string;
+    setServer(value: string): GetDebugConfigResponse;
+
+    getServerPath(): string;
+    setServerPath(value: string): GetDebugConfigResponse;
+
+
+    getToolchainConfigurationMap(): jspb.Map<string, string>;
+    clearToolchainConfigurationMap(): void;
+
+
+    getServerConfigurationMap(): jspb.Map<string, string>;
+    clearServerConfigurationMap(): void;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetDebugConfigResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: GetDebugConfigResponse): GetDebugConfigResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetDebugConfigResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetDebugConfigResponse;
+    static deserializeBinaryFromReader(message: GetDebugConfigResponse, reader: jspb.BinaryReader): GetDebugConfigResponse;
+}
+
+export namespace GetDebugConfigResponse {
+    export type AsObject = {
+        executable: string,
+        toolchain: string,
+        toolchainPath: string,
+        toolchainPrefix: string,
+        server: string,
+        serverPath: string,
+
+        toolchainConfigurationMap: Array<[string, string]>,
+
+        serverConfigurationMap: Array<[string, string]>,
+    }
+}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/debug/v1/debug_pb.js

@@ -1,7 +1,8 @@
-// source: debug/debug.proto
+// source: cc/arduino/cli/debug/v1/debug.proto
 /**
  * @fileoverview
  * @enhanceable
+ * @suppress {missingRequire} reports error on implicit type usages.
  * @suppress {messageConventions} JS Compiler reports an error if a variable or
  *     field starts with 'MSG_' and isn't a translatable message.
  * @public
@@ -14,12 +15,12 @@ var jspb = require('google-protobuf');
 var goog = jspb;
 var global = Function('return this')();
 
-var commands_common_pb = require('../commands/common_pb.js');
-goog.object.extend(proto, commands_common_pb);
-goog.exportSymbol('proto.cc.arduino.cli.debug.DebugConfigReq', null, global);
-goog.exportSymbol('proto.cc.arduino.cli.debug.DebugReq', null, global);
-goog.exportSymbol('proto.cc.arduino.cli.debug.DebugResp', null, global);
-goog.exportSymbol('proto.cc.arduino.cli.debug.GetDebugConfigResp', null, global);
+var cc_arduino_cli_commands_v1_common_pb = require('../../../../../cc/arduino/cli/commands/v1/common_pb.js');
+goog.object.extend(proto, cc_arduino_cli_commands_v1_common_pb);
+goog.exportSymbol('proto.cc.arduino.cli.debug.v1.DebugConfigRequest', null, global);
+goog.exportSymbol('proto.cc.arduino.cli.debug.v1.DebugRequest', null, global);
+goog.exportSymbol('proto.cc.arduino.cli.debug.v1.DebugResponse', null, global);
+goog.exportSymbol('proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse', null, global);
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
@@ -30,16 +31,16 @@ goog.exportSymbol('proto.cc.arduino.cli.debug.GetDebugConfigResp', null, global)
  * @extends {jspb.Message}
  * @constructor
  */
-proto.cc.arduino.cli.debug.DebugReq = function(opt_data) {
+proto.cc.arduino.cli.debug.v1.DebugRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
-goog.inherits(proto.cc.arduino.cli.debug.DebugReq, jspb.Message);
+goog.inherits(proto.cc.arduino.cli.debug.v1.DebugRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
-  proto.cc.arduino.cli.debug.DebugReq.displayName = 'proto.cc.arduino.cli.debug.DebugReq';
+  proto.cc.arduino.cli.debug.v1.DebugRequest.displayName = 'proto.cc.arduino.cli.debug.v1.DebugRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
@@ -51,16 +52,16 @@ if (goog.DEBUG && !COMPILED) {
  * @extends {jspb.Message}
  * @constructor
  */
-proto.cc.arduino.cli.debug.DebugConfigReq = function(opt_data) {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
-goog.inherits(proto.cc.arduino.cli.debug.DebugConfigReq, jspb.Message);
+goog.inherits(proto.cc.arduino.cli.debug.v1.DebugConfigRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
-  proto.cc.arduino.cli.debug.DebugConfigReq.displayName = 'proto.cc.arduino.cli.debug.DebugConfigReq';
+  proto.cc.arduino.cli.debug.v1.DebugConfigRequest.displayName = 'proto.cc.arduino.cli.debug.v1.DebugConfigRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
@@ -72,16 +73,16 @@ if (goog.DEBUG && !COMPILED) {
  * @extends {jspb.Message}
  * @constructor
  */
-proto.cc.arduino.cli.debug.DebugResp = function(opt_data) {
+proto.cc.arduino.cli.debug.v1.DebugResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
-goog.inherits(proto.cc.arduino.cli.debug.DebugResp, jspb.Message);
+goog.inherits(proto.cc.arduino.cli.debug.v1.DebugResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
-  proto.cc.arduino.cli.debug.DebugResp.displayName = 'proto.cc.arduino.cli.debug.DebugResp';
+  proto.cc.arduino.cli.debug.v1.DebugResponse.displayName = 'proto.cc.arduino.cli.debug.v1.DebugResponse';
 }
 /**
  * Generated by JsPbCodeGenerator.
@@ -93,16 +94,16 @@ if (goog.DEBUG && !COMPILED) {
  * @extends {jspb.Message}
  * @constructor
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp = function(opt_data) {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
-goog.inherits(proto.cc.arduino.cli.debug.GetDebugConfigResp, jspb.Message);
+goog.inherits(proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
-  proto.cc.arduino.cli.debug.GetDebugConfigResp.displayName = 'proto.cc.arduino.cli.debug.GetDebugConfigResp';
+  proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.displayName = 'proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse';
 }
 
 
@@ -120,8 +121,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) {
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
-proto.cc.arduino.cli.debug.DebugReq.prototype.toObject = function(opt_includeInstance) {
-  return proto.cc.arduino.cli.debug.DebugReq.toObject(opt_includeInstance, this);
+proto.cc.arduino.cli.debug.v1.DebugRequest.prototype.toObject = function(opt_includeInstance) {
+  return proto.cc.arduino.cli.debug.v1.DebugRequest.toObject(opt_includeInstance, this);
 };
 
 
@@ -130,13 +131,13 @@ proto.cc.arduino.cli.debug.DebugReq.prototype.toObject = function(opt_includeIns
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
- * @param {!proto.cc.arduino.cli.debug.DebugReq} msg The msg instance to transform.
+ * @param {!proto.cc.arduino.cli.debug.v1.DebugRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
-proto.cc.arduino.cli.debug.DebugReq.toObject = function(includeInstance, msg) {
+proto.cc.arduino.cli.debug.v1.DebugRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
-    debugreq: (f = msg.getDebugreq()) && proto.cc.arduino.cli.debug.DebugConfigReq.toObject(includeInstance, f),
+    debugRequest: (f = msg.getDebugRequest()) && proto.cc.arduino.cli.debug.v1.DebugConfigRequest.toObject(includeInstance, f),
     data: msg.getData_asB64(),
     sendInterrupt: jspb.Message.getBooleanFieldWithDefault(msg, 3, false)
   };
@@ -152,23 +153,23 @@ proto.cc.arduino.cli.debug.DebugReq.toObject = function(includeInstance, msg) {
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
- * @return {!proto.cc.arduino.cli.debug.DebugReq}
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugRequest}
  */
-proto.cc.arduino.cli.debug.DebugReq.deserializeBinary = function(bytes) {
+proto.cc.arduino.cli.debug.v1.DebugRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
-  var msg = new proto.cc.arduino.cli.debug.DebugReq;
-  return proto.cc.arduino.cli.debug.DebugReq.deserializeBinaryFromReader(msg, reader);
+  var msg = new proto.cc.arduino.cli.debug.v1.DebugRequest;
+  return proto.cc.arduino.cli.debug.v1.DebugRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
- * @param {!proto.cc.arduino.cli.debug.DebugReq} msg The message object to deserialize into.
+ * @param {!proto.cc.arduino.cli.debug.v1.DebugRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
- * @return {!proto.cc.arduino.cli.debug.DebugReq}
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugRequest}
  */
-proto.cc.arduino.cli.debug.DebugReq.deserializeBinaryFromReader = function(msg, reader) {
+proto.cc.arduino.cli.debug.v1.DebugRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
@@ -176,9 +177,9 @@ proto.cc.arduino.cli.debug.DebugReq.deserializeBinaryFromReader = function(msg,
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
-      var value = new proto.cc.arduino.cli.debug.DebugConfigReq;
-      reader.readMessage(value,proto.cc.arduino.cli.debug.DebugConfigReq.deserializeBinaryFromReader);
-      msg.setDebugreq(value);
+      var value = new proto.cc.arduino.cli.debug.v1.DebugConfigRequest;
+      reader.readMessage(value,proto.cc.arduino.cli.debug.v1.DebugConfigRequest.deserializeBinaryFromReader);
+      msg.setDebugRequest(value);
       break;
     case 2:
       var value = /** @type {!Uint8Array} */ (reader.readBytes());
@@ -201,9 +202,9 @@ proto.cc.arduino.cli.debug.DebugReq.deserializeBinaryFromReader = function(msg,
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
-proto.cc.arduino.cli.debug.DebugReq.prototype.serializeBinary = function() {
+proto.cc.arduino.cli.debug.v1.DebugRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
-  proto.cc.arduino.cli.debug.DebugReq.serializeBinaryToWriter(this, writer);
+  proto.cc.arduino.cli.debug.v1.DebugRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
@@ -211,18 +212,18 @@ proto.cc.arduino.cli.debug.DebugReq.prototype.serializeBinary = function() {
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
- * @param {!proto.cc.arduino.cli.debug.DebugReq} message
+ * @param {!proto.cc.arduino.cli.debug.v1.DebugRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
-proto.cc.arduino.cli.debug.DebugReq.serializeBinaryToWriter = function(message, writer) {
+proto.cc.arduino.cli.debug.v1.DebugRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
-  f = message.getDebugreq();
+  f = message.getDebugRequest();
   if (f != null) {
     writer.writeMessage(
       1,
       f,
-      proto.cc.arduino.cli.debug.DebugConfigReq.serializeBinaryToWriter
+      proto.cc.arduino.cli.debug.v1.DebugConfigRequest.serializeBinaryToWriter
     );
   }
   f = message.getData_asU8();
@@ -243,30 +244,30 @@ proto.cc.arduino.cli.debug.DebugReq.serializeBinaryToWriter = function(message,
 
 
 /**
- * optional DebugConfigReq debugReq = 1;
- * @return {?proto.cc.arduino.cli.debug.DebugConfigReq}
+ * optional DebugConfigRequest debug_request = 1;
+ * @return {?proto.cc.arduino.cli.debug.v1.DebugConfigRequest}
  */
-proto.cc.arduino.cli.debug.DebugReq.prototype.getDebugreq = function() {
-  return /** @type{?proto.cc.arduino.cli.debug.DebugConfigReq} */ (
-    jspb.Message.getWrapperField(this, proto.cc.arduino.cli.debug.DebugConfigReq, 1));
+proto.cc.arduino.cli.debug.v1.DebugRequest.prototype.getDebugRequest = function() {
+  return /** @type{?proto.cc.arduino.cli.debug.v1.DebugConfigRequest} */ (
+    jspb.Message.getWrapperField(this, proto.cc.arduino.cli.debug.v1.DebugConfigRequest, 1));
 };
 
 
 /**
- * @param {?proto.cc.arduino.cli.debug.DebugConfigReq|undefined} value
- * @return {!proto.cc.arduino.cli.debug.DebugReq} returns this
+ * @param {?proto.cc.arduino.cli.debug.v1.DebugConfigRequest|undefined} value
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugRequest} returns this
 */
-proto.cc.arduino.cli.debug.DebugReq.prototype.setDebugreq = function(value) {
+proto.cc.arduino.cli.debug.v1.DebugRequest.prototype.setDebugRequest = function(value) {
   return jspb.Message.setWrapperField(this, 1, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
- * @return {!proto.cc.arduino.cli.debug.DebugReq} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugRequest} returns this
  */
-proto.cc.arduino.cli.debug.DebugReq.prototype.clearDebugreq = function() {
-  return this.setDebugreq(undefined);
+proto.cc.arduino.cli.debug.v1.DebugRequest.prototype.clearDebugRequest = function() {
+  return this.setDebugRequest(undefined);
 };
 
 
@@ -274,7 +275,7 @@ proto.cc.arduino.cli.debug.DebugReq.prototype.clearDebugreq = function() {
  * Returns whether this field is set.
  * @return {boolean}
  */
-proto.cc.arduino.cli.debug.DebugReq.prototype.hasDebugreq = function() {
+proto.cc.arduino.cli.debug.v1.DebugRequest.prototype.hasDebugRequest = function() {
   return jspb.Message.getField(this, 1) != null;
 };
 
@@ -283,7 +284,7 @@ proto.cc.arduino.cli.debug.DebugReq.prototype.hasDebugreq = function() {
  * optional bytes data = 2;
  * @return {!(string|Uint8Array)}
  */
-proto.cc.arduino.cli.debug.DebugReq.prototype.getData = function() {
+proto.cc.arduino.cli.debug.v1.DebugRequest.prototype.getData = function() {
   return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
@@ -293,7 +294,7 @@ proto.cc.arduino.cli.debug.DebugReq.prototype.getData = function() {
  * This is a type-conversion wrapper around `getData()`
  * @return {string}
  */
-proto.cc.arduino.cli.debug.DebugReq.prototype.getData_asB64 = function() {
+proto.cc.arduino.cli.debug.v1.DebugRequest.prototype.getData_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getData()));
 };
@@ -306,7 +307,7 @@ proto.cc.arduino.cli.debug.DebugReq.prototype.getData_asB64 = function() {
  * This is a type-conversion wrapper around `getData()`
  * @return {!Uint8Array}
  */
-proto.cc.arduino.cli.debug.DebugReq.prototype.getData_asU8 = function() {
+proto.cc.arduino.cli.debug.v1.DebugRequest.prototype.getData_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getData()));
 };
@@ -314,9 +315,9 @@ proto.cc.arduino.cli.debug.DebugReq.prototype.getData_asU8 = function() {
 
 /**
  * @param {!(string|Uint8Array)} value
- * @return {!proto.cc.arduino.cli.debug.DebugReq} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugRequest} returns this
  */
-proto.cc.arduino.cli.debug.DebugReq.prototype.setData = function(value) {
+proto.cc.arduino.cli.debug.v1.DebugRequest.prototype.setData = function(value) {
   return jspb.Message.setProto3BytesField(this, 2, value);
 };
 
@@ -325,16 +326,16 @@ proto.cc.arduino.cli.debug.DebugReq.prototype.setData = function(value) {
  * optional bool send_interrupt = 3;
  * @return {boolean}
  */
-proto.cc.arduino.cli.debug.DebugReq.prototype.getSendInterrupt = function() {
+proto.cc.arduino.cli.debug.v1.DebugRequest.prototype.getSendInterrupt = function() {
   return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 3, false));
 };
 
 
 /**
  * @param {boolean} value
- * @return {!proto.cc.arduino.cli.debug.DebugReq} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugRequest} returns this
  */
-proto.cc.arduino.cli.debug.DebugReq.prototype.setSendInterrupt = function(value) {
+proto.cc.arduino.cli.debug.v1.DebugRequest.prototype.setSendInterrupt = function(value) {
   return jspb.Message.setProto3BooleanField(this, 3, value);
 };
 
@@ -355,8 +356,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) {
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.toObject = function(opt_includeInstance) {
-  return proto.cc.arduino.cli.debug.DebugConfigReq.toObject(opt_includeInstance, this);
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.toObject = function(opt_includeInstance) {
+  return proto.cc.arduino.cli.debug.v1.DebugConfigRequest.toObject(opt_includeInstance, this);
 };
 
 
@@ -365,13 +366,13 @@ proto.cc.arduino.cli.debug.DebugConfigReq.prototype.toObject = function(opt_incl
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
- * @param {!proto.cc.arduino.cli.debug.DebugConfigReq} msg The msg instance to transform.
+ * @param {!proto.cc.arduino.cli.debug.v1.DebugConfigRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.toObject = function(includeInstance, msg) {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
-    instance: (f = msg.getInstance()) && commands_common_pb.Instance.toObject(includeInstance, f),
+    instance: (f = msg.getInstance()) && cc_arduino_cli_commands_v1_common_pb.Instance.toObject(includeInstance, f),
     fqbn: jspb.Message.getFieldWithDefault(msg, 2, ""),
     sketchPath: jspb.Message.getFieldWithDefault(msg, 3, ""),
     port: jspb.Message.getFieldWithDefault(msg, 4, ""),
@@ -391,23 +392,23 @@ proto.cc.arduino.cli.debug.DebugConfigReq.toObject = function(includeInstance, m
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
- * @return {!proto.cc.arduino.cli.debug.DebugConfigReq}
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugConfigRequest}
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.deserializeBinary = function(bytes) {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
-  var msg = new proto.cc.arduino.cli.debug.DebugConfigReq;
-  return proto.cc.arduino.cli.debug.DebugConfigReq.deserializeBinaryFromReader(msg, reader);
+  var msg = new proto.cc.arduino.cli.debug.v1.DebugConfigRequest;
+  return proto.cc.arduino.cli.debug.v1.DebugConfigRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
- * @param {!proto.cc.arduino.cli.debug.DebugConfigReq} msg The message object to deserialize into.
+ * @param {!proto.cc.arduino.cli.debug.v1.DebugConfigRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
- * @return {!proto.cc.arduino.cli.debug.DebugConfigReq}
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugConfigRequest}
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.deserializeBinaryFromReader = function(msg, reader) {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
@@ -415,8 +416,8 @@ proto.cc.arduino.cli.debug.DebugConfigReq.deserializeBinaryFromReader = function
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
-      var value = new commands_common_pb.Instance;
-      reader.readMessage(value,commands_common_pb.Instance.deserializeBinaryFromReader);
+      var value = new cc_arduino_cli_commands_v1_common_pb.Instance;
+      reader.readMessage(value,cc_arduino_cli_commands_v1_common_pb.Instance.deserializeBinaryFromReader);
       msg.setInstance(value);
       break;
     case 2:
@@ -456,9 +457,9 @@ proto.cc.arduino.cli.debug.DebugConfigReq.deserializeBinaryFromReader = function
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.serializeBinary = function() {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
-  proto.cc.arduino.cli.debug.DebugConfigReq.serializeBinaryToWriter(this, writer);
+  proto.cc.arduino.cli.debug.v1.DebugConfigRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
@@ -466,18 +467,18 @@ proto.cc.arduino.cli.debug.DebugConfigReq.prototype.serializeBinary = function()
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
- * @param {!proto.cc.arduino.cli.debug.DebugConfigReq} message
+ * @param {!proto.cc.arduino.cli.debug.v1.DebugConfigRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.serializeBinaryToWriter = function(message, writer) {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getInstance();
   if (f != null) {
     writer.writeMessage(
       1,
       f,
-      commands_common_pb.Instance.serializeBinaryToWriter
+      cc_arduino_cli_commands_v1_common_pb.Instance.serializeBinaryToWriter
     );
   }
   f = message.getFqbn();
@@ -526,29 +527,29 @@ proto.cc.arduino.cli.debug.DebugConfigReq.serializeBinaryToWriter = function(mes
 
 
 /**
- * optional cc.arduino.cli.commands.Instance instance = 1;
- * @return {?proto.cc.arduino.cli.commands.Instance}
+ * optional cc.arduino.cli.commands.v1.Instance instance = 1;
+ * @return {?proto.cc.arduino.cli.commands.v1.Instance}
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.getInstance = function() {
-  return /** @type{?proto.cc.arduino.cli.commands.Instance} */ (
-    jspb.Message.getWrapperField(this, commands_common_pb.Instance, 1));
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.getInstance = function() {
+  return /** @type{?proto.cc.arduino.cli.commands.v1.Instance} */ (
+    jspb.Message.getWrapperField(this, cc_arduino_cli_commands_v1_common_pb.Instance, 1));
 };
 
 
 /**
- * @param {?proto.cc.arduino.cli.commands.Instance|undefined} value
- * @return {!proto.cc.arduino.cli.debug.DebugConfigReq} returns this
+ * @param {?proto.cc.arduino.cli.commands.v1.Instance|undefined} value
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugConfigRequest} returns this
 */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.setInstance = function(value) {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.setInstance = function(value) {
   return jspb.Message.setWrapperField(this, 1, value);
 };
 
 
 /**
  * Clears the message field making it undefined.
- * @return {!proto.cc.arduino.cli.debug.DebugConfigReq} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugConfigRequest} returns this
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.clearInstance = function() {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.clearInstance = function() {
   return this.setInstance(undefined);
 };
 
@@ -557,7 +558,7 @@ proto.cc.arduino.cli.debug.DebugConfigReq.prototype.clearInstance = function() {
  * Returns whether this field is set.
  * @return {boolean}
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.hasInstance = function() {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.hasInstance = function() {
   return jspb.Message.getField(this, 1) != null;
 };
 
@@ -566,16 +567,16 @@ proto.cc.arduino.cli.debug.DebugConfigReq.prototype.hasInstance = function() {
  * optional string fqbn = 2;
  * @return {string}
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.getFqbn = function() {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.getFqbn = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
- * @return {!proto.cc.arduino.cli.debug.DebugConfigReq} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugConfigRequest} returns this
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.setFqbn = function(value) {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.setFqbn = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
@@ -584,16 +585,16 @@ proto.cc.arduino.cli.debug.DebugConfigReq.prototype.setFqbn = function(value) {
  * optional string sketch_path = 3;
  * @return {string}
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.getSketchPath = function() {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.getSketchPath = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
 };
 
 
 /**
  * @param {string} value
- * @return {!proto.cc.arduino.cli.debug.DebugConfigReq} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugConfigRequest} returns this
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.setSketchPath = function(value) {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.setSketchPath = function(value) {
   return jspb.Message.setProto3StringField(this, 3, value);
 };
 
@@ -602,16 +603,16 @@ proto.cc.arduino.cli.debug.DebugConfigReq.prototype.setSketchPath = function(val
  * optional string port = 4;
  * @return {string}
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.getPort = function() {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.getPort = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
 };
 
 
 /**
  * @param {string} value
- * @return {!proto.cc.arduino.cli.debug.DebugConfigReq} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugConfigRequest} returns this
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.setPort = function(value) {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.setPort = function(value) {
   return jspb.Message.setProto3StringField(this, 4, value);
 };
 
@@ -620,16 +621,16 @@ proto.cc.arduino.cli.debug.DebugConfigReq.prototype.setPort = function(value) {
  * optional string interpreter = 5;
  * @return {string}
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.getInterpreter = function() {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.getInterpreter = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, ""));
 };
 
 
 /**
  * @param {string} value
- * @return {!proto.cc.arduino.cli.debug.DebugConfigReq} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugConfigRequest} returns this
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.setInterpreter = function(value) {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.setInterpreter = function(value) {
   return jspb.Message.setProto3StringField(this, 5, value);
 };
 
@@ -638,16 +639,16 @@ proto.cc.arduino.cli.debug.DebugConfigReq.prototype.setInterpreter = function(va
  * optional string import_dir = 8;
  * @return {string}
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.getImportDir = function() {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.getImportDir = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 8, ""));
 };
 
 
 /**
  * @param {string} value
- * @return {!proto.cc.arduino.cli.debug.DebugConfigReq} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugConfigRequest} returns this
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.setImportDir = function(value) {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.setImportDir = function(value) {
   return jspb.Message.setProto3StringField(this, 8, value);
 };
 
@@ -656,16 +657,16 @@ proto.cc.arduino.cli.debug.DebugConfigReq.prototype.setImportDir = function(valu
  * optional string programmer = 9;
  * @return {string}
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.getProgrammer = function() {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.getProgrammer = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 9, ""));
 };
 
 
 /**
  * @param {string} value
- * @return {!proto.cc.arduino.cli.debug.DebugConfigReq} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugConfigRequest} returns this
  */
-proto.cc.arduino.cli.debug.DebugConfigReq.prototype.setProgrammer = function(value) {
+proto.cc.arduino.cli.debug.v1.DebugConfigRequest.prototype.setProgrammer = function(value) {
   return jspb.Message.setProto3StringField(this, 9, value);
 };
 
@@ -686,8 +687,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) {
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
-proto.cc.arduino.cli.debug.DebugResp.prototype.toObject = function(opt_includeInstance) {
-  return proto.cc.arduino.cli.debug.DebugResp.toObject(opt_includeInstance, this);
+proto.cc.arduino.cli.debug.v1.DebugResponse.prototype.toObject = function(opt_includeInstance) {
+  return proto.cc.arduino.cli.debug.v1.DebugResponse.toObject(opt_includeInstance, this);
 };
 
 
@@ -696,11 +697,11 @@ proto.cc.arduino.cli.debug.DebugResp.prototype.toObject = function(opt_includeIn
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
- * @param {!proto.cc.arduino.cli.debug.DebugResp} msg The msg instance to transform.
+ * @param {!proto.cc.arduino.cli.debug.v1.DebugResponse} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
-proto.cc.arduino.cli.debug.DebugResp.toObject = function(includeInstance, msg) {
+proto.cc.arduino.cli.debug.v1.DebugResponse.toObject = function(includeInstance, msg) {
   var f, obj = {
     data: msg.getData_asB64(),
     error: jspb.Message.getFieldWithDefault(msg, 2, "")
@@ -717,23 +718,23 @@ proto.cc.arduino.cli.debug.DebugResp.toObject = function(includeInstance, msg) {
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
- * @return {!proto.cc.arduino.cli.debug.DebugResp}
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugResponse}
  */
-proto.cc.arduino.cli.debug.DebugResp.deserializeBinary = function(bytes) {
+proto.cc.arduino.cli.debug.v1.DebugResponse.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
-  var msg = new proto.cc.arduino.cli.debug.DebugResp;
-  return proto.cc.arduino.cli.debug.DebugResp.deserializeBinaryFromReader(msg, reader);
+  var msg = new proto.cc.arduino.cli.debug.v1.DebugResponse;
+  return proto.cc.arduino.cli.debug.v1.DebugResponse.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
- * @param {!proto.cc.arduino.cli.debug.DebugResp} msg The message object to deserialize into.
+ * @param {!proto.cc.arduino.cli.debug.v1.DebugResponse} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
- * @return {!proto.cc.arduino.cli.debug.DebugResp}
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugResponse}
  */
-proto.cc.arduino.cli.debug.DebugResp.deserializeBinaryFromReader = function(msg, reader) {
+proto.cc.arduino.cli.debug.v1.DebugResponse.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
@@ -761,9 +762,9 @@ proto.cc.arduino.cli.debug.DebugResp.deserializeBinaryFromReader = function(msg,
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
-proto.cc.arduino.cli.debug.DebugResp.prototype.serializeBinary = function() {
+proto.cc.arduino.cli.debug.v1.DebugResponse.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
-  proto.cc.arduino.cli.debug.DebugResp.serializeBinaryToWriter(this, writer);
+  proto.cc.arduino.cli.debug.v1.DebugResponse.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
@@ -771,11 +772,11 @@ proto.cc.arduino.cli.debug.DebugResp.prototype.serializeBinary = function() {
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
- * @param {!proto.cc.arduino.cli.debug.DebugResp} message
+ * @param {!proto.cc.arduino.cli.debug.v1.DebugResponse} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
-proto.cc.arduino.cli.debug.DebugResp.serializeBinaryToWriter = function(message, writer) {
+proto.cc.arduino.cli.debug.v1.DebugResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getData_asU8();
   if (f.length > 0) {
@@ -798,7 +799,7 @@ proto.cc.arduino.cli.debug.DebugResp.serializeBinaryToWriter = function(message,
  * optional bytes data = 1;
  * @return {!(string|Uint8Array)}
  */
-proto.cc.arduino.cli.debug.DebugResp.prototype.getData = function() {
+proto.cc.arduino.cli.debug.v1.DebugResponse.prototype.getData = function() {
   return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
@@ -808,7 +809,7 @@ proto.cc.arduino.cli.debug.DebugResp.prototype.getData = function() {
  * This is a type-conversion wrapper around `getData()`
  * @return {string}
  */
-proto.cc.arduino.cli.debug.DebugResp.prototype.getData_asB64 = function() {
+proto.cc.arduino.cli.debug.v1.DebugResponse.prototype.getData_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getData()));
 };
@@ -821,7 +822,7 @@ proto.cc.arduino.cli.debug.DebugResp.prototype.getData_asB64 = function() {
  * This is a type-conversion wrapper around `getData()`
  * @return {!Uint8Array}
  */
-proto.cc.arduino.cli.debug.DebugResp.prototype.getData_asU8 = function() {
+proto.cc.arduino.cli.debug.v1.DebugResponse.prototype.getData_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getData()));
 };
@@ -829,9 +830,9 @@ proto.cc.arduino.cli.debug.DebugResp.prototype.getData_asU8 = function() {
 
 /**
  * @param {!(string|Uint8Array)} value
- * @return {!proto.cc.arduino.cli.debug.DebugResp} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugResponse} returns this
  */
-proto.cc.arduino.cli.debug.DebugResp.prototype.setData = function(value) {
+proto.cc.arduino.cli.debug.v1.DebugResponse.prototype.setData = function(value) {
   return jspb.Message.setProto3BytesField(this, 1, value);
 };
 
@@ -840,16 +841,16 @@ proto.cc.arduino.cli.debug.DebugResp.prototype.setData = function(value) {
  * optional string error = 2;
  * @return {string}
  */
-proto.cc.arduino.cli.debug.DebugResp.prototype.getError = function() {
+proto.cc.arduino.cli.debug.v1.DebugResponse.prototype.getError = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
- * @return {!proto.cc.arduino.cli.debug.DebugResp} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.DebugResponse} returns this
  */
-proto.cc.arduino.cli.debug.DebugResp.prototype.setError = function(value) {
+proto.cc.arduino.cli.debug.v1.DebugResponse.prototype.setError = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
@@ -870,8 +871,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) {
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.toObject = function(opt_includeInstance) {
-  return proto.cc.arduino.cli.debug.GetDebugConfigResp.toObject(opt_includeInstance, this);
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.toObject = function(opt_includeInstance) {
+  return proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.toObject(opt_includeInstance, this);
 };
 
 
@@ -880,11 +881,11 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.toObject = function(opt_
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
- * @param {!proto.cc.arduino.cli.debug.GetDebugConfigResp} msg The msg instance to transform.
+ * @param {!proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.toObject = function(includeInstance, msg) {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.toObject = function(includeInstance, msg) {
   var f, obj = {
     executable: jspb.Message.getFieldWithDefault(msg, 1, ""),
     toolchain: jspb.Message.getFieldWithDefault(msg, 2, ""),
@@ -907,23 +908,23 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.toObject = function(includeInstanc
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
- * @return {!proto.cc.arduino.cli.debug.GetDebugConfigResp}
+ * @return {!proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse}
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.deserializeBinary = function(bytes) {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
-  var msg = new proto.cc.arduino.cli.debug.GetDebugConfigResp;
-  return proto.cc.arduino.cli.debug.GetDebugConfigResp.deserializeBinaryFromReader(msg, reader);
+  var msg = new proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse;
+  return proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
- * @param {!proto.cc.arduino.cli.debug.GetDebugConfigResp} msg The message object to deserialize into.
+ * @param {!proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
- * @return {!proto.cc.arduino.cli.debug.GetDebugConfigResp}
+ * @return {!proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse}
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.deserializeBinaryFromReader = function(msg, reader) {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
@@ -979,9 +980,9 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.deserializeBinaryFromReader = func
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.serializeBinary = function() {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
-  proto.cc.arduino.cli.debug.GetDebugConfigResp.serializeBinaryToWriter(this, writer);
+  proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
@@ -989,11 +990,11 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.serializeBinary = functi
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
- * @param {!proto.cc.arduino.cli.debug.GetDebugConfigResp} message
+ * @param {!proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.serializeBinaryToWriter = function(message, writer) {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getExecutable();
   if (f.length > 0) {
@@ -1052,16 +1053,16 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.serializeBinaryToWriter = function
  * optional string executable = 1;
  * @return {string}
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.getExecutable = function() {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.getExecutable = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
 /**
  * @param {string} value
- * @return {!proto.cc.arduino.cli.debug.GetDebugConfigResp} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse} returns this
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.setExecutable = function(value) {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.setExecutable = function(value) {
   return jspb.Message.setProto3StringField(this, 1, value);
 };
 
@@ -1070,16 +1071,16 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.setExecutable = function
  * optional string toolchain = 2;
  * @return {string}
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.getToolchain = function() {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.getToolchain = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
 /**
  * @param {string} value
- * @return {!proto.cc.arduino.cli.debug.GetDebugConfigResp} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse} returns this
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.setToolchain = function(value) {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.setToolchain = function(value) {
   return jspb.Message.setProto3StringField(this, 2, value);
 };
 
@@ -1088,16 +1089,16 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.setToolchain = function(
  * optional string toolchain_path = 3;
  * @return {string}
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.getToolchainPath = function() {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.getToolchainPath = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
 };
 
 
 /**
  * @param {string} value
- * @return {!proto.cc.arduino.cli.debug.GetDebugConfigResp} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse} returns this
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.setToolchainPath = function(value) {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.setToolchainPath = function(value) {
   return jspb.Message.setProto3StringField(this, 3, value);
 };
 
@@ -1106,16 +1107,16 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.setToolchainPath = funct
  * optional string toolchain_prefix = 4;
  * @return {string}
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.getToolchainPrefix = function() {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.getToolchainPrefix = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
 };
 
 
 /**
  * @param {string} value
- * @return {!proto.cc.arduino.cli.debug.GetDebugConfigResp} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse} returns this
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.setToolchainPrefix = function(value) {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.setToolchainPrefix = function(value) {
   return jspb.Message.setProto3StringField(this, 4, value);
 };
 
@@ -1124,16 +1125,16 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.setToolchainPrefix = fun
  * optional string server = 5;
  * @return {string}
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.getServer = function() {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.getServer = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, ""));
 };
 
 
 /**
  * @param {string} value
- * @return {!proto.cc.arduino.cli.debug.GetDebugConfigResp} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse} returns this
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.setServer = function(value) {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.setServer = function(value) {
   return jspb.Message.setProto3StringField(this, 5, value);
 };
 
@@ -1142,16 +1143,16 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.setServer = function(val
  * optional string server_path = 6;
  * @return {string}
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.getServerPath = function() {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.getServerPath = function() {
   return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 6, ""));
 };
 
 
 /**
  * @param {string} value
- * @return {!proto.cc.arduino.cli.debug.GetDebugConfigResp} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse} returns this
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.setServerPath = function(value) {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.setServerPath = function(value) {
   return jspb.Message.setProto3StringField(this, 6, value);
 };
 
@@ -1162,7 +1163,7 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.setServerPath = function
  * empty, instead returning `undefined`
  * @return {!jspb.Map<string,string>}
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.getToolchainConfigurationMap = function(opt_noLazyCreate) {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.getToolchainConfigurationMap = function(opt_noLazyCreate) {
   return /** @type {!jspb.Map<string,string>} */ (
       jspb.Message.getMapField(this, 7, opt_noLazyCreate,
       null));
@@ -1171,9 +1172,9 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.getToolchainConfiguratio
 
 /**
  * Clears values from the map. The map will be non-null.
- * @return {!proto.cc.arduino.cli.debug.GetDebugConfigResp} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse} returns this
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.clearToolchainConfigurationMap = function() {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.clearToolchainConfigurationMap = function() {
   this.getToolchainConfigurationMap().clear();
   return this;};
 
@@ -1184,7 +1185,7 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.clearToolchainConfigurat
  * empty, instead returning `undefined`
  * @return {!jspb.Map<string,string>}
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.getServerConfigurationMap = function(opt_noLazyCreate) {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.getServerConfigurationMap = function(opt_noLazyCreate) {
   return /** @type {!jspb.Map<string,string>} */ (
       jspb.Message.getMapField(this, 8, opt_noLazyCreate,
       null));
@@ -1193,11 +1194,11 @@ proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.getServerConfigurationMa
 
 /**
  * Clears values from the map. The map will be non-null.
- * @return {!proto.cc.arduino.cli.debug.GetDebugConfigResp} returns this
+ * @return {!proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse} returns this
  */
-proto.cc.arduino.cli.debug.GetDebugConfigResp.prototype.clearServerConfigurationMap = function() {
+proto.cc.arduino.cli.debug.v1.GetDebugConfigResponse.prototype.clearServerConfigurationMap = function() {
   this.getServerConfigurationMap().clear();
   return this;};
 
 
-goog.object.extend(exports, proto.cc.arduino.cli.debug);
+goog.object.extend(exports, proto.cc.arduino.cli.debug.v1);

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/monitor/v1/monitor_grpc_pb.d.ts

@@ -0,0 +1,42 @@
+// package: cc.arduino.cli.monitor.v1
+// file: cc/arduino/cli/monitor/v1/monitor.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as grpc from "@grpc/grpc-js";
+import {handleClientStreamingCall} from "@grpc/grpc-js/build/src/server-call";
+import * as cc_arduino_cli_monitor_v1_monitor_pb from "../../../../../cc/arduino/cli/monitor/v1/monitor_pb";
+import * as google_protobuf_struct_pb from "google-protobuf/google/protobuf/struct_pb";
+
+interface IMonitorServiceService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+    streamingOpen: IMonitorServiceService_IStreamingOpen;
+}
+
+interface IMonitorServiceService_IStreamingOpen extends grpc.MethodDefinition<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse> {
+    path: "/cc.arduino.cli.monitor.v1.MonitorService/StreamingOpen";
+    requestStream: true;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
+}
+
+export const MonitorServiceService: IMonitorServiceService;
+
+export interface IMonitorServiceServer {
+    streamingOpen: grpc.handleBidiStreamingCall<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
+}
+
+export interface IMonitorServiceClient {
+    streamingOpen(): grpc.ClientDuplexStream<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
+    streamingOpen(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
+    streamingOpen(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
+}
+
+export class MonitorServiceClient extends grpc.Client implements IMonitorServiceClient {
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: Partial<grpc.ClientOptions>);
+    public streamingOpen(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
+    public streamingOpen(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
+}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/monitor/v1/monitor_grpc_pb.js

@@ -0,0 +1,62 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+// Original file comments:
+// This file is part of arduino-cli.
+//
+// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)
+//
+// This software is released under the GNU General Public License version 3,
+// which covers the main part of arduino-cli.
+// The terms of this license can be found at:
+// https://www.gnu.org/licenses/gpl-3.0.en.html
+//
+// You can be released from the requirements of the above licenses by purchasing
+// a commercial license. Buying such a license is mandatory if you want to
+// modify or otherwise use the software for commercial activities involving the
+// Arduino software without disclosing the source code of your own applications.
+// To purchase a commercial license, send an email to license@arduino.cc.
+//
+'use strict';
+var cc_arduino_cli_monitor_v1_monitor_pb = require('../../../../../cc/arduino/cli/monitor/v1/monitor_pb.js');
+var google_protobuf_struct_pb = require('google-protobuf/google/protobuf/struct_pb.js');
+
+function serialize_cc_arduino_cli_monitor_v1_StreamingOpenRequest(arg) {
+  if (!(arg instanceof cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest)) {
+    throw new Error('Expected argument of type cc.arduino.cli.monitor.v1.StreamingOpenRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_monitor_v1_StreamingOpenRequest(buffer_arg) {
+  return cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_monitor_v1_StreamingOpenResponse(arg) {
+  if (!(arg instanceof cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse)) {
+    throw new Error('Expected argument of type cc.arduino.cli.monitor.v1.StreamingOpenResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_monitor_v1_StreamingOpenResponse(buffer_arg) {
+  return cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+
+// MonitorService provides services for boards monitor
+var MonitorServiceService = exports['cc.arduino.cli.monitor.v1.MonitorService'] = {
+  // Open a bidirectional monitor stream. This can be used to implement
+// something similar to the Arduino IDE's Serial Monitor.
+streamingOpen: {
+    path: '/cc.arduino.cli.monitor.v1.MonitorService/StreamingOpen',
+    requestStream: true,
+    responseStream: true,
+    requestType: cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest,
+    responseType: cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse,
+    requestSerialize: serialize_cc_arduino_cli_monitor_v1_StreamingOpenRequest,
+    requestDeserialize: deserialize_cc_arduino_cli_monitor_v1_StreamingOpenRequest,
+    responseSerialize: serialize_cc_arduino_cli_monitor_v1_StreamingOpenResponse,
+    responseDeserialize: deserialize_cc_arduino_cli_monitor_v1_StreamingOpenResponse,
+  },
+};
+

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/monitor/v1/monitor_pb.d.ts

@@ -1,5 +1,5 @@
-// package: cc.arduino.cli.monitor
-// file: monitor/monitor.proto
+// package: cc.arduino.cli.monitor.v1
+// file: cc/arduino/cli/monitor/v1/monitor.proto
 
 /* tslint:disable */
 /* eslint-disable */
@@ -7,12 +7,12 @@
 import * as jspb from "google-protobuf";
 import * as google_protobuf_struct_pb from "google-protobuf/google/protobuf/struct_pb";
 
-export class StreamingOpenReq extends jspb.Message { 
+export class StreamingOpenRequest extends jspb.Message { 
 
-    hasMonitorconfig(): boolean;
-    clearMonitorconfig(): void;
-    getMonitorconfig(): MonitorConfig | undefined;
-    setMonitorconfig(value?: MonitorConfig): StreamingOpenReq;
+    hasConfig(): boolean;
+    clearConfig(): void;
+    getConfig(): MonitorConfig | undefined;
+    setConfig(value?: MonitorConfig): StreamingOpenRequest;
 
 
     hasData(): boolean;
@@ -20,34 +20,43 @@ export class StreamingOpenReq extends jspb.Message {
     getData(): Uint8Array | string;
     getData_asU8(): Uint8Array;
     getData_asB64(): string;
-    setData(value: Uint8Array | string): StreamingOpenReq;
+    setData(value: Uint8Array | string): StreamingOpenRequest;
 
 
-    getContentCase(): StreamingOpenReq.ContentCase;
+    hasRecvAcknowledge(): boolean;
+    clearRecvAcknowledge(): void;
+    getRecvAcknowledge(): number;
+    setRecvAcknowledge(value: number): StreamingOpenRequest;
+
+
+    getContentCase(): StreamingOpenRequest.ContentCase;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): StreamingOpenReq.AsObject;
-    static toObject(includeInstance: boolean, msg: StreamingOpenReq): StreamingOpenReq.AsObject;
+    toObject(includeInstance?: boolean): StreamingOpenRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: StreamingOpenRequest): StreamingOpenRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: StreamingOpenReq, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): StreamingOpenReq;
-    static deserializeBinaryFromReader(message: StreamingOpenReq, reader: jspb.BinaryReader): StreamingOpenReq;
+    static serializeBinaryToWriter(message: StreamingOpenRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): StreamingOpenRequest;
+    static deserializeBinaryFromReader(message: StreamingOpenRequest, reader: jspb.BinaryReader): StreamingOpenRequest;
 }
 
-export namespace StreamingOpenReq {
+export namespace StreamingOpenRequest {
     export type AsObject = {
-        monitorconfig?: MonitorConfig.AsObject,
+        config?: MonitorConfig.AsObject,
         data: Uint8Array | string,
+        recvAcknowledge: number,
     }
 
     export enum ContentCase {
         CONTENT_NOT_SET = 0,
     
-    MONITORCONFIG = 1,
+    CONFIG = 1,
 
     DATA = 2,
 
+    RECV_ACKNOWLEDGE = 3,
+
     }
 
 }
@@ -60,10 +69,13 @@ export class MonitorConfig extends jspb.Message {
     setType(value: MonitorConfig.TargetType): MonitorConfig;
 
 
-    hasAdditionalconfig(): boolean;
-    clearAdditionalconfig(): void;
-    getAdditionalconfig(): google_protobuf_struct_pb.Struct | undefined;
-    setAdditionalconfig(value?: google_protobuf_struct_pb.Struct): MonitorConfig;
+    hasAdditionalConfig(): boolean;
+    clearAdditionalConfig(): void;
+    getAdditionalConfig(): google_protobuf_struct_pb.Struct | undefined;
+    setAdditionalConfig(value?: google_protobuf_struct_pb.Struct): MonitorConfig;
+
+    getRecvRateLimitBuffer(): number;
+    setRecvRateLimitBuffer(value: number): MonitorConfig;
 
 
     serializeBinary(): Uint8Array;
@@ -80,34 +92,40 @@ export namespace MonitorConfig {
     export type AsObject = {
         target: string,
         type: MonitorConfig.TargetType,
-        additionalconfig?: google_protobuf_struct_pb.Struct.AsObject,
+        additionalConfig?: google_protobuf_struct_pb.Struct.AsObject,
+        recvRateLimitBuffer: number,
     }
 
     export enum TargetType {
-    SERIAL = 0,
+    TARGET_TYPE_SERIAL = 0,
+    TARGET_TYPE_NULL = 99,
     }
 
 }
 
-export class StreamingOpenResp extends jspb.Message { 
+export class StreamingOpenResponse extends jspb.Message { 
     getData(): Uint8Array | string;
     getData_asU8(): Uint8Array;
     getData_asB64(): string;
-    setData(value: Uint8Array | string): StreamingOpenResp;
+    setData(value: Uint8Array | string): StreamingOpenResponse;
+
+    getDropped(): number;
+    setDropped(value: number): StreamingOpenResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): StreamingOpenResp.AsObject;
-    static toObject(includeInstance: boolean, msg: StreamingOpenResp): StreamingOpenResp.AsObject;
+    toObject(includeInstance?: boolean): StreamingOpenResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: StreamingOpenResponse): StreamingOpenResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: StreamingOpenResp, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): StreamingOpenResp;
-    static deserializeBinaryFromReader(message: StreamingOpenResp, reader: jspb.BinaryReader): StreamingOpenResp;
+    static serializeBinaryToWriter(message: StreamingOpenResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): StreamingOpenResponse;
+    static deserializeBinaryFromReader(message: StreamingOpenResponse, reader: jspb.BinaryReader): StreamingOpenResponse;
 }
 
-export namespace StreamingOpenResp {
+export namespace StreamingOpenResponse {
     export type AsObject = {
         data: Uint8Array | string,
+        dropped: number,
     }
 }

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/monitor/v1/monitor_pb.js

@@ -1,7 +1,8 @@
-// source: monitor/monitor.proto
+// source: cc/arduino/cli/monitor/v1/monitor.proto
 /**
  * @fileoverview
  * @enhanceable
+ * @suppress {missingRequire} reports error on implicit type usages.
  * @suppress {messageConventions} JS Compiler reports an error if a variable or
  *     field starts with 'MSG_' and isn't a translatable message.
  * @public
@@ -16,11 +17,11 @@ var global = Function('return this')();
 
 var google_protobuf_struct_pb = require('google-protobuf/google/protobuf/struct_pb.js');
 goog.object.extend(proto, google_protobuf_struct_pb);
-goog.exportSymbol('proto.cc.arduino.cli.monitor.MonitorConfig', null, global);
-goog.exportSymbol('proto.cc.arduino.cli.monitor.MonitorConfig.TargetType', null, global);
-goog.exportSymbol('proto.cc.arduino.cli.monitor.StreamingOpenReq', null, global);
-goog.exportSymbol('proto.cc.arduino.cli.monitor.StreamingOpenReq.ContentCase', null, global);
-goog.exportSymbol('proto.cc.arduino.cli.monitor.StreamingOpenResp', null, global);
+goog.exportSymbol('proto.cc.arduino.cli.monitor.v1.MonitorConfig', null, global);
+goog.exportSymbol('proto.cc.arduino.cli.monitor.v1.MonitorConfig.TargetType', null, global);
+goog.exportSymbol('proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest', null, global);
+goog.exportSymbol('proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.ContentCase', null, global);
+goog.exportSymbol('proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse', null, global);
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
@@ -31,16 +32,16 @@ goog.exportSymbol('proto.cc.arduino.cli.monitor.StreamingOpenResp', null, global
  * @extends {jspb.Message}
  * @constructor
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq = function(opt_data) {
-  jspb.Message.initialize(this, opt_data, 0, -1, null, proto.cc.arduino.cli.monitor.StreamingOpenReq.oneofGroups_);
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest = function(opt_data) {
+  jspb.Message.initialize(this, opt_data, 0, -1, null, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_);
 };
-goog.inherits(proto.cc.arduino.cli.monitor.StreamingOpenReq, jspb.Message);
+goog.inherits(proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
-  proto.cc.arduino.cli.monitor.StreamingOpenReq.displayName = 'proto.cc.arduino.cli.monitor.StreamingOpenReq';
+  proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.displayName = 'proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest';
 }
 /**
  * Generated by JsPbCodeGenerator.
@@ -52,16 +53,16 @@ if (goog.DEBUG && !COMPILED) {
  * @extends {jspb.Message}
  * @constructor
  */
-proto.cc.arduino.cli.monitor.MonitorConfig = function(opt_data) {
+proto.cc.arduino.cli.monitor.v1.MonitorConfig = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
-goog.inherits(proto.cc.arduino.cli.monitor.MonitorConfig, jspb.Message);
+goog.inherits(proto.cc.arduino.cli.monitor.v1.MonitorConfig, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
-  proto.cc.arduino.cli.monitor.MonitorConfig.displayName = 'proto.cc.arduino.cli.monitor.MonitorConfig';
+  proto.cc.arduino.cli.monitor.v1.MonitorConfig.displayName = 'proto.cc.arduino.cli.monitor.v1.MonitorConfig';
 }
 /**
  * Generated by JsPbCodeGenerator.
@@ -73,16 +74,16 @@ if (goog.DEBUG && !COMPILED) {
  * @extends {jspb.Message}
  * @constructor
  */
-proto.cc.arduino.cli.monitor.StreamingOpenResp = function(opt_data) {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse = function(opt_data) {
   jspb.Message.initialize(this, opt_data, 0, -1, null, null);
 };
-goog.inherits(proto.cc.arduino.cli.monitor.StreamingOpenResp, jspb.Message);
+goog.inherits(proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse, jspb.Message);
 if (goog.DEBUG && !COMPILED) {
   /**
    * @public
    * @override
    */
-  proto.cc.arduino.cli.monitor.StreamingOpenResp.displayName = 'proto.cc.arduino.cli.monitor.StreamingOpenResp';
+  proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.displayName = 'proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse';
 }
 
 /**
@@ -93,22 +94,23 @@ if (goog.DEBUG && !COMPILED) {
  * @private {!Array<!Array<number>>}
  * @const
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.oneofGroups_ = [[1,2]];
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_ = [[1,2,3]];
 
 /**
  * @enum {number}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.ContentCase = {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.ContentCase = {
   CONTENT_NOT_SET: 0,
-  MONITORCONFIG: 1,
-  DATA: 2
+  CONFIG: 1,
+  DATA: 2,
+  RECV_ACKNOWLEDGE: 3
 };
 
 /**
- * @return {proto.cc.arduino.cli.monitor.StreamingOpenReq.ContentCase}
+ * @return {proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.ContentCase}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.getContentCase = function() {
-  return /** @type {proto.cc.arduino.cli.monitor.StreamingOpenReq.ContentCase} */(jspb.Message.computeOneofCase(this, proto.cc.arduino.cli.monitor.StreamingOpenReq.oneofGroups_[0]));
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.getContentCase = function() {
+  return /** @type {proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.ContentCase} */(jspb.Message.computeOneofCase(this, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_[0]));
 };
 
 
@@ -126,8 +128,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) {
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.toObject = function(opt_includeInstance) {
-  return proto.cc.arduino.cli.monitor.StreamingOpenReq.toObject(opt_includeInstance, this);
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.toObject = function(opt_includeInstance) {
+  return proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.toObject(opt_includeInstance, this);
 };
 
 
@@ -136,14 +138,15 @@ proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.toObject = function(opt_
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
- * @param {!proto.cc.arduino.cli.monitor.StreamingOpenReq} msg The msg instance to transform.
+ * @param {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.toObject = function(includeInstance, msg) {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
-    monitorconfig: (f = msg.getMonitorconfig()) && proto.cc.arduino.cli.monitor.MonitorConfig.toObject(includeInstance, f),
-    data: msg.getData_asB64()
+    config: (f = msg.getConfig()) && proto.cc.arduino.cli.monitor.v1.MonitorConfig.toObject(includeInstance, f),
+    data: msg.getData_asB64(),
+    recvAcknowledge: jspb.Message.getFieldWithDefault(msg, 3, 0)
   };
 
   if (includeInstance) {
@@ -157,23 +160,23 @@ proto.cc.arduino.cli.monitor.StreamingOpenReq.toObject = function(includeInstanc
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
- * @return {!proto.cc.arduino.cli.monitor.StreamingOpenReq}
+ * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.deserializeBinary = function(bytes) {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
-  var msg = new proto.cc.arduino.cli.monitor.StreamingOpenReq;
-  return proto.cc.arduino.cli.monitor.StreamingOpenReq.deserializeBinaryFromReader(msg, reader);
+  var msg = new proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest;
+  return proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
- * @param {!proto.cc.arduino.cli.monitor.StreamingOpenReq} msg The message object to deserialize into.
+ * @param {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
- * @return {!proto.cc.arduino.cli.monitor.StreamingOpenReq}
+ * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.deserializeBinaryFromReader = function(msg, reader) {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
@@ -181,14 +184,18 @@ proto.cc.arduino.cli.monitor.StreamingOpenReq.deserializeBinaryFromReader = func
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
-      var value = new proto.cc.arduino.cli.monitor.MonitorConfig;
-      reader.readMessage(value,proto.cc.arduino.cli.monitor.MonitorConfig.deserializeBinaryFromReader);
-      msg.setMonitorconfig(value);
+      var value = new proto.cc.arduino.cli.monitor.v1.MonitorConfig;
+      reader.readMessage(value,proto.cc.arduino.cli.monitor.v1.MonitorConfig.deserializeBinaryFromReader);
+      msg.setConfig(value);
       break;
     case 2:
       var value = /** @type {!Uint8Array} */ (reader.readBytes());
       msg.setData(value);
       break;
+    case 3:
+      var value = /** @type {number} */ (reader.readInt32());
+      msg.setRecvAcknowledge(value);
+      break;
     default:
       reader.skipField();
       break;
@@ -202,9 +209,9 @@ proto.cc.arduino.cli.monitor.StreamingOpenReq.deserializeBinaryFromReader = func
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.serializeBinary = function() {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
-  proto.cc.arduino.cli.monitor.StreamingOpenReq.serializeBinaryToWriter(this, writer);
+  proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
@@ -212,18 +219,18 @@ proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.serializeBinary = functi
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
- * @param {!proto.cc.arduino.cli.monitor.StreamingOpenReq} message
+ * @param {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.serializeBinaryToWriter = function(message, writer) {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
-  f = message.getMonitorconfig();
+  f = message.getConfig();
   if (f != null) {
     writer.writeMessage(
       1,
       f,
-      proto.cc.arduino.cli.monitor.MonitorConfig.serializeBinaryToWriter
+      proto.cc.arduino.cli.monitor.v1.MonitorConfig.serializeBinaryToWriter
     );
   }
   f = /** @type {!(string|Uint8Array)} */ (jspb.Message.getField(message, 2));
@@ -233,34 +240,41 @@ proto.cc.arduino.cli.monitor.StreamingOpenReq.serializeBinaryToWriter = function
       f
     );
   }
+  f = /** @type {number} */ (jspb.Message.getField(message, 3));
+  if (f != null) {
+    writer.writeInt32(
+      3,
+      f
+    );
+  }
 };
 
 
 /**
- * optional MonitorConfig monitorConfig = 1;
- * @return {?proto.cc.arduino.cli.monitor.MonitorConfig}
+ * optional MonitorConfig config = 1;
+ * @return {?proto.cc.arduino.cli.monitor.v1.MonitorConfig}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.getMonitorconfig = function() {
-  return /** @type{?proto.cc.arduino.cli.monitor.MonitorConfig} */ (
-    jspb.Message.getWrapperField(this, proto.cc.arduino.cli.monitor.MonitorConfig, 1));
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.getConfig = function() {
+  return /** @type{?proto.cc.arduino.cli.monitor.v1.MonitorConfig} */ (
+    jspb.Message.getWrapperField(this, proto.cc.arduino.cli.monitor.v1.MonitorConfig, 1));
 };
 
 
 /**
- * @param {?proto.cc.arduino.cli.monitor.MonitorConfig|undefined} value
- * @return {!proto.cc.arduino.cli.monitor.StreamingOpenReq} returns this
+ * @param {?proto.cc.arduino.cli.monitor.v1.MonitorConfig|undefined} value
+ * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} returns this
 */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.setMonitorconfig = function(value) {
-  return jspb.Message.setOneofWrapperField(this, 1, proto.cc.arduino.cli.monitor.StreamingOpenReq.oneofGroups_[0], value);
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.setConfig = function(value) {
+  return jspb.Message.setOneofWrapperField(this, 1, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_[0], value);
 };
 
 
 /**
  * Clears the message field making it undefined.
- * @return {!proto.cc.arduino.cli.monitor.StreamingOpenReq} returns this
+ * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} returns this
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.clearMonitorconfig = function() {
-  return this.setMonitorconfig(undefined);
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.clearConfig = function() {
+  return this.setConfig(undefined);
 };
 
 
@@ -268,7 +282,7 @@ proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.clearMonitorconfig = fun
  * Returns whether this field is set.
  * @return {boolean}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.hasMonitorconfig = function() {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.hasConfig = function() {
   return jspb.Message.getField(this, 1) != null;
 };
 
@@ -277,7 +291,7 @@ proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.hasMonitorconfig = funct
  * optional bytes data = 2;
  * @return {!(string|Uint8Array)}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.getData = function() {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.getData = function() {
   return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
@@ -287,7 +301,7 @@ proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.getData = function() {
  * This is a type-conversion wrapper around `getData()`
  * @return {string}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.getData_asB64 = function() {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.getData_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getData()));
 };
@@ -300,7 +314,7 @@ proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.getData_asB64 = function
  * This is a type-conversion wrapper around `getData()`
  * @return {!Uint8Array}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.getData_asU8 = function() {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.getData_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getData()));
 };
@@ -308,19 +322,19 @@ proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.getData_asU8 = function(
 
 /**
  * @param {!(string|Uint8Array)} value
- * @return {!proto.cc.arduino.cli.monitor.StreamingOpenReq} returns this
+ * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} returns this
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.setData = function(value) {
-  return jspb.Message.setOneofField(this, 2, proto.cc.arduino.cli.monitor.StreamingOpenReq.oneofGroups_[0], value);
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.setData = function(value) {
+  return jspb.Message.setOneofField(this, 2, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_[0], value);
 };
 
 
 /**
  * Clears the field making it undefined.
- * @return {!proto.cc.arduino.cli.monitor.StreamingOpenReq} returns this
+ * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} returns this
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.clearData = function() {
-  return jspb.Message.setOneofField(this, 2, proto.cc.arduino.cli.monitor.StreamingOpenReq.oneofGroups_[0], undefined);
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.clearData = function() {
+  return jspb.Message.setOneofField(this, 2, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_[0], undefined);
 };
 
 
@@ -328,217 +342,35 @@ proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.clearData = function() {
  * Returns whether this field is set.
  * @return {boolean}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenReq.prototype.hasData = function() {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.hasData = function() {
   return jspb.Message.getField(this, 2) != null;
 };
 
 
-
-
-
-if (jspb.Message.GENERATE_TO_OBJECT) {
 /**
- * Creates an object representation of this proto.
- * Field names that are reserved in JavaScript and will be renamed to pb_name.
- * Optional fields that are not set will be set to undefined.
- * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
- * For the list of reserved names please see:
- *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
- * @param {boolean=} opt_includeInstance Deprecated. whether to include the
- *     JSPB instance for transitional soy proto support:
- *     http://goto/soy-param-migration
- * @return {!Object}
+ * optional int32 recv_acknowledge = 3;
+ * @return {number}
  */
-proto.cc.arduino.cli.monitor.MonitorConfig.prototype.toObject = function(opt_includeInstance) {
-  return proto.cc.arduino.cli.monitor.MonitorConfig.toObject(opt_includeInstance, this);
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.getRecvAcknowledge = function() {
+  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));
 };
 
 
 /**
- * Static version of the {@see toObject} method.
- * @param {boolean|undefined} includeInstance Deprecated. Whether to include
- *     the JSPB instance for transitional soy proto support:
- *     http://goto/soy-param-migration
- * @param {!proto.cc.arduino.cli.monitor.MonitorConfig} msg The msg instance to transform.
- * @return {!Object}
- * @suppress {unusedLocalVariables} f is only used for nested messages
+ * @param {number} value
+ * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} returns this
  */
-proto.cc.arduino.cli.monitor.MonitorConfig.toObject = function(includeInstance, msg) {
-  var f, obj = {
-    target: jspb.Message.getFieldWithDefault(msg, 1, ""),
-    type: jspb.Message.getFieldWithDefault(msg, 2, 0),
-    additionalconfig: (f = msg.getAdditionalconfig()) && google_protobuf_struct_pb.Struct.toObject(includeInstance, f)
-  };
-
-  if (includeInstance) {
-    obj.$jspbMessageInstance = msg;
-  }
-  return obj;
-};
-}
-
-
-/**
- * Deserializes binary data (in protobuf wire format).
- * @param {jspb.ByteSource} bytes The bytes to deserialize.
- * @return {!proto.cc.arduino.cli.monitor.MonitorConfig}
- */
-proto.cc.arduino.cli.monitor.MonitorConfig.deserializeBinary = function(bytes) {
-  var reader = new jspb.BinaryReader(bytes);
-  var msg = new proto.cc.arduino.cli.monitor.MonitorConfig;
-  return proto.cc.arduino.cli.monitor.MonitorConfig.deserializeBinaryFromReader(msg, reader);
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.setRecvAcknowledge = function(value) {
+  return jspb.Message.setOneofField(this, 3, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_[0], value);
 };
 
 
 /**
- * Deserializes binary data (in protobuf wire format) from the
- * given reader into the given message object.
- * @param {!proto.cc.arduino.cli.monitor.MonitorConfig} msg The message object to deserialize into.
- * @param {!jspb.BinaryReader} reader The BinaryReader to use.
- * @return {!proto.cc.arduino.cli.monitor.MonitorConfig}
+ * Clears the field making it undefined.
+ * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} returns this
  */
-proto.cc.arduino.cli.monitor.MonitorConfig.deserializeBinaryFromReader = function(msg, reader) {
-  while (reader.nextField()) {
-    if (reader.isEndGroup()) {
-      break;
-    }
-    var field = reader.getFieldNumber();
-    switch (field) {
-    case 1:
-      var value = /** @type {string} */ (reader.readString());
-      msg.setTarget(value);
-      break;
-    case 2:
-      var value = /** @type {!proto.cc.arduino.cli.monitor.MonitorConfig.TargetType} */ (reader.readEnum());
-      msg.setType(value);
-      break;
-    case 3:
-      var value = new google_protobuf_struct_pb.Struct;
-      reader.readMessage(value,google_protobuf_struct_pb.Struct.deserializeBinaryFromReader);
-      msg.setAdditionalconfig(value);
-      break;
-    default:
-      reader.skipField();
-      break;
-    }
-  }
-  return msg;
-};
-
-
-/**
- * Serializes the message to binary data (in protobuf wire format).
- * @return {!Uint8Array}
- */
-proto.cc.arduino.cli.monitor.MonitorConfig.prototype.serializeBinary = function() {
-  var writer = new jspb.BinaryWriter();
-  proto.cc.arduino.cli.monitor.MonitorConfig.serializeBinaryToWriter(this, writer);
-  return writer.getResultBuffer();
-};
-
-
-/**
- * Serializes the given message to binary data (in protobuf wire
- * format), writing to the given BinaryWriter.
- * @param {!proto.cc.arduino.cli.monitor.MonitorConfig} message
- * @param {!jspb.BinaryWriter} writer
- * @suppress {unusedLocalVariables} f is only used for nested messages
- */
-proto.cc.arduino.cli.monitor.MonitorConfig.serializeBinaryToWriter = function(message, writer) {
-  var f = undefined;
-  f = message.getTarget();
-  if (f.length > 0) {
-    writer.writeString(
-      1,
-      f
-    );
-  }
-  f = message.getType();
-  if (f !== 0.0) {
-    writer.writeEnum(
-      2,
-      f
-    );
-  }
-  f = message.getAdditionalconfig();
-  if (f != null) {
-    writer.writeMessage(
-      3,
-      f,
-      google_protobuf_struct_pb.Struct.serializeBinaryToWriter
-    );
-  }
-};
-
-
-/**
- * @enum {number}
- */
-proto.cc.arduino.cli.monitor.MonitorConfig.TargetType = {
-  SERIAL: 0
-};
-
-/**
- * optional string target = 1;
- * @return {string}
- */
-proto.cc.arduino.cli.monitor.MonitorConfig.prototype.getTarget = function() {
-  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
-};
-
-
-/**
- * @param {string} value
- * @return {!proto.cc.arduino.cli.monitor.MonitorConfig} returns this
- */
-proto.cc.arduino.cli.monitor.MonitorConfig.prototype.setTarget = function(value) {
-  return jspb.Message.setProto3StringField(this, 1, value);
-};
-
-
-/**
- * optional TargetType type = 2;
- * @return {!proto.cc.arduino.cli.monitor.MonitorConfig.TargetType}
- */
-proto.cc.arduino.cli.monitor.MonitorConfig.prototype.getType = function() {
-  return /** @type {!proto.cc.arduino.cli.monitor.MonitorConfig.TargetType} */ (jspb.Message.getFieldWithDefault(this, 2, 0));
-};
-
-
-/**
- * @param {!proto.cc.arduino.cli.monitor.MonitorConfig.TargetType} value
- * @return {!proto.cc.arduino.cli.monitor.MonitorConfig} returns this
- */
-proto.cc.arduino.cli.monitor.MonitorConfig.prototype.setType = function(value) {
-  return jspb.Message.setProto3EnumField(this, 2, value);
-};
-
-
-/**
- * optional google.protobuf.Struct additionalConfig = 3;
- * @return {?proto.google.protobuf.Struct}
- */
-proto.cc.arduino.cli.monitor.MonitorConfig.prototype.getAdditionalconfig = function() {
-  return /** @type{?proto.google.protobuf.Struct} */ (
-    jspb.Message.getWrapperField(this, google_protobuf_struct_pb.Struct, 3));
-};
-
-
-/**
- * @param {?proto.google.protobuf.Struct|undefined} value
- * @return {!proto.cc.arduino.cli.monitor.MonitorConfig} returns this
-*/
-proto.cc.arduino.cli.monitor.MonitorConfig.prototype.setAdditionalconfig = function(value) {
-  return jspb.Message.setWrapperField(this, 3, value);
-};
-
-
-/**
- * Clears the message field making it undefined.
- * @return {!proto.cc.arduino.cli.monitor.MonitorConfig} returns this
- */
-proto.cc.arduino.cli.monitor.MonitorConfig.prototype.clearAdditionalconfig = function() {
-  return this.setAdditionalconfig(undefined);
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.clearRecvAcknowledge = function() {
+  return jspb.Message.setOneofField(this, 3, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_[0], undefined);
 };
 
 
@@ -546,7 +378,7 @@ proto.cc.arduino.cli.monitor.MonitorConfig.prototype.clearAdditionalconfig = fun
  * Returns whether this field is set.
  * @return {boolean}
  */
-proto.cc.arduino.cli.monitor.MonitorConfig.prototype.hasAdditionalconfig = function() {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.hasRecvAcknowledge = function() {
   return jspb.Message.getField(this, 3) != null;
 };
 
@@ -567,8 +399,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) {
  *     http://goto/soy-param-migration
  * @return {!Object}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenResp.prototype.toObject = function(opt_includeInstance) {
-  return proto.cc.arduino.cli.monitor.StreamingOpenResp.toObject(opt_includeInstance, this);
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.toObject = function(opt_includeInstance) {
+  return proto.cc.arduino.cli.monitor.v1.MonitorConfig.toObject(opt_includeInstance, this);
 };
 
 
@@ -577,13 +409,16 @@ proto.cc.arduino.cli.monitor.StreamingOpenResp.prototype.toObject = function(opt
  * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  *     the JSPB instance for transitional soy proto support:
  *     http://goto/soy-param-migration
- * @param {!proto.cc.arduino.cli.monitor.StreamingOpenResp} msg The msg instance to transform.
+ * @param {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} msg The msg instance to transform.
  * @return {!Object}
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
-proto.cc.arduino.cli.monitor.StreamingOpenResp.toObject = function(includeInstance, msg) {
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.toObject = function(includeInstance, msg) {
   var f, obj = {
-    data: msg.getData_asB64()
+    target: jspb.Message.getFieldWithDefault(msg, 1, ""),
+    type: jspb.Message.getFieldWithDefault(msg, 2, 0),
+    additionalConfig: (f = msg.getAdditionalConfig()) && google_protobuf_struct_pb.Struct.toObject(includeInstance, f),
+    recvRateLimitBuffer: jspb.Message.getFieldWithDefault(msg, 4, 0)
   };
 
   if (includeInstance) {
@@ -597,23 +432,23 @@ proto.cc.arduino.cli.monitor.StreamingOpenResp.toObject = function(includeInstan
 /**
  * Deserializes binary data (in protobuf wire format).
  * @param {jspb.ByteSource} bytes The bytes to deserialize.
- * @return {!proto.cc.arduino.cli.monitor.StreamingOpenResp}
+ * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenResp.deserializeBinary = function(bytes) {
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.deserializeBinary = function(bytes) {
   var reader = new jspb.BinaryReader(bytes);
-  var msg = new proto.cc.arduino.cli.monitor.StreamingOpenResp;
-  return proto.cc.arduino.cli.monitor.StreamingOpenResp.deserializeBinaryFromReader(msg, reader);
+  var msg = new proto.cc.arduino.cli.monitor.v1.MonitorConfig;
+  return proto.cc.arduino.cli.monitor.v1.MonitorConfig.deserializeBinaryFromReader(msg, reader);
 };
 
 
 /**
  * Deserializes binary data (in protobuf wire format) from the
  * given reader into the given message object.
- * @param {!proto.cc.arduino.cli.monitor.StreamingOpenResp} msg The message object to deserialize into.
+ * @param {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} msg The message object to deserialize into.
  * @param {!jspb.BinaryReader} reader The BinaryReader to use.
- * @return {!proto.cc.arduino.cli.monitor.StreamingOpenResp}
+ * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenResp.deserializeBinaryFromReader = function(msg, reader) {
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.deserializeBinaryFromReader = function(msg, reader) {
   while (reader.nextField()) {
     if (reader.isEndGroup()) {
       break;
@@ -621,8 +456,21 @@ proto.cc.arduino.cli.monitor.StreamingOpenResp.deserializeBinaryFromReader = fun
     var field = reader.getFieldNumber();
     switch (field) {
     case 1:
-      var value = /** @type {!Uint8Array} */ (reader.readBytes());
-      msg.setData(value);
+      var value = /** @type {string} */ (reader.readString());
+      msg.setTarget(value);
+      break;
+    case 2:
+      var value = /** @type {!proto.cc.arduino.cli.monitor.v1.MonitorConfig.TargetType} */ (reader.readEnum());
+      msg.setType(value);
+      break;
+    case 3:
+      var value = new google_protobuf_struct_pb.Struct;
+      reader.readMessage(value,google_protobuf_struct_pb.Struct.deserializeBinaryFromReader);
+      msg.setAdditionalConfig(value);
+      break;
+    case 4:
+      var value = /** @type {number} */ (reader.readInt32());
+      msg.setRecvRateLimitBuffer(value);
       break;
     default:
       reader.skipField();
@@ -637,9 +485,9 @@ proto.cc.arduino.cli.monitor.StreamingOpenResp.deserializeBinaryFromReader = fun
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenResp.prototype.serializeBinary = function() {
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
-  proto.cc.arduino.cli.monitor.StreamingOpenResp.serializeBinaryToWriter(this, writer);
+  proto.cc.arduino.cli.monitor.v1.MonitorConfig.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
@@ -647,11 +495,249 @@ proto.cc.arduino.cli.monitor.StreamingOpenResp.prototype.serializeBinary = funct
 /**
  * Serializes the given message to binary data (in protobuf wire
  * format), writing to the given BinaryWriter.
- * @param {!proto.cc.arduino.cli.monitor.StreamingOpenResp} message
+ * @param {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} message
  * @param {!jspb.BinaryWriter} writer
  * @suppress {unusedLocalVariables} f is only used for nested messages
  */
-proto.cc.arduino.cli.monitor.StreamingOpenResp.serializeBinaryToWriter = function(message, writer) {
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.serializeBinaryToWriter = function(message, writer) {
+  var f = undefined;
+  f = message.getTarget();
+  if (f.length > 0) {
+    writer.writeString(
+      1,
+      f
+    );
+  }
+  f = message.getType();
+  if (f !== 0.0) {
+    writer.writeEnum(
+      2,
+      f
+    );
+  }
+  f = message.getAdditionalConfig();
+  if (f != null) {
+    writer.writeMessage(
+      3,
+      f,
+      google_protobuf_struct_pb.Struct.serializeBinaryToWriter
+    );
+  }
+  f = message.getRecvRateLimitBuffer();
+  if (f !== 0) {
+    writer.writeInt32(
+      4,
+      f
+    );
+  }
+};
+
+
+/**
+ * @enum {number}
+ */
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.TargetType = {
+  TARGET_TYPE_SERIAL: 0,
+  TARGET_TYPE_NULL: 99
+};
+
+/**
+ * optional string target = 1;
+ * @return {string}
+ */
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.getTarget = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} returns this
+ */
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.setTarget = function(value) {
+  return jspb.Message.setProto3StringField(this, 1, value);
+};
+
+
+/**
+ * optional TargetType type = 2;
+ * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig.TargetType}
+ */
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.getType = function() {
+  return /** @type {!proto.cc.arduino.cli.monitor.v1.MonitorConfig.TargetType} */ (jspb.Message.getFieldWithDefault(this, 2, 0));
+};
+
+
+/**
+ * @param {!proto.cc.arduino.cli.monitor.v1.MonitorConfig.TargetType} value
+ * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} returns this
+ */
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.setType = function(value) {
+  return jspb.Message.setProto3EnumField(this, 2, value);
+};
+
+
+/**
+ * optional google.protobuf.Struct additional_config = 3;
+ * @return {?proto.google.protobuf.Struct}
+ */
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.getAdditionalConfig = function() {
+  return /** @type{?proto.google.protobuf.Struct} */ (
+    jspb.Message.getWrapperField(this, google_protobuf_struct_pb.Struct, 3));
+};
+
+
+/**
+ * @param {?proto.google.protobuf.Struct|undefined} value
+ * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} returns this
+*/
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.setAdditionalConfig = function(value) {
+  return jspb.Message.setWrapperField(this, 3, value);
+};
+
+
+/**
+ * Clears the message field making it undefined.
+ * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} returns this
+ */
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.clearAdditionalConfig = function() {
+  return this.setAdditionalConfig(undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.hasAdditionalConfig = function() {
+  return jspb.Message.getField(this, 3) != null;
+};
+
+
+/**
+ * optional int32 recv_rate_limit_buffer = 4;
+ * @return {number}
+ */
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.getRecvRateLimitBuffer = function() {
+  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0));
+};
+
+
+/**
+ * @param {number} value
+ * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} returns this
+ */
+proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.setRecvRateLimitBuffer = function(value) {
+  return jspb.Message.setProto3IntField(this, 4, value);
+};
+
+
+
+
+
+if (jspb.Message.GENERATE_TO_OBJECT) {
+/**
+ * Creates an object representation of this proto.
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
+ * Optional fields that are not set will be set to undefined.
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
+ * For the list of reserved names please see:
+ *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
+ *     JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @return {!Object}
+ */
+proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.toObject = function(opt_includeInstance) {
+  return proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.toObject(opt_includeInstance, this);
+};
+
+
+/**
+ * Static version of the {@see toObject} method.
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
+ *     the JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @param {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse} msg The msg instance to transform.
+ * @return {!Object}
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.toObject = function(includeInstance, msg) {
+  var f, obj = {
+    data: msg.getData_asB64(),
+    dropped: jspb.Message.getFieldWithDefault(msg, 2, 0)
+  };
+
+  if (includeInstance) {
+    obj.$jspbMessageInstance = msg;
+  }
+  return obj;
+};
+}
+
+
+/**
+ * Deserializes binary data (in protobuf wire format).
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
+ * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse}
+ */
+proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.deserializeBinary = function(bytes) {
+  var reader = new jspb.BinaryReader(bytes);
+  var msg = new proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse;
+  return proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.deserializeBinaryFromReader(msg, reader);
+};
+
+
+/**
+ * Deserializes binary data (in protobuf wire format) from the
+ * given reader into the given message object.
+ * @param {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse} msg The message object to deserialize into.
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
+ * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse}
+ */
+proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.deserializeBinaryFromReader = function(msg, reader) {
+  while (reader.nextField()) {
+    if (reader.isEndGroup()) {
+      break;
+    }
+    var field = reader.getFieldNumber();
+    switch (field) {
+    case 1:
+      var value = /** @type {!Uint8Array} */ (reader.readBytes());
+      msg.setData(value);
+      break;
+    case 2:
+      var value = /** @type {number} */ (reader.readInt32());
+      msg.setDropped(value);
+      break;
+    default:
+      reader.skipField();
+      break;
+    }
+  }
+  return msg;
+};
+
+
+/**
+ * Serializes the message to binary data (in protobuf wire format).
+ * @return {!Uint8Array}
+ */
+proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.serializeBinary = function() {
+  var writer = new jspb.BinaryWriter();
+  proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.serializeBinaryToWriter(this, writer);
+  return writer.getResultBuffer();
+};
+
+
+/**
+ * Serializes the given message to binary data (in protobuf wire
+ * format), writing to the given BinaryWriter.
+ * @param {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse} message
+ * @param {!jspb.BinaryWriter} writer
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
   f = message.getData_asU8();
   if (f.length > 0) {
@@ -660,6 +746,13 @@ proto.cc.arduino.cli.monitor.StreamingOpenResp.serializeBinaryToWriter = functio
       f
     );
   }
+  f = message.getDropped();
+  if (f !== 0) {
+    writer.writeInt32(
+      2,
+      f
+    );
+  }
 };
 
 
@@ -667,7 +760,7 @@ proto.cc.arduino.cli.monitor.StreamingOpenResp.serializeBinaryToWriter = functio
  * optional bytes data = 1;
  * @return {!(string|Uint8Array)}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenResp.prototype.getData = function() {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.getData = function() {
   return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
@@ -677,7 +770,7 @@ proto.cc.arduino.cli.monitor.StreamingOpenResp.prototype.getData = function() {
  * This is a type-conversion wrapper around `getData()`
  * @return {string}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenResp.prototype.getData_asB64 = function() {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.getData_asB64 = function() {
   return /** @type {string} */ (jspb.Message.bytesAsB64(
       this.getData()));
 };
@@ -690,7 +783,7 @@ proto.cc.arduino.cli.monitor.StreamingOpenResp.prototype.getData_asB64 = functio
  * This is a type-conversion wrapper around `getData()`
  * @return {!Uint8Array}
  */
-proto.cc.arduino.cli.monitor.StreamingOpenResp.prototype.getData_asU8 = function() {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.getData_asU8 = function() {
   return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
       this.getData()));
 };
@@ -698,11 +791,29 @@ proto.cc.arduino.cli.monitor.StreamingOpenResp.prototype.getData_asU8 = function
 
 /**
  * @param {!(string|Uint8Array)} value
- * @return {!proto.cc.arduino.cli.monitor.StreamingOpenResp} returns this
+ * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse} returns this
  */
-proto.cc.arduino.cli.monitor.StreamingOpenResp.prototype.setData = function(value) {
+proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.setData = function(value) {
   return jspb.Message.setProto3BytesField(this, 1, value);
 };
 
 
-goog.object.extend(exports, proto.cc.arduino.cli.monitor);
+/**
+ * optional int32 dropped = 2;
+ * @return {number}
+ */
+proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.getDropped = function() {
+  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0));
+};
+
+
+/**
+ * @param {number} value
+ * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse} returns this
+ */
+proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.setDropped = function(value) {
+  return jspb.Message.setProto3IntField(this, 2, value);
+};
+
+
+goog.object.extend(exports, proto.cc.arduino.cli.monitor.v1);

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/settings/v1/settings_grpc_pb.d.ts

@@ -0,0 +1,110 @@
+// package: cc.arduino.cli.settings.v1
+// file: cc/arduino/cli/settings/v1/settings.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as grpc from "@grpc/grpc-js";
+import {handleClientStreamingCall} from "@grpc/grpc-js/build/src/server-call";
+import * as cc_arduino_cli_settings_v1_settings_pb from "../../../../../cc/arduino/cli/settings/v1/settings_pb";
+
+interface ISettingsServiceService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+    getAll: ISettingsServiceService_IGetAll;
+    merge: ISettingsServiceService_IMerge;
+    getValue: ISettingsServiceService_IGetValue;
+    setValue: ISettingsServiceService_ISetValue;
+    write: ISettingsServiceService_IWrite;
+}
+
+interface ISettingsServiceService_IGetAll extends grpc.MethodDefinition<cc_arduino_cli_settings_v1_settings_pb.GetAllRequest, cc_arduino_cli_settings_v1_settings_pb.GetAllResponse> {
+    path: "/cc.arduino.cli.settings.v1.SettingsService/GetAll";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_settings_v1_settings_pb.GetAllRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_settings_v1_settings_pb.GetAllRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_settings_v1_settings_pb.GetAllResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_settings_v1_settings_pb.GetAllResponse>;
+}
+interface ISettingsServiceService_IMerge extends grpc.MethodDefinition<cc_arduino_cli_settings_v1_settings_pb.MergeRequest, cc_arduino_cli_settings_v1_settings_pb.MergeResponse> {
+    path: "/cc.arduino.cli.settings.v1.SettingsService/Merge";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_settings_v1_settings_pb.MergeRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_settings_v1_settings_pb.MergeRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_settings_v1_settings_pb.MergeResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_settings_v1_settings_pb.MergeResponse>;
+}
+interface ISettingsServiceService_IGetValue extends grpc.MethodDefinition<cc_arduino_cli_settings_v1_settings_pb.GetValueRequest, cc_arduino_cli_settings_v1_settings_pb.GetValueResponse> {
+    path: "/cc.arduino.cli.settings.v1.SettingsService/GetValue";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_settings_v1_settings_pb.GetValueRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_settings_v1_settings_pb.GetValueRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_settings_v1_settings_pb.GetValueResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_settings_v1_settings_pb.GetValueResponse>;
+}
+interface ISettingsServiceService_ISetValue extends grpc.MethodDefinition<cc_arduino_cli_settings_v1_settings_pb.SetValueRequest, cc_arduino_cli_settings_v1_settings_pb.SetValueResponse> {
+    path: "/cc.arduino.cli.settings.v1.SettingsService/SetValue";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_settings_v1_settings_pb.SetValueRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_settings_v1_settings_pb.SetValueRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_settings_v1_settings_pb.SetValueResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_settings_v1_settings_pb.SetValueResponse>;
+}
+interface ISettingsServiceService_IWrite extends grpc.MethodDefinition<cc_arduino_cli_settings_v1_settings_pb.WriteRequest, cc_arduino_cli_settings_v1_settings_pb.WriteResponse> {
+    path: "/cc.arduino.cli.settings.v1.SettingsService/Write";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_settings_v1_settings_pb.WriteRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_settings_v1_settings_pb.WriteRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_settings_v1_settings_pb.WriteResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_settings_v1_settings_pb.WriteResponse>;
+}
+
+export const SettingsServiceService: ISettingsServiceService;
+
+export interface ISettingsServiceServer {
+    getAll: grpc.handleUnaryCall<cc_arduino_cli_settings_v1_settings_pb.GetAllRequest, cc_arduino_cli_settings_v1_settings_pb.GetAllResponse>;
+    merge: grpc.handleUnaryCall<cc_arduino_cli_settings_v1_settings_pb.MergeRequest, cc_arduino_cli_settings_v1_settings_pb.MergeResponse>;
+    getValue: grpc.handleUnaryCall<cc_arduino_cli_settings_v1_settings_pb.GetValueRequest, cc_arduino_cli_settings_v1_settings_pb.GetValueResponse>;
+    setValue: grpc.handleUnaryCall<cc_arduino_cli_settings_v1_settings_pb.SetValueRequest, cc_arduino_cli_settings_v1_settings_pb.SetValueResponse>;
+    write: grpc.handleUnaryCall<cc_arduino_cli_settings_v1_settings_pb.WriteRequest, cc_arduino_cli_settings_v1_settings_pb.WriteResponse>;
+}
+
+export interface ISettingsServiceClient {
+    getAll(request: cc_arduino_cli_settings_v1_settings_pb.GetAllRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.GetAllResponse) => void): grpc.ClientUnaryCall;
+    getAll(request: cc_arduino_cli_settings_v1_settings_pb.GetAllRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.GetAllResponse) => void): grpc.ClientUnaryCall;
+    getAll(request: cc_arduino_cli_settings_v1_settings_pb.GetAllRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.GetAllResponse) => void): grpc.ClientUnaryCall;
+    merge(request: cc_arduino_cli_settings_v1_settings_pb.MergeRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.MergeResponse) => void): grpc.ClientUnaryCall;
+    merge(request: cc_arduino_cli_settings_v1_settings_pb.MergeRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.MergeResponse) => void): grpc.ClientUnaryCall;
+    merge(request: cc_arduino_cli_settings_v1_settings_pb.MergeRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.MergeResponse) => void): grpc.ClientUnaryCall;
+    getValue(request: cc_arduino_cli_settings_v1_settings_pb.GetValueRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.GetValueResponse) => void): grpc.ClientUnaryCall;
+    getValue(request: cc_arduino_cli_settings_v1_settings_pb.GetValueRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.GetValueResponse) => void): grpc.ClientUnaryCall;
+    getValue(request: cc_arduino_cli_settings_v1_settings_pb.GetValueRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.GetValueResponse) => void): grpc.ClientUnaryCall;
+    setValue(request: cc_arduino_cli_settings_v1_settings_pb.SetValueRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.SetValueResponse) => void): grpc.ClientUnaryCall;
+    setValue(request: cc_arduino_cli_settings_v1_settings_pb.SetValueRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.SetValueResponse) => void): grpc.ClientUnaryCall;
+    setValue(request: cc_arduino_cli_settings_v1_settings_pb.SetValueRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.SetValueResponse) => void): grpc.ClientUnaryCall;
+    write(request: cc_arduino_cli_settings_v1_settings_pb.WriteRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.WriteResponse) => void): grpc.ClientUnaryCall;
+    write(request: cc_arduino_cli_settings_v1_settings_pb.WriteRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.WriteResponse) => void): grpc.ClientUnaryCall;
+    write(request: cc_arduino_cli_settings_v1_settings_pb.WriteRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.WriteResponse) => void): grpc.ClientUnaryCall;
+}
+
+export class SettingsServiceClient extends grpc.Client implements ISettingsServiceClient {
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: Partial<grpc.ClientOptions>);
+    public getAll(request: cc_arduino_cli_settings_v1_settings_pb.GetAllRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.GetAllResponse) => void): grpc.ClientUnaryCall;
+    public getAll(request: cc_arduino_cli_settings_v1_settings_pb.GetAllRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.GetAllResponse) => void): grpc.ClientUnaryCall;
+    public getAll(request: cc_arduino_cli_settings_v1_settings_pb.GetAllRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.GetAllResponse) => void): grpc.ClientUnaryCall;
+    public merge(request: cc_arduino_cli_settings_v1_settings_pb.MergeRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.MergeResponse) => void): grpc.ClientUnaryCall;
+    public merge(request: cc_arduino_cli_settings_v1_settings_pb.MergeRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.MergeResponse) => void): grpc.ClientUnaryCall;
+    public merge(request: cc_arduino_cli_settings_v1_settings_pb.MergeRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.MergeResponse) => void): grpc.ClientUnaryCall;
+    public getValue(request: cc_arduino_cli_settings_v1_settings_pb.GetValueRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.GetValueResponse) => void): grpc.ClientUnaryCall;
+    public getValue(request: cc_arduino_cli_settings_v1_settings_pb.GetValueRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.GetValueResponse) => void): grpc.ClientUnaryCall;
+    public getValue(request: cc_arduino_cli_settings_v1_settings_pb.GetValueRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.GetValueResponse) => void): grpc.ClientUnaryCall;
+    public setValue(request: cc_arduino_cli_settings_v1_settings_pb.SetValueRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.SetValueResponse) => void): grpc.ClientUnaryCall;
+    public setValue(request: cc_arduino_cli_settings_v1_settings_pb.SetValueRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.SetValueResponse) => void): grpc.ClientUnaryCall;
+    public setValue(request: cc_arduino_cli_settings_v1_settings_pb.SetValueRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.SetValueResponse) => void): grpc.ClientUnaryCall;
+    public write(request: cc_arduino_cli_settings_v1_settings_pb.WriteRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.WriteResponse) => void): grpc.ClientUnaryCall;
+    public write(request: cc_arduino_cli_settings_v1_settings_pb.WriteRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.WriteResponse) => void): grpc.ClientUnaryCall;
+    public write(request: cc_arduino_cli_settings_v1_settings_pb.WriteRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_settings_v1_settings_pb.WriteResponse) => void): grpc.ClientUnaryCall;
+}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/settings/v1/settings_grpc_pb.js

@@ -0,0 +1,197 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+// Original file comments:
+// This file is part of arduino-cli.
+//
+// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)
+//
+// This software is released under the GNU General Public License version 3,
+// which covers the main part of arduino-cli.
+// The terms of this license can be found at:
+// https://www.gnu.org/licenses/gpl-3.0.en.html
+//
+// You can be released from the requirements of the above licenses by purchasing
+// a commercial license. Buying such a license is mandatory if you want to
+// modify or otherwise use the software for commercial activities involving the
+// Arduino software without disclosing the source code of your own applications.
+// To purchase a commercial license, send an email to license@arduino.cc.
+//
+'use strict';
+var cc_arduino_cli_settings_v1_settings_pb = require('../../../../../cc/arduino/cli/settings/v1/settings_pb.js');
+
+function serialize_cc_arduino_cli_settings_v1_GetAllRequest(arg) {
+  if (!(arg instanceof cc_arduino_cli_settings_v1_settings_pb.GetAllRequest)) {
+    throw new Error('Expected argument of type cc.arduino.cli.settings.v1.GetAllRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_settings_v1_GetAllRequest(buffer_arg) {
+  return cc_arduino_cli_settings_v1_settings_pb.GetAllRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_settings_v1_GetAllResponse(arg) {
+  if (!(arg instanceof cc_arduino_cli_settings_v1_settings_pb.GetAllResponse)) {
+    throw new Error('Expected argument of type cc.arduino.cli.settings.v1.GetAllResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_settings_v1_GetAllResponse(buffer_arg) {
+  return cc_arduino_cli_settings_v1_settings_pb.GetAllResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_settings_v1_GetValueRequest(arg) {
+  if (!(arg instanceof cc_arduino_cli_settings_v1_settings_pb.GetValueRequest)) {
+    throw new Error('Expected argument of type cc.arduino.cli.settings.v1.GetValueRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_settings_v1_GetValueRequest(buffer_arg) {
+  return cc_arduino_cli_settings_v1_settings_pb.GetValueRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_settings_v1_GetValueResponse(arg) {
+  if (!(arg instanceof cc_arduino_cli_settings_v1_settings_pb.GetValueResponse)) {
+    throw new Error('Expected argument of type cc.arduino.cli.settings.v1.GetValueResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_settings_v1_GetValueResponse(buffer_arg) {
+  return cc_arduino_cli_settings_v1_settings_pb.GetValueResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_settings_v1_MergeRequest(arg) {
+  if (!(arg instanceof cc_arduino_cli_settings_v1_settings_pb.MergeRequest)) {
+    throw new Error('Expected argument of type cc.arduino.cli.settings.v1.MergeRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_settings_v1_MergeRequest(buffer_arg) {
+  return cc_arduino_cli_settings_v1_settings_pb.MergeRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_settings_v1_MergeResponse(arg) {
+  if (!(arg instanceof cc_arduino_cli_settings_v1_settings_pb.MergeResponse)) {
+    throw new Error('Expected argument of type cc.arduino.cli.settings.v1.MergeResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_settings_v1_MergeResponse(buffer_arg) {
+  return cc_arduino_cli_settings_v1_settings_pb.MergeResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_settings_v1_SetValueRequest(arg) {
+  if (!(arg instanceof cc_arduino_cli_settings_v1_settings_pb.SetValueRequest)) {
+    throw new Error('Expected argument of type cc.arduino.cli.settings.v1.SetValueRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_settings_v1_SetValueRequest(buffer_arg) {
+  return cc_arduino_cli_settings_v1_settings_pb.SetValueRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_settings_v1_SetValueResponse(arg) {
+  if (!(arg instanceof cc_arduino_cli_settings_v1_settings_pb.SetValueResponse)) {
+    throw new Error('Expected argument of type cc.arduino.cli.settings.v1.SetValueResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_settings_v1_SetValueResponse(buffer_arg) {
+  return cc_arduino_cli_settings_v1_settings_pb.SetValueResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_settings_v1_WriteRequest(arg) {
+  if (!(arg instanceof cc_arduino_cli_settings_v1_settings_pb.WriteRequest)) {
+    throw new Error('Expected argument of type cc.arduino.cli.settings.v1.WriteRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_settings_v1_WriteRequest(buffer_arg) {
+  return cc_arduino_cli_settings_v1_settings_pb.WriteRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_settings_v1_WriteResponse(arg) {
+  if (!(arg instanceof cc_arduino_cli_settings_v1_settings_pb.WriteResponse)) {
+    throw new Error('Expected argument of type cc.arduino.cli.settings.v1.WriteResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_settings_v1_WriteResponse(buffer_arg) {
+  return cc_arduino_cli_settings_v1_settings_pb.WriteResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+
+// The SettingsService provides an interface to Arduino CLI configuration
+// options
+var SettingsServiceService = exports['cc.arduino.cli.settings.v1.SettingsService'] = {
+  // List all the settings.
+getAll: {
+    path: '/cc.arduino.cli.settings.v1.SettingsService/GetAll',
+    requestStream: false,
+    responseStream: false,
+    requestType: cc_arduino_cli_settings_v1_settings_pb.GetAllRequest,
+    responseType: cc_arduino_cli_settings_v1_settings_pb.GetAllResponse,
+    requestSerialize: serialize_cc_arduino_cli_settings_v1_GetAllRequest,
+    requestDeserialize: deserialize_cc_arduino_cli_settings_v1_GetAllRequest,
+    responseSerialize: serialize_cc_arduino_cli_settings_v1_GetAllResponse,
+    responseDeserialize: deserialize_cc_arduino_cli_settings_v1_GetAllResponse,
+  },
+  // Set multiple settings values at once.
+merge: {
+    path: '/cc.arduino.cli.settings.v1.SettingsService/Merge',
+    requestStream: false,
+    responseStream: false,
+    requestType: cc_arduino_cli_settings_v1_settings_pb.MergeRequest,
+    responseType: cc_arduino_cli_settings_v1_settings_pb.MergeResponse,
+    requestSerialize: serialize_cc_arduino_cli_settings_v1_MergeRequest,
+    requestDeserialize: deserialize_cc_arduino_cli_settings_v1_MergeRequest,
+    responseSerialize: serialize_cc_arduino_cli_settings_v1_MergeResponse,
+    responseDeserialize: deserialize_cc_arduino_cli_settings_v1_MergeResponse,
+  },
+  // Get the value of a specific setting.
+getValue: {
+    path: '/cc.arduino.cli.settings.v1.SettingsService/GetValue',
+    requestStream: false,
+    responseStream: false,
+    requestType: cc_arduino_cli_settings_v1_settings_pb.GetValueRequest,
+    responseType: cc_arduino_cli_settings_v1_settings_pb.GetValueResponse,
+    requestSerialize: serialize_cc_arduino_cli_settings_v1_GetValueRequest,
+    requestDeserialize: deserialize_cc_arduino_cli_settings_v1_GetValueRequest,
+    responseSerialize: serialize_cc_arduino_cli_settings_v1_GetValueResponse,
+    responseDeserialize: deserialize_cc_arduino_cli_settings_v1_GetValueResponse,
+  },
+  // Set the value of a specific setting.
+setValue: {
+    path: '/cc.arduino.cli.settings.v1.SettingsService/SetValue',
+    requestStream: false,
+    responseStream: false,
+    requestType: cc_arduino_cli_settings_v1_settings_pb.SetValueRequest,
+    responseType: cc_arduino_cli_settings_v1_settings_pb.SetValueResponse,
+    requestSerialize: serialize_cc_arduino_cli_settings_v1_SetValueRequest,
+    requestDeserialize: deserialize_cc_arduino_cli_settings_v1_SetValueRequest,
+    responseSerialize: serialize_cc_arduino_cli_settings_v1_SetValueResponse,
+    responseDeserialize: deserialize_cc_arduino_cli_settings_v1_SetValueResponse,
+  },
+  // Writes to file settings currently stored in memory
+write: {
+    path: '/cc.arduino.cli.settings.v1.SettingsService/Write',
+    requestStream: false,
+    responseStream: false,
+    requestType: cc_arduino_cli_settings_v1_settings_pb.WriteRequest,
+    responseType: cc_arduino_cli_settings_v1_settings_pb.WriteResponse,
+    requestSerialize: serialize_cc_arduino_cli_settings_v1_WriteRequest,
+    requestDeserialize: deserialize_cc_arduino_cli_settings_v1_WriteRequest,
+    responseSerialize: serialize_cc_arduino_cli_settings_v1_WriteResponse,
+    responseDeserialize: deserialize_cc_arduino_cli_settings_v1_WriteResponse,
+  },
+};
+

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/settings/v1/settings_pb.d.ts

@@ -1,54 +1,100 @@
-// package: cc.arduino.cli.settings
-// file: settings/settings.proto
+// package: cc.arduino.cli.settings.v1
+// file: cc/arduino/cli/settings/v1/settings.proto
 
 /* tslint:disable */
 /* eslint-disable */
 
 import * as jspb from "google-protobuf";
 
-export class RawData extends jspb.Message { 
-    getJsondata(): string;
-    setJsondata(value: string): RawData;
+export class GetAllResponse extends jspb.Message { 
+    getJsonData(): string;
+    setJsonData(value: string): GetAllResponse;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): RawData.AsObject;
-    static toObject(includeInstance: boolean, msg: RawData): RawData.AsObject;
+    toObject(includeInstance?: boolean): GetAllResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: GetAllResponse): GetAllResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: RawData, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): RawData;
-    static deserializeBinaryFromReader(message: RawData, reader: jspb.BinaryReader): RawData;
+    static serializeBinaryToWriter(message: GetAllResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetAllResponse;
+    static deserializeBinaryFromReader(message: GetAllResponse, reader: jspb.BinaryReader): GetAllResponse;
 }
 
-export namespace RawData {
+export namespace GetAllResponse {
     export type AsObject = {
-        jsondata: string,
+        jsonData: string,
     }
 }
 
-export class Value extends jspb.Message { 
-    getKey(): string;
-    setKey(value: string): Value;
-
-    getJsondata(): string;
-    setJsondata(value: string): Value;
+export class MergeRequest extends jspb.Message { 
+    getJsonData(): string;
+    setJsonData(value: string): MergeRequest;
 
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): Value.AsObject;
-    static toObject(includeInstance: boolean, msg: Value): Value.AsObject;
+    toObject(includeInstance?: boolean): MergeRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: MergeRequest): MergeRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: Value, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): Value;
-    static deserializeBinaryFromReader(message: Value, reader: jspb.BinaryReader): Value;
+    static serializeBinaryToWriter(message: MergeRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): MergeRequest;
+    static deserializeBinaryFromReader(message: MergeRequest, reader: jspb.BinaryReader): MergeRequest;
 }
 
-export namespace Value {
+export namespace MergeRequest {
+    export type AsObject = {
+        jsonData: string,
+    }
+}
+
+export class GetValueResponse extends jspb.Message { 
+    getKey(): string;
+    setKey(value: string): GetValueResponse;
+
+    getJsonData(): string;
+    setJsonData(value: string): GetValueResponse;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetValueResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: GetValueResponse): GetValueResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetValueResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetValueResponse;
+    static deserializeBinaryFromReader(message: GetValueResponse, reader: jspb.BinaryReader): GetValueResponse;
+}
+
+export namespace GetValueResponse {
     export type AsObject = {
         key: string,
-        jsondata: string,
+        jsonData: string,
+    }
+}
+
+export class SetValueRequest extends jspb.Message { 
+    getKey(): string;
+    setKey(value: string): SetValueRequest;
+
+    getJsonData(): string;
+    setJsonData(value: string): SetValueRequest;
+
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SetValueRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: SetValueRequest): SetValueRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: SetValueRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SetValueRequest;
+    static deserializeBinaryFromReader(message: SetValueRequest, reader: jspb.BinaryReader): SetValueRequest;
+}
+
+export namespace SetValueRequest {
+    export type AsObject = {
+        key: string,
+        jsonData: string,
     }
 }
 
@@ -125,8 +171,8 @@ export namespace SetValueResponse {
 }
 
 export class WriteRequest extends jspb.Message { 
-    getFilepath(): string;
-    setFilepath(value: string): WriteRequest;
+    getFilePath(): string;
+    setFilePath(value: string): WriteRequest;
 
 
     serializeBinary(): Uint8Array;
@@ -141,7 +187,7 @@ export class WriteRequest extends jspb.Message {
 
 export namespace WriteRequest {
     export type AsObject = {
-        filepath: string,
+        filePath: string,
     }
 }
 

arduino-ide-extension/src/node/cli-protocol/commands/commands_grpc_pb.d.ts

@@ -1,619 +0,0 @@
-// package: cc.arduino.cli.commands
-// file: commands/commands.proto
-
-/* tslint:disable */
-/* eslint-disable */
-
-import * as grpc from "@grpc/grpc-js";
-import {handleClientStreamingCall} from "@grpc/grpc-js/build/src/server-call";
-import * as commands_commands_pb from "../commands/commands_pb";
-import * as commands_common_pb from "../commands/common_pb";
-import * as commands_board_pb from "../commands/board_pb";
-import * as commands_compile_pb from "../commands/compile_pb";
-import * as commands_core_pb from "../commands/core_pb";
-import * as commands_upload_pb from "../commands/upload_pb";
-import * as commands_lib_pb from "../commands/lib_pb";
-
-interface IArduinoCoreService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
-    init: IArduinoCoreService_IInit;
-    destroy: IArduinoCoreService_IDestroy;
-    rescan: IArduinoCoreService_IRescan;
-    updateIndex: IArduinoCoreService_IUpdateIndex;
-    updateLibrariesIndex: IArduinoCoreService_IUpdateLibrariesIndex;
-    updateCoreLibrariesIndex: IArduinoCoreService_IUpdateCoreLibrariesIndex;
-    outdated: IArduinoCoreService_IOutdated;
-    upgrade: IArduinoCoreService_IUpgrade;
-    version: IArduinoCoreService_IVersion;
-    loadSketch: IArduinoCoreService_ILoadSketch;
-    archiveSketch: IArduinoCoreService_IArchiveSketch;
-    boardDetails: IArduinoCoreService_IBoardDetails;
-    boardAttach: IArduinoCoreService_IBoardAttach;
-    boardList: IArduinoCoreService_IBoardList;
-    boardListAll: IArduinoCoreService_IBoardListAll;
-    boardSearch: IArduinoCoreService_IBoardSearch;
-    boardListWatch: IArduinoCoreService_IBoardListWatch;
-    compile: IArduinoCoreService_ICompile;
-    platformInstall: IArduinoCoreService_IPlatformInstall;
-    platformDownload: IArduinoCoreService_IPlatformDownload;
-    platformUninstall: IArduinoCoreService_IPlatformUninstall;
-    platformUpgrade: IArduinoCoreService_IPlatformUpgrade;
-    upload: IArduinoCoreService_IUpload;
-    uploadUsingProgrammer: IArduinoCoreService_IUploadUsingProgrammer;
-    listProgrammersAvailableForUpload: IArduinoCoreService_IListProgrammersAvailableForUpload;
-    burnBootloader: IArduinoCoreService_IBurnBootloader;
-    platformSearch: IArduinoCoreService_IPlatformSearch;
-    platformList: IArduinoCoreService_IPlatformList;
-    libraryDownload: IArduinoCoreService_ILibraryDownload;
-    libraryInstall: IArduinoCoreService_ILibraryInstall;
-    zipLibraryInstall: IArduinoCoreService_IZipLibraryInstall;
-    gitLibraryInstall: IArduinoCoreService_IGitLibraryInstall;
-    libraryUninstall: IArduinoCoreService_ILibraryUninstall;
-    libraryUpgradeAll: IArduinoCoreService_ILibraryUpgradeAll;
-    libraryResolveDependencies: IArduinoCoreService_ILibraryResolveDependencies;
-    librarySearch: IArduinoCoreService_ILibrarySearch;
-    libraryList: IArduinoCoreService_ILibraryList;
-}
-
-interface IArduinoCoreService_IInit extends grpc.MethodDefinition<commands_commands_pb.InitReq, commands_commands_pb.InitResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/Init";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_commands_pb.InitReq>;
-    requestDeserialize: grpc.deserialize<commands_commands_pb.InitReq>;
-    responseSerialize: grpc.serialize<commands_commands_pb.InitResp>;
-    responseDeserialize: grpc.deserialize<commands_commands_pb.InitResp>;
-}
-interface IArduinoCoreService_IDestroy extends grpc.MethodDefinition<commands_commands_pb.DestroyReq, commands_commands_pb.DestroyResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/Destroy";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_commands_pb.DestroyReq>;
-    requestDeserialize: grpc.deserialize<commands_commands_pb.DestroyReq>;
-    responseSerialize: grpc.serialize<commands_commands_pb.DestroyResp>;
-    responseDeserialize: grpc.deserialize<commands_commands_pb.DestroyResp>;
-}
-interface IArduinoCoreService_IRescan extends grpc.MethodDefinition<commands_commands_pb.RescanReq, commands_commands_pb.RescanResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/Rescan";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_commands_pb.RescanReq>;
-    requestDeserialize: grpc.deserialize<commands_commands_pb.RescanReq>;
-    responseSerialize: grpc.serialize<commands_commands_pb.RescanResp>;
-    responseDeserialize: grpc.deserialize<commands_commands_pb.RescanResp>;
-}
-interface IArduinoCoreService_IUpdateIndex extends grpc.MethodDefinition<commands_commands_pb.UpdateIndexReq, commands_commands_pb.UpdateIndexResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/UpdateIndex";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_commands_pb.UpdateIndexReq>;
-    requestDeserialize: grpc.deserialize<commands_commands_pb.UpdateIndexReq>;
-    responseSerialize: grpc.serialize<commands_commands_pb.UpdateIndexResp>;
-    responseDeserialize: grpc.deserialize<commands_commands_pb.UpdateIndexResp>;
-}
-interface IArduinoCoreService_IUpdateLibrariesIndex extends grpc.MethodDefinition<commands_commands_pb.UpdateLibrariesIndexReq, commands_commands_pb.UpdateLibrariesIndexResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/UpdateLibrariesIndex";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_commands_pb.UpdateLibrariesIndexReq>;
-    requestDeserialize: grpc.deserialize<commands_commands_pb.UpdateLibrariesIndexReq>;
-    responseSerialize: grpc.serialize<commands_commands_pb.UpdateLibrariesIndexResp>;
-    responseDeserialize: grpc.deserialize<commands_commands_pb.UpdateLibrariesIndexResp>;
-}
-interface IArduinoCoreService_IUpdateCoreLibrariesIndex extends grpc.MethodDefinition<commands_commands_pb.UpdateCoreLibrariesIndexReq, commands_commands_pb.UpdateCoreLibrariesIndexResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/UpdateCoreLibrariesIndex";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_commands_pb.UpdateCoreLibrariesIndexReq>;
-    requestDeserialize: grpc.deserialize<commands_commands_pb.UpdateCoreLibrariesIndexReq>;
-    responseSerialize: grpc.serialize<commands_commands_pb.UpdateCoreLibrariesIndexResp>;
-    responseDeserialize: grpc.deserialize<commands_commands_pb.UpdateCoreLibrariesIndexResp>;
-}
-interface IArduinoCoreService_IOutdated extends grpc.MethodDefinition<commands_commands_pb.OutdatedReq, commands_commands_pb.OutdatedResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/Outdated";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_commands_pb.OutdatedReq>;
-    requestDeserialize: grpc.deserialize<commands_commands_pb.OutdatedReq>;
-    responseSerialize: grpc.serialize<commands_commands_pb.OutdatedResp>;
-    responseDeserialize: grpc.deserialize<commands_commands_pb.OutdatedResp>;
-}
-interface IArduinoCoreService_IUpgrade extends grpc.MethodDefinition<commands_commands_pb.UpgradeReq, commands_commands_pb.UpgradeResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/Upgrade";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_commands_pb.UpgradeReq>;
-    requestDeserialize: grpc.deserialize<commands_commands_pb.UpgradeReq>;
-    responseSerialize: grpc.serialize<commands_commands_pb.UpgradeResp>;
-    responseDeserialize: grpc.deserialize<commands_commands_pb.UpgradeResp>;
-}
-interface IArduinoCoreService_IVersion extends grpc.MethodDefinition<commands_commands_pb.VersionReq, commands_commands_pb.VersionResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/Version";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_commands_pb.VersionReq>;
-    requestDeserialize: grpc.deserialize<commands_commands_pb.VersionReq>;
-    responseSerialize: grpc.serialize<commands_commands_pb.VersionResp>;
-    responseDeserialize: grpc.deserialize<commands_commands_pb.VersionResp>;
-}
-interface IArduinoCoreService_ILoadSketch extends grpc.MethodDefinition<commands_commands_pb.LoadSketchReq, commands_commands_pb.LoadSketchResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/LoadSketch";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_commands_pb.LoadSketchReq>;
-    requestDeserialize: grpc.deserialize<commands_commands_pb.LoadSketchReq>;
-    responseSerialize: grpc.serialize<commands_commands_pb.LoadSketchResp>;
-    responseDeserialize: grpc.deserialize<commands_commands_pb.LoadSketchResp>;
-}
-interface IArduinoCoreService_IArchiveSketch extends grpc.MethodDefinition<commands_commands_pb.ArchiveSketchReq, commands_commands_pb.ArchiveSketchResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/ArchiveSketch";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_commands_pb.ArchiveSketchReq>;
-    requestDeserialize: grpc.deserialize<commands_commands_pb.ArchiveSketchReq>;
-    responseSerialize: grpc.serialize<commands_commands_pb.ArchiveSketchResp>;
-    responseDeserialize: grpc.deserialize<commands_commands_pb.ArchiveSketchResp>;
-}
-interface IArduinoCoreService_IBoardDetails extends grpc.MethodDefinition<commands_board_pb.BoardDetailsReq, commands_board_pb.BoardDetailsResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/BoardDetails";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_board_pb.BoardDetailsReq>;
-    requestDeserialize: grpc.deserialize<commands_board_pb.BoardDetailsReq>;
-    responseSerialize: grpc.serialize<commands_board_pb.BoardDetailsResp>;
-    responseDeserialize: grpc.deserialize<commands_board_pb.BoardDetailsResp>;
-}
-interface IArduinoCoreService_IBoardAttach extends grpc.MethodDefinition<commands_board_pb.BoardAttachReq, commands_board_pb.BoardAttachResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/BoardAttach";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_board_pb.BoardAttachReq>;
-    requestDeserialize: grpc.deserialize<commands_board_pb.BoardAttachReq>;
-    responseSerialize: grpc.serialize<commands_board_pb.BoardAttachResp>;
-    responseDeserialize: grpc.deserialize<commands_board_pb.BoardAttachResp>;
-}
-interface IArduinoCoreService_IBoardList extends grpc.MethodDefinition<commands_board_pb.BoardListReq, commands_board_pb.BoardListResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/BoardList";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_board_pb.BoardListReq>;
-    requestDeserialize: grpc.deserialize<commands_board_pb.BoardListReq>;
-    responseSerialize: grpc.serialize<commands_board_pb.BoardListResp>;
-    responseDeserialize: grpc.deserialize<commands_board_pb.BoardListResp>;
-}
-interface IArduinoCoreService_IBoardListAll extends grpc.MethodDefinition<commands_board_pb.BoardListAllReq, commands_board_pb.BoardListAllResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/BoardListAll";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_board_pb.BoardListAllReq>;
-    requestDeserialize: grpc.deserialize<commands_board_pb.BoardListAllReq>;
-    responseSerialize: grpc.serialize<commands_board_pb.BoardListAllResp>;
-    responseDeserialize: grpc.deserialize<commands_board_pb.BoardListAllResp>;
-}
-interface IArduinoCoreService_IBoardSearch extends grpc.MethodDefinition<commands_board_pb.BoardSearchReq, commands_board_pb.BoardSearchResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/BoardSearch";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_board_pb.BoardSearchReq>;
-    requestDeserialize: grpc.deserialize<commands_board_pb.BoardSearchReq>;
-    responseSerialize: grpc.serialize<commands_board_pb.BoardSearchResp>;
-    responseDeserialize: grpc.deserialize<commands_board_pb.BoardSearchResp>;
-}
-interface IArduinoCoreService_IBoardListWatch extends grpc.MethodDefinition<commands_board_pb.BoardListWatchReq, commands_board_pb.BoardListWatchResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/BoardListWatch";
-    requestStream: true;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_board_pb.BoardListWatchReq>;
-    requestDeserialize: grpc.deserialize<commands_board_pb.BoardListWatchReq>;
-    responseSerialize: grpc.serialize<commands_board_pb.BoardListWatchResp>;
-    responseDeserialize: grpc.deserialize<commands_board_pb.BoardListWatchResp>;
-}
-interface IArduinoCoreService_ICompile extends grpc.MethodDefinition<commands_compile_pb.CompileReq, commands_compile_pb.CompileResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/Compile";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_compile_pb.CompileReq>;
-    requestDeserialize: grpc.deserialize<commands_compile_pb.CompileReq>;
-    responseSerialize: grpc.serialize<commands_compile_pb.CompileResp>;
-    responseDeserialize: grpc.deserialize<commands_compile_pb.CompileResp>;
-}
-interface IArduinoCoreService_IPlatformInstall extends grpc.MethodDefinition<commands_core_pb.PlatformInstallReq, commands_core_pb.PlatformInstallResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/PlatformInstall";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_core_pb.PlatformInstallReq>;
-    requestDeserialize: grpc.deserialize<commands_core_pb.PlatformInstallReq>;
-    responseSerialize: grpc.serialize<commands_core_pb.PlatformInstallResp>;
-    responseDeserialize: grpc.deserialize<commands_core_pb.PlatformInstallResp>;
-}
-interface IArduinoCoreService_IPlatformDownload extends grpc.MethodDefinition<commands_core_pb.PlatformDownloadReq, commands_core_pb.PlatformDownloadResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/PlatformDownload";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_core_pb.PlatformDownloadReq>;
-    requestDeserialize: grpc.deserialize<commands_core_pb.PlatformDownloadReq>;
-    responseSerialize: grpc.serialize<commands_core_pb.PlatformDownloadResp>;
-    responseDeserialize: grpc.deserialize<commands_core_pb.PlatformDownloadResp>;
-}
-interface IArduinoCoreService_IPlatformUninstall extends grpc.MethodDefinition<commands_core_pb.PlatformUninstallReq, commands_core_pb.PlatformUninstallResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/PlatformUninstall";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_core_pb.PlatformUninstallReq>;
-    requestDeserialize: grpc.deserialize<commands_core_pb.PlatformUninstallReq>;
-    responseSerialize: grpc.serialize<commands_core_pb.PlatformUninstallResp>;
-    responseDeserialize: grpc.deserialize<commands_core_pb.PlatformUninstallResp>;
-}
-interface IArduinoCoreService_IPlatformUpgrade extends grpc.MethodDefinition<commands_core_pb.PlatformUpgradeReq, commands_core_pb.PlatformUpgradeResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/PlatformUpgrade";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_core_pb.PlatformUpgradeReq>;
-    requestDeserialize: grpc.deserialize<commands_core_pb.PlatformUpgradeReq>;
-    responseSerialize: grpc.serialize<commands_core_pb.PlatformUpgradeResp>;
-    responseDeserialize: grpc.deserialize<commands_core_pb.PlatformUpgradeResp>;
-}
-interface IArduinoCoreService_IUpload extends grpc.MethodDefinition<commands_upload_pb.UploadReq, commands_upload_pb.UploadResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/Upload";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_upload_pb.UploadReq>;
-    requestDeserialize: grpc.deserialize<commands_upload_pb.UploadReq>;
-    responseSerialize: grpc.serialize<commands_upload_pb.UploadResp>;
-    responseDeserialize: grpc.deserialize<commands_upload_pb.UploadResp>;
-}
-interface IArduinoCoreService_IUploadUsingProgrammer extends grpc.MethodDefinition<commands_upload_pb.UploadUsingProgrammerReq, commands_upload_pb.UploadUsingProgrammerResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/UploadUsingProgrammer";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_upload_pb.UploadUsingProgrammerReq>;
-    requestDeserialize: grpc.deserialize<commands_upload_pb.UploadUsingProgrammerReq>;
-    responseSerialize: grpc.serialize<commands_upload_pb.UploadUsingProgrammerResp>;
-    responseDeserialize: grpc.deserialize<commands_upload_pb.UploadUsingProgrammerResp>;
-}
-interface IArduinoCoreService_IListProgrammersAvailableForUpload extends grpc.MethodDefinition<commands_upload_pb.ListProgrammersAvailableForUploadReq, commands_upload_pb.ListProgrammersAvailableForUploadResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/ListProgrammersAvailableForUpload";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_upload_pb.ListProgrammersAvailableForUploadReq>;
-    requestDeserialize: grpc.deserialize<commands_upload_pb.ListProgrammersAvailableForUploadReq>;
-    responseSerialize: grpc.serialize<commands_upload_pb.ListProgrammersAvailableForUploadResp>;
-    responseDeserialize: grpc.deserialize<commands_upload_pb.ListProgrammersAvailableForUploadResp>;
-}
-interface IArduinoCoreService_IBurnBootloader extends grpc.MethodDefinition<commands_upload_pb.BurnBootloaderReq, commands_upload_pb.BurnBootloaderResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/BurnBootloader";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_upload_pb.BurnBootloaderReq>;
-    requestDeserialize: grpc.deserialize<commands_upload_pb.BurnBootloaderReq>;
-    responseSerialize: grpc.serialize<commands_upload_pb.BurnBootloaderResp>;
-    responseDeserialize: grpc.deserialize<commands_upload_pb.BurnBootloaderResp>;
-}
-interface IArduinoCoreService_IPlatformSearch extends grpc.MethodDefinition<commands_core_pb.PlatformSearchReq, commands_core_pb.PlatformSearchResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/PlatformSearch";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_core_pb.PlatformSearchReq>;
-    requestDeserialize: grpc.deserialize<commands_core_pb.PlatformSearchReq>;
-    responseSerialize: grpc.serialize<commands_core_pb.PlatformSearchResp>;
-    responseDeserialize: grpc.deserialize<commands_core_pb.PlatformSearchResp>;
-}
-interface IArduinoCoreService_IPlatformList extends grpc.MethodDefinition<commands_core_pb.PlatformListReq, commands_core_pb.PlatformListResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/PlatformList";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_core_pb.PlatformListReq>;
-    requestDeserialize: grpc.deserialize<commands_core_pb.PlatformListReq>;
-    responseSerialize: grpc.serialize<commands_core_pb.PlatformListResp>;
-    responseDeserialize: grpc.deserialize<commands_core_pb.PlatformListResp>;
-}
-interface IArduinoCoreService_ILibraryDownload extends grpc.MethodDefinition<commands_lib_pb.LibraryDownloadReq, commands_lib_pb.LibraryDownloadResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/LibraryDownload";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_lib_pb.LibraryDownloadReq>;
-    requestDeserialize: grpc.deserialize<commands_lib_pb.LibraryDownloadReq>;
-    responseSerialize: grpc.serialize<commands_lib_pb.LibraryDownloadResp>;
-    responseDeserialize: grpc.deserialize<commands_lib_pb.LibraryDownloadResp>;
-}
-interface IArduinoCoreService_ILibraryInstall extends grpc.MethodDefinition<commands_lib_pb.LibraryInstallReq, commands_lib_pb.LibraryInstallResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/LibraryInstall";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_lib_pb.LibraryInstallReq>;
-    requestDeserialize: grpc.deserialize<commands_lib_pb.LibraryInstallReq>;
-    responseSerialize: grpc.serialize<commands_lib_pb.LibraryInstallResp>;
-    responseDeserialize: grpc.deserialize<commands_lib_pb.LibraryInstallResp>;
-}
-interface IArduinoCoreService_IZipLibraryInstall extends grpc.MethodDefinition<commands_lib_pb.ZipLibraryInstallReq, commands_lib_pb.ZipLibraryInstallResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/ZipLibraryInstall";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_lib_pb.ZipLibraryInstallReq>;
-    requestDeserialize: grpc.deserialize<commands_lib_pb.ZipLibraryInstallReq>;
-    responseSerialize: grpc.serialize<commands_lib_pb.ZipLibraryInstallResp>;
-    responseDeserialize: grpc.deserialize<commands_lib_pb.ZipLibraryInstallResp>;
-}
-interface IArduinoCoreService_IGitLibraryInstall extends grpc.MethodDefinition<commands_lib_pb.GitLibraryInstallReq, commands_lib_pb.GitLibraryInstallResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/GitLibraryInstall";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_lib_pb.GitLibraryInstallReq>;
-    requestDeserialize: grpc.deserialize<commands_lib_pb.GitLibraryInstallReq>;
-    responseSerialize: grpc.serialize<commands_lib_pb.GitLibraryInstallResp>;
-    responseDeserialize: grpc.deserialize<commands_lib_pb.GitLibraryInstallResp>;
-}
-interface IArduinoCoreService_ILibraryUninstall extends grpc.MethodDefinition<commands_lib_pb.LibraryUninstallReq, commands_lib_pb.LibraryUninstallResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/LibraryUninstall";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_lib_pb.LibraryUninstallReq>;
-    requestDeserialize: grpc.deserialize<commands_lib_pb.LibraryUninstallReq>;
-    responseSerialize: grpc.serialize<commands_lib_pb.LibraryUninstallResp>;
-    responseDeserialize: grpc.deserialize<commands_lib_pb.LibraryUninstallResp>;
-}
-interface IArduinoCoreService_ILibraryUpgradeAll extends grpc.MethodDefinition<commands_lib_pb.LibraryUpgradeAllReq, commands_lib_pb.LibraryUpgradeAllResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/LibraryUpgradeAll";
-    requestStream: false;
-    responseStream: true;
-    requestSerialize: grpc.serialize<commands_lib_pb.LibraryUpgradeAllReq>;
-    requestDeserialize: grpc.deserialize<commands_lib_pb.LibraryUpgradeAllReq>;
-    responseSerialize: grpc.serialize<commands_lib_pb.LibraryUpgradeAllResp>;
-    responseDeserialize: grpc.deserialize<commands_lib_pb.LibraryUpgradeAllResp>;
-}
-interface IArduinoCoreService_ILibraryResolveDependencies extends grpc.MethodDefinition<commands_lib_pb.LibraryResolveDependenciesReq, commands_lib_pb.LibraryResolveDependenciesResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/LibraryResolveDependencies";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_lib_pb.LibraryResolveDependenciesReq>;
-    requestDeserialize: grpc.deserialize<commands_lib_pb.LibraryResolveDependenciesReq>;
-    responseSerialize: grpc.serialize<commands_lib_pb.LibraryResolveDependenciesResp>;
-    responseDeserialize: grpc.deserialize<commands_lib_pb.LibraryResolveDependenciesResp>;
-}
-interface IArduinoCoreService_ILibrarySearch extends grpc.MethodDefinition<commands_lib_pb.LibrarySearchReq, commands_lib_pb.LibrarySearchResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/LibrarySearch";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_lib_pb.LibrarySearchReq>;
-    requestDeserialize: grpc.deserialize<commands_lib_pb.LibrarySearchReq>;
-    responseSerialize: grpc.serialize<commands_lib_pb.LibrarySearchResp>;
-    responseDeserialize: grpc.deserialize<commands_lib_pb.LibrarySearchResp>;
-}
-interface IArduinoCoreService_ILibraryList extends grpc.MethodDefinition<commands_lib_pb.LibraryListReq, commands_lib_pb.LibraryListResp> {
-    path: "/cc.arduino.cli.commands.ArduinoCore/LibraryList";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<commands_lib_pb.LibraryListReq>;
-    requestDeserialize: grpc.deserialize<commands_lib_pb.LibraryListReq>;
-    responseSerialize: grpc.serialize<commands_lib_pb.LibraryListResp>;
-    responseDeserialize: grpc.deserialize<commands_lib_pb.LibraryListResp>;
-}
-
-export const ArduinoCoreService: IArduinoCoreService;
-
-export interface IArduinoCoreServer {
-    init: grpc.handleServerStreamingCall<commands_commands_pb.InitReq, commands_commands_pb.InitResp>;
-    destroy: grpc.handleUnaryCall<commands_commands_pb.DestroyReq, commands_commands_pb.DestroyResp>;
-    rescan: grpc.handleUnaryCall<commands_commands_pb.RescanReq, commands_commands_pb.RescanResp>;
-    updateIndex: grpc.handleServerStreamingCall<commands_commands_pb.UpdateIndexReq, commands_commands_pb.UpdateIndexResp>;
-    updateLibrariesIndex: grpc.handleServerStreamingCall<commands_commands_pb.UpdateLibrariesIndexReq, commands_commands_pb.UpdateLibrariesIndexResp>;
-    updateCoreLibrariesIndex: grpc.handleServerStreamingCall<commands_commands_pb.UpdateCoreLibrariesIndexReq, commands_commands_pb.UpdateCoreLibrariesIndexResp>;
-    outdated: grpc.handleUnaryCall<commands_commands_pb.OutdatedReq, commands_commands_pb.OutdatedResp>;
-    upgrade: grpc.handleServerStreamingCall<commands_commands_pb.UpgradeReq, commands_commands_pb.UpgradeResp>;
-    version: grpc.handleUnaryCall<commands_commands_pb.VersionReq, commands_commands_pb.VersionResp>;
-    loadSketch: grpc.handleUnaryCall<commands_commands_pb.LoadSketchReq, commands_commands_pb.LoadSketchResp>;
-    archiveSketch: grpc.handleUnaryCall<commands_commands_pb.ArchiveSketchReq, commands_commands_pb.ArchiveSketchResp>;
-    boardDetails: grpc.handleUnaryCall<commands_board_pb.BoardDetailsReq, commands_board_pb.BoardDetailsResp>;
-    boardAttach: grpc.handleServerStreamingCall<commands_board_pb.BoardAttachReq, commands_board_pb.BoardAttachResp>;
-    boardList: grpc.handleUnaryCall<commands_board_pb.BoardListReq, commands_board_pb.BoardListResp>;
-    boardListAll: grpc.handleUnaryCall<commands_board_pb.BoardListAllReq, commands_board_pb.BoardListAllResp>;
-    boardSearch: grpc.handleUnaryCall<commands_board_pb.BoardSearchReq, commands_board_pb.BoardSearchResp>;
-    boardListWatch: grpc.handleBidiStreamingCall<commands_board_pb.BoardListWatchReq, commands_board_pb.BoardListWatchResp>;
-    compile: grpc.handleServerStreamingCall<commands_compile_pb.CompileReq, commands_compile_pb.CompileResp>;
-    platformInstall: grpc.handleServerStreamingCall<commands_core_pb.PlatformInstallReq, commands_core_pb.PlatformInstallResp>;
-    platformDownload: grpc.handleServerStreamingCall<commands_core_pb.PlatformDownloadReq, commands_core_pb.PlatformDownloadResp>;
-    platformUninstall: grpc.handleServerStreamingCall<commands_core_pb.PlatformUninstallReq, commands_core_pb.PlatformUninstallResp>;
-    platformUpgrade: grpc.handleServerStreamingCall<commands_core_pb.PlatformUpgradeReq, commands_core_pb.PlatformUpgradeResp>;
-    upload: grpc.handleServerStreamingCall<commands_upload_pb.UploadReq, commands_upload_pb.UploadResp>;
-    uploadUsingProgrammer: grpc.handleServerStreamingCall<commands_upload_pb.UploadUsingProgrammerReq, commands_upload_pb.UploadUsingProgrammerResp>;
-    listProgrammersAvailableForUpload: grpc.handleUnaryCall<commands_upload_pb.ListProgrammersAvailableForUploadReq, commands_upload_pb.ListProgrammersAvailableForUploadResp>;
-    burnBootloader: grpc.handleServerStreamingCall<commands_upload_pb.BurnBootloaderReq, commands_upload_pb.BurnBootloaderResp>;
-    platformSearch: grpc.handleUnaryCall<commands_core_pb.PlatformSearchReq, commands_core_pb.PlatformSearchResp>;
-    platformList: grpc.handleUnaryCall<commands_core_pb.PlatformListReq, commands_core_pb.PlatformListResp>;
-    libraryDownload: grpc.handleServerStreamingCall<commands_lib_pb.LibraryDownloadReq, commands_lib_pb.LibraryDownloadResp>;
-    libraryInstall: grpc.handleServerStreamingCall<commands_lib_pb.LibraryInstallReq, commands_lib_pb.LibraryInstallResp>;
-    zipLibraryInstall: grpc.handleServerStreamingCall<commands_lib_pb.ZipLibraryInstallReq, commands_lib_pb.ZipLibraryInstallResp>;
-    gitLibraryInstall: grpc.handleServerStreamingCall<commands_lib_pb.GitLibraryInstallReq, commands_lib_pb.GitLibraryInstallResp>;
-    libraryUninstall: grpc.handleServerStreamingCall<commands_lib_pb.LibraryUninstallReq, commands_lib_pb.LibraryUninstallResp>;
-    libraryUpgradeAll: grpc.handleServerStreamingCall<commands_lib_pb.LibraryUpgradeAllReq, commands_lib_pb.LibraryUpgradeAllResp>;
-    libraryResolveDependencies: grpc.handleUnaryCall<commands_lib_pb.LibraryResolveDependenciesReq, commands_lib_pb.LibraryResolveDependenciesResp>;
-    librarySearch: grpc.handleUnaryCall<commands_lib_pb.LibrarySearchReq, commands_lib_pb.LibrarySearchResp>;
-    libraryList: grpc.handleUnaryCall<commands_lib_pb.LibraryListReq, commands_lib_pb.LibraryListResp>;
-}
-
-export interface IArduinoCoreClient {
-    init(request: commands_commands_pb.InitReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.InitResp>;
-    init(request: commands_commands_pb.InitReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.InitResp>;
-    destroy(request: commands_commands_pb.DestroyReq, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.DestroyResp) => void): grpc.ClientUnaryCall;
-    destroy(request: commands_commands_pb.DestroyReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.DestroyResp) => void): grpc.ClientUnaryCall;
-    destroy(request: commands_commands_pb.DestroyReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.DestroyResp) => void): grpc.ClientUnaryCall;
-    rescan(request: commands_commands_pb.RescanReq, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.RescanResp) => void): grpc.ClientUnaryCall;
-    rescan(request: commands_commands_pb.RescanReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.RescanResp) => void): grpc.ClientUnaryCall;
-    rescan(request: commands_commands_pb.RescanReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.RescanResp) => void): grpc.ClientUnaryCall;
-    updateIndex(request: commands_commands_pb.UpdateIndexReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpdateIndexResp>;
-    updateIndex(request: commands_commands_pb.UpdateIndexReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpdateIndexResp>;
-    updateLibrariesIndex(request: commands_commands_pb.UpdateLibrariesIndexReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpdateLibrariesIndexResp>;
-    updateLibrariesIndex(request: commands_commands_pb.UpdateLibrariesIndexReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpdateLibrariesIndexResp>;
-    updateCoreLibrariesIndex(request: commands_commands_pb.UpdateCoreLibrariesIndexReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpdateCoreLibrariesIndexResp>;
-    updateCoreLibrariesIndex(request: commands_commands_pb.UpdateCoreLibrariesIndexReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpdateCoreLibrariesIndexResp>;
-    outdated(request: commands_commands_pb.OutdatedReq, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.OutdatedResp) => void): grpc.ClientUnaryCall;
-    outdated(request: commands_commands_pb.OutdatedReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.OutdatedResp) => void): grpc.ClientUnaryCall;
-    outdated(request: commands_commands_pb.OutdatedReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.OutdatedResp) => void): grpc.ClientUnaryCall;
-    upgrade(request: commands_commands_pb.UpgradeReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpgradeResp>;
-    upgrade(request: commands_commands_pb.UpgradeReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpgradeResp>;
-    version(request: commands_commands_pb.VersionReq, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.VersionResp) => void): grpc.ClientUnaryCall;
-    version(request: commands_commands_pb.VersionReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.VersionResp) => void): grpc.ClientUnaryCall;
-    version(request: commands_commands_pb.VersionReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.VersionResp) => void): grpc.ClientUnaryCall;
-    loadSketch(request: commands_commands_pb.LoadSketchReq, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.LoadSketchResp) => void): grpc.ClientUnaryCall;
-    loadSketch(request: commands_commands_pb.LoadSketchReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.LoadSketchResp) => void): grpc.ClientUnaryCall;
-    loadSketch(request: commands_commands_pb.LoadSketchReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.LoadSketchResp) => void): grpc.ClientUnaryCall;
-    archiveSketch(request: commands_commands_pb.ArchiveSketchReq, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.ArchiveSketchResp) => void): grpc.ClientUnaryCall;
-    archiveSketch(request: commands_commands_pb.ArchiveSketchReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.ArchiveSketchResp) => void): grpc.ClientUnaryCall;
-    archiveSketch(request: commands_commands_pb.ArchiveSketchReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.ArchiveSketchResp) => void): grpc.ClientUnaryCall;
-    boardDetails(request: commands_board_pb.BoardDetailsReq, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardDetailsResp) => void): grpc.ClientUnaryCall;
-    boardDetails(request: commands_board_pb.BoardDetailsReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardDetailsResp) => void): grpc.ClientUnaryCall;
-    boardDetails(request: commands_board_pb.BoardDetailsReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardDetailsResp) => void): grpc.ClientUnaryCall;
-    boardAttach(request: commands_board_pb.BoardAttachReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_board_pb.BoardAttachResp>;
-    boardAttach(request: commands_board_pb.BoardAttachReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_board_pb.BoardAttachResp>;
-    boardList(request: commands_board_pb.BoardListReq, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardListResp) => void): grpc.ClientUnaryCall;
-    boardList(request: commands_board_pb.BoardListReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardListResp) => void): grpc.ClientUnaryCall;
-    boardList(request: commands_board_pb.BoardListReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardListResp) => void): grpc.ClientUnaryCall;
-    boardListAll(request: commands_board_pb.BoardListAllReq, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardListAllResp) => void): grpc.ClientUnaryCall;
-    boardListAll(request: commands_board_pb.BoardListAllReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardListAllResp) => void): grpc.ClientUnaryCall;
-    boardListAll(request: commands_board_pb.BoardListAllReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardListAllResp) => void): grpc.ClientUnaryCall;
-    boardSearch(request: commands_board_pb.BoardSearchReq, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardSearchResp) => void): grpc.ClientUnaryCall;
-    boardSearch(request: commands_board_pb.BoardSearchReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardSearchResp) => void): grpc.ClientUnaryCall;
-    boardSearch(request: commands_board_pb.BoardSearchReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardSearchResp) => void): grpc.ClientUnaryCall;
-    boardListWatch(): grpc.ClientDuplexStream<commands_board_pb.BoardListWatchReq, commands_board_pb.BoardListWatchResp>;
-    boardListWatch(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<commands_board_pb.BoardListWatchReq, commands_board_pb.BoardListWatchResp>;
-    boardListWatch(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<commands_board_pb.BoardListWatchReq, commands_board_pb.BoardListWatchResp>;
-    compile(request: commands_compile_pb.CompileReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_compile_pb.CompileResp>;
-    compile(request: commands_compile_pb.CompileReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_compile_pb.CompileResp>;
-    platformInstall(request: commands_core_pb.PlatformInstallReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformInstallResp>;
-    platformInstall(request: commands_core_pb.PlatformInstallReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformInstallResp>;
-    platformDownload(request: commands_core_pb.PlatformDownloadReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformDownloadResp>;
-    platformDownload(request: commands_core_pb.PlatformDownloadReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformDownloadResp>;
-    platformUninstall(request: commands_core_pb.PlatformUninstallReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformUninstallResp>;
-    platformUninstall(request: commands_core_pb.PlatformUninstallReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformUninstallResp>;
-    platformUpgrade(request: commands_core_pb.PlatformUpgradeReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformUpgradeResp>;
-    platformUpgrade(request: commands_core_pb.PlatformUpgradeReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformUpgradeResp>;
-    upload(request: commands_upload_pb.UploadReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_upload_pb.UploadResp>;
-    upload(request: commands_upload_pb.UploadReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_upload_pb.UploadResp>;
-    uploadUsingProgrammer(request: commands_upload_pb.UploadUsingProgrammerReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_upload_pb.UploadUsingProgrammerResp>;
-    uploadUsingProgrammer(request: commands_upload_pb.UploadUsingProgrammerReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_upload_pb.UploadUsingProgrammerResp>;
-    listProgrammersAvailableForUpload(request: commands_upload_pb.ListProgrammersAvailableForUploadReq, callback: (error: grpc.ServiceError | null, response: commands_upload_pb.ListProgrammersAvailableForUploadResp) => void): grpc.ClientUnaryCall;
-    listProgrammersAvailableForUpload(request: commands_upload_pb.ListProgrammersAvailableForUploadReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_upload_pb.ListProgrammersAvailableForUploadResp) => void): grpc.ClientUnaryCall;
-    listProgrammersAvailableForUpload(request: commands_upload_pb.ListProgrammersAvailableForUploadReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_upload_pb.ListProgrammersAvailableForUploadResp) => void): grpc.ClientUnaryCall;
-    burnBootloader(request: commands_upload_pb.BurnBootloaderReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_upload_pb.BurnBootloaderResp>;
-    burnBootloader(request: commands_upload_pb.BurnBootloaderReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_upload_pb.BurnBootloaderResp>;
-    platformSearch(request: commands_core_pb.PlatformSearchReq, callback: (error: grpc.ServiceError | null, response: commands_core_pb.PlatformSearchResp) => void): grpc.ClientUnaryCall;
-    platformSearch(request: commands_core_pb.PlatformSearchReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_core_pb.PlatformSearchResp) => void): grpc.ClientUnaryCall;
-    platformSearch(request: commands_core_pb.PlatformSearchReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_core_pb.PlatformSearchResp) => void): grpc.ClientUnaryCall;
-    platformList(request: commands_core_pb.PlatformListReq, callback: (error: grpc.ServiceError | null, response: commands_core_pb.PlatformListResp) => void): grpc.ClientUnaryCall;
-    platformList(request: commands_core_pb.PlatformListReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_core_pb.PlatformListResp) => void): grpc.ClientUnaryCall;
-    platformList(request: commands_core_pb.PlatformListReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_core_pb.PlatformListResp) => void): grpc.ClientUnaryCall;
-    libraryDownload(request: commands_lib_pb.LibraryDownloadReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryDownloadResp>;
-    libraryDownload(request: commands_lib_pb.LibraryDownloadReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryDownloadResp>;
-    libraryInstall(request: commands_lib_pb.LibraryInstallReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryInstallResp>;
-    libraryInstall(request: commands_lib_pb.LibraryInstallReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryInstallResp>;
-    zipLibraryInstall(request: commands_lib_pb.ZipLibraryInstallReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.ZipLibraryInstallResp>;
-    zipLibraryInstall(request: commands_lib_pb.ZipLibraryInstallReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.ZipLibraryInstallResp>;
-    gitLibraryInstall(request: commands_lib_pb.GitLibraryInstallReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.GitLibraryInstallResp>;
-    gitLibraryInstall(request: commands_lib_pb.GitLibraryInstallReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.GitLibraryInstallResp>;
-    libraryUninstall(request: commands_lib_pb.LibraryUninstallReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryUninstallResp>;
-    libraryUninstall(request: commands_lib_pb.LibraryUninstallReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryUninstallResp>;
-    libraryUpgradeAll(request: commands_lib_pb.LibraryUpgradeAllReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryUpgradeAllResp>;
-    libraryUpgradeAll(request: commands_lib_pb.LibraryUpgradeAllReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryUpgradeAllResp>;
-    libraryResolveDependencies(request: commands_lib_pb.LibraryResolveDependenciesReq, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibraryResolveDependenciesResp) => void): grpc.ClientUnaryCall;
-    libraryResolveDependencies(request: commands_lib_pb.LibraryResolveDependenciesReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibraryResolveDependenciesResp) => void): grpc.ClientUnaryCall;
-    libraryResolveDependencies(request: commands_lib_pb.LibraryResolveDependenciesReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibraryResolveDependenciesResp) => void): grpc.ClientUnaryCall;
-    librarySearch(request: commands_lib_pb.LibrarySearchReq, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibrarySearchResp) => void): grpc.ClientUnaryCall;
-    librarySearch(request: commands_lib_pb.LibrarySearchReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibrarySearchResp) => void): grpc.ClientUnaryCall;
-    librarySearch(request: commands_lib_pb.LibrarySearchReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibrarySearchResp) => void): grpc.ClientUnaryCall;
-    libraryList(request: commands_lib_pb.LibraryListReq, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibraryListResp) => void): grpc.ClientUnaryCall;
-    libraryList(request: commands_lib_pb.LibraryListReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibraryListResp) => void): grpc.ClientUnaryCall;
-    libraryList(request: commands_lib_pb.LibraryListReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibraryListResp) => void): grpc.ClientUnaryCall;
-}
-
-export class ArduinoCoreClient extends grpc.Client implements IArduinoCoreClient {
-    constructor(address: string, credentials: grpc.ChannelCredentials, options?: Partial<grpc.ClientOptions>);
-    public init(request: commands_commands_pb.InitReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.InitResp>;
-    public init(request: commands_commands_pb.InitReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.InitResp>;
-    public destroy(request: commands_commands_pb.DestroyReq, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.DestroyResp) => void): grpc.ClientUnaryCall;
-    public destroy(request: commands_commands_pb.DestroyReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.DestroyResp) => void): grpc.ClientUnaryCall;
-    public destroy(request: commands_commands_pb.DestroyReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.DestroyResp) => void): grpc.ClientUnaryCall;
-    public rescan(request: commands_commands_pb.RescanReq, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.RescanResp) => void): grpc.ClientUnaryCall;
-    public rescan(request: commands_commands_pb.RescanReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.RescanResp) => void): grpc.ClientUnaryCall;
-    public rescan(request: commands_commands_pb.RescanReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.RescanResp) => void): grpc.ClientUnaryCall;
-    public updateIndex(request: commands_commands_pb.UpdateIndexReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpdateIndexResp>;
-    public updateIndex(request: commands_commands_pb.UpdateIndexReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpdateIndexResp>;
-    public updateLibrariesIndex(request: commands_commands_pb.UpdateLibrariesIndexReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpdateLibrariesIndexResp>;
-    public updateLibrariesIndex(request: commands_commands_pb.UpdateLibrariesIndexReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpdateLibrariesIndexResp>;
-    public updateCoreLibrariesIndex(request: commands_commands_pb.UpdateCoreLibrariesIndexReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpdateCoreLibrariesIndexResp>;
-    public updateCoreLibrariesIndex(request: commands_commands_pb.UpdateCoreLibrariesIndexReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpdateCoreLibrariesIndexResp>;
-    public outdated(request: commands_commands_pb.OutdatedReq, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.OutdatedResp) => void): grpc.ClientUnaryCall;
-    public outdated(request: commands_commands_pb.OutdatedReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.OutdatedResp) => void): grpc.ClientUnaryCall;
-    public outdated(request: commands_commands_pb.OutdatedReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.OutdatedResp) => void): grpc.ClientUnaryCall;
-    public upgrade(request: commands_commands_pb.UpgradeReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpgradeResp>;
-    public upgrade(request: commands_commands_pb.UpgradeReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_commands_pb.UpgradeResp>;
-    public version(request: commands_commands_pb.VersionReq, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.VersionResp) => void): grpc.ClientUnaryCall;
-    public version(request: commands_commands_pb.VersionReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.VersionResp) => void): grpc.ClientUnaryCall;
-    public version(request: commands_commands_pb.VersionReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.VersionResp) => void): grpc.ClientUnaryCall;
-    public loadSketch(request: commands_commands_pb.LoadSketchReq, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.LoadSketchResp) => void): grpc.ClientUnaryCall;
-    public loadSketch(request: commands_commands_pb.LoadSketchReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.LoadSketchResp) => void): grpc.ClientUnaryCall;
-    public loadSketch(request: commands_commands_pb.LoadSketchReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.LoadSketchResp) => void): grpc.ClientUnaryCall;
-    public archiveSketch(request: commands_commands_pb.ArchiveSketchReq, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.ArchiveSketchResp) => void): grpc.ClientUnaryCall;
-    public archiveSketch(request: commands_commands_pb.ArchiveSketchReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.ArchiveSketchResp) => void): grpc.ClientUnaryCall;
-    public archiveSketch(request: commands_commands_pb.ArchiveSketchReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_commands_pb.ArchiveSketchResp) => void): grpc.ClientUnaryCall;
-    public boardDetails(request: commands_board_pb.BoardDetailsReq, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardDetailsResp) => void): grpc.ClientUnaryCall;
-    public boardDetails(request: commands_board_pb.BoardDetailsReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardDetailsResp) => void): grpc.ClientUnaryCall;
-    public boardDetails(request: commands_board_pb.BoardDetailsReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardDetailsResp) => void): grpc.ClientUnaryCall;
-    public boardAttach(request: commands_board_pb.BoardAttachReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_board_pb.BoardAttachResp>;
-    public boardAttach(request: commands_board_pb.BoardAttachReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_board_pb.BoardAttachResp>;
-    public boardList(request: commands_board_pb.BoardListReq, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardListResp) => void): grpc.ClientUnaryCall;
-    public boardList(request: commands_board_pb.BoardListReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardListResp) => void): grpc.ClientUnaryCall;
-    public boardList(request: commands_board_pb.BoardListReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardListResp) => void): grpc.ClientUnaryCall;
-    public boardListAll(request: commands_board_pb.BoardListAllReq, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardListAllResp) => void): grpc.ClientUnaryCall;
-    public boardListAll(request: commands_board_pb.BoardListAllReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardListAllResp) => void): grpc.ClientUnaryCall;
-    public boardListAll(request: commands_board_pb.BoardListAllReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardListAllResp) => void): grpc.ClientUnaryCall;
-    public boardSearch(request: commands_board_pb.BoardSearchReq, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardSearchResp) => void): grpc.ClientUnaryCall;
-    public boardSearch(request: commands_board_pb.BoardSearchReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardSearchResp) => void): grpc.ClientUnaryCall;
-    public boardSearch(request: commands_board_pb.BoardSearchReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_board_pb.BoardSearchResp) => void): grpc.ClientUnaryCall;
-    public boardListWatch(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<commands_board_pb.BoardListWatchReq, commands_board_pb.BoardListWatchResp>;
-    public boardListWatch(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<commands_board_pb.BoardListWatchReq, commands_board_pb.BoardListWatchResp>;
-    public compile(request: commands_compile_pb.CompileReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_compile_pb.CompileResp>;
-    public compile(request: commands_compile_pb.CompileReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_compile_pb.CompileResp>;
-    public platformInstall(request: commands_core_pb.PlatformInstallReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformInstallResp>;
-    public platformInstall(request: commands_core_pb.PlatformInstallReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformInstallResp>;
-    public platformDownload(request: commands_core_pb.PlatformDownloadReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformDownloadResp>;
-    public platformDownload(request: commands_core_pb.PlatformDownloadReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformDownloadResp>;
-    public platformUninstall(request: commands_core_pb.PlatformUninstallReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformUninstallResp>;
-    public platformUninstall(request: commands_core_pb.PlatformUninstallReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformUninstallResp>;
-    public platformUpgrade(request: commands_core_pb.PlatformUpgradeReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformUpgradeResp>;
-    public platformUpgrade(request: commands_core_pb.PlatformUpgradeReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_core_pb.PlatformUpgradeResp>;
-    public upload(request: commands_upload_pb.UploadReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_upload_pb.UploadResp>;
-    public upload(request: commands_upload_pb.UploadReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_upload_pb.UploadResp>;
-    public uploadUsingProgrammer(request: commands_upload_pb.UploadUsingProgrammerReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_upload_pb.UploadUsingProgrammerResp>;
-    public uploadUsingProgrammer(request: commands_upload_pb.UploadUsingProgrammerReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_upload_pb.UploadUsingProgrammerResp>;
-    public listProgrammersAvailableForUpload(request: commands_upload_pb.ListProgrammersAvailableForUploadReq, callback: (error: grpc.ServiceError | null, response: commands_upload_pb.ListProgrammersAvailableForUploadResp) => void): grpc.ClientUnaryCall;
-    public listProgrammersAvailableForUpload(request: commands_upload_pb.ListProgrammersAvailableForUploadReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_upload_pb.ListProgrammersAvailableForUploadResp) => void): grpc.ClientUnaryCall;
-    public listProgrammersAvailableForUpload(request: commands_upload_pb.ListProgrammersAvailableForUploadReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_upload_pb.ListProgrammersAvailableForUploadResp) => void): grpc.ClientUnaryCall;
-    public burnBootloader(request: commands_upload_pb.BurnBootloaderReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_upload_pb.BurnBootloaderResp>;
-    public burnBootloader(request: commands_upload_pb.BurnBootloaderReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_upload_pb.BurnBootloaderResp>;
-    public platformSearch(request: commands_core_pb.PlatformSearchReq, callback: (error: grpc.ServiceError | null, response: commands_core_pb.PlatformSearchResp) => void): grpc.ClientUnaryCall;
-    public platformSearch(request: commands_core_pb.PlatformSearchReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_core_pb.PlatformSearchResp) => void): grpc.ClientUnaryCall;
-    public platformSearch(request: commands_core_pb.PlatformSearchReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_core_pb.PlatformSearchResp) => void): grpc.ClientUnaryCall;
-    public platformList(request: commands_core_pb.PlatformListReq, callback: (error: grpc.ServiceError | null, response: commands_core_pb.PlatformListResp) => void): grpc.ClientUnaryCall;
-    public platformList(request: commands_core_pb.PlatformListReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_core_pb.PlatformListResp) => void): grpc.ClientUnaryCall;
-    public platformList(request: commands_core_pb.PlatformListReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_core_pb.PlatformListResp) => void): grpc.ClientUnaryCall;
-    public libraryDownload(request: commands_lib_pb.LibraryDownloadReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryDownloadResp>;
-    public libraryDownload(request: commands_lib_pb.LibraryDownloadReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryDownloadResp>;
-    public libraryInstall(request: commands_lib_pb.LibraryInstallReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryInstallResp>;
-    public libraryInstall(request: commands_lib_pb.LibraryInstallReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryInstallResp>;
-    public zipLibraryInstall(request: commands_lib_pb.ZipLibraryInstallReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.ZipLibraryInstallResp>;
-    public zipLibraryInstall(request: commands_lib_pb.ZipLibraryInstallReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.ZipLibraryInstallResp>;
-    public gitLibraryInstall(request: commands_lib_pb.GitLibraryInstallReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.GitLibraryInstallResp>;
-    public gitLibraryInstall(request: commands_lib_pb.GitLibraryInstallReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.GitLibraryInstallResp>;
-    public libraryUninstall(request: commands_lib_pb.LibraryUninstallReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryUninstallResp>;
-    public libraryUninstall(request: commands_lib_pb.LibraryUninstallReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryUninstallResp>;
-    public libraryUpgradeAll(request: commands_lib_pb.LibraryUpgradeAllReq, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryUpgradeAllResp>;
-    public libraryUpgradeAll(request: commands_lib_pb.LibraryUpgradeAllReq, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<commands_lib_pb.LibraryUpgradeAllResp>;
-    public libraryResolveDependencies(request: commands_lib_pb.LibraryResolveDependenciesReq, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibraryResolveDependenciesResp) => void): grpc.ClientUnaryCall;
-    public libraryResolveDependencies(request: commands_lib_pb.LibraryResolveDependenciesReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibraryResolveDependenciesResp) => void): grpc.ClientUnaryCall;
-    public libraryResolveDependencies(request: commands_lib_pb.LibraryResolveDependenciesReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibraryResolveDependenciesResp) => void): grpc.ClientUnaryCall;
-    public librarySearch(request: commands_lib_pb.LibrarySearchReq, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibrarySearchResp) => void): grpc.ClientUnaryCall;
-    public librarySearch(request: commands_lib_pb.LibrarySearchReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibrarySearchResp) => void): grpc.ClientUnaryCall;
-    public librarySearch(request: commands_lib_pb.LibrarySearchReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibrarySearchResp) => void): grpc.ClientUnaryCall;
-    public libraryList(request: commands_lib_pb.LibraryListReq, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibraryListResp) => void): grpc.ClientUnaryCall;
-    public libraryList(request: commands_lib_pb.LibraryListReq, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibraryListResp) => void): grpc.ClientUnaryCall;
-    public libraryList(request: commands_lib_pb.LibraryListReq, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: commands_lib_pb.LibraryListResp) => void): grpc.ClientUnaryCall;
-}