#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Instance {
    /// The ID of the instance.
    #[prost(int32, tag = "1")]
    pub id: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DownloadProgress {
    /// URL of the download.
    #[prost(string, tag = "1")]
    pub url: std::string::String,
    /// The file being downloaded.
    #[prost(string, tag = "2")]
    pub file: std::string::String,
    /// Total size of the file being downloaded.
    #[prost(int64, tag = "3")]
    pub total_size: i64,
    /// Size of the downloaded portion of the file.
    #[prost(int64, tag = "4")]
    pub downloaded: i64,
    /// Whether the download is complete.
    #[prost(bool, tag = "5")]
    pub completed: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TaskProgress {
    /// Description of the task.
    #[prost(string, tag = "1")]
    pub name: std::string::String,
    /// Additional information about the task.
    #[prost(string, tag = "2")]
    pub message: std::string::String,
    /// Whether the task is complete.
    #[prost(bool, tag = "3")]
    pub completed: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Programmer {
    #[prost(string, tag = "1")]
    pub platform: std::string::String,
    #[prost(string, tag = "2")]
    pub id: std::string::String,
    #[prost(string, tag = "3")]
    pub name: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoardDetailsReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// The fully qualified board name of the board you want information about
    /// (e.g., `arduino:avr:uno`).
    #[prost(string, tag = "2")]
    pub fqbn: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoardDetailsResp {
    /// The fully qualified board name of the board.
    #[prost(string, tag = "1")]
    pub fqbn: std::string::String,
    /// Name used to identify the board to humans (e.g., Arduino Uno).
    #[prost(string, tag = "2")]
    pub name: std::string::String,
    /// Installed version of the board's platform.
    #[prost(string, tag = "3")]
    pub version: std::string::String,
    /// The board ID component of the FQBN (e.g., `uno`).
    #[prost(string, tag = "4")]
    pub properties_id: std::string::String,
    /// Board alias that can be used as a more user friendly alternative to the
    /// FQBN.
    #[prost(string, tag = "5")]
    pub alias: std::string::String,
    /// Whether this is an official or 3rd party board.
    #[prost(bool, tag = "6")]
    pub official: bool,
    /// URL of the board's pinout documentation.
    #[prost(string, tag = "7")]
    pub pinout: std::string::String,
    /// Data about the package that contains the board's platform.
    #[prost(message, optional, tag = "8")]
    pub package: ::std::option::Option<Package>,
    /// Data about the board's platform.
    #[prost(message, optional, tag = "9")]
    pub platform: ::std::option::Option<BoardPlatform>,
    /// Tool dependencies of the board.
    #[prost(message, repeated, tag = "10")]
    pub tools_dependencies: ::std::vec::Vec<ToolsDependencies>,
    /// The board's custom configuration options.
    #[prost(message, repeated, tag = "11")]
    pub config_options: ::std::vec::Vec<ConfigOption>,
    /// Identifying information for the board (e.g., USB VID/PID).
    #[prost(message, repeated, tag = "12")]
    pub identification_pref: ::std::vec::Vec<IdentificationPref>,
    /// List of programmers supported by the board
    #[prost(message, repeated, tag = "13")]
    pub programmers: ::std::vec::Vec<Programmer>,
    /// Set to true if the board supports debugging
    #[prost(bool, tag = "14")]
    pub debugging_supported: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IdentificationPref {
    /// Identifying information for USB-connected boards.
    #[prost(message, optional, tag = "1")]
    pub usb_id: ::std::option::Option<Usbid>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Usbid {
    /// USB vendor ID.
    #[prost(string, tag = "1")]
    pub vid: std::string::String,
    /// USB product ID.
    #[prost(string, tag = "2")]
    pub pid: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Package {
    /// Maintainer of the package.
    #[prost(string, tag = "1")]
    pub maintainer: std::string::String,
    /// The URL of the platforms index file
    /// (e.g., https://downloads.arduino.cc/packages/package_index.json).
    #[prost(string, tag = "2")]
    pub url: std::string::String,
    /// A URL provided by the package author, intended to point to their website.
    #[prost(string, tag = "3")]
    pub website_url: std::string::String,
    /// Email address of the package maintainer.
    #[prost(string, tag = "4")]
    pub email: std::string::String,
    /// Package vendor name.
    #[prost(string, tag = "5")]
    pub name: std::string::String,
    /// Resources for getting help about using the package.
    #[prost(message, optional, tag = "6")]
    pub help: ::std::option::Option<Help>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Help {
    /// URL for getting online help.
    #[prost(string, tag = "1")]
    pub online: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoardPlatform {
    /// Architecture of the platform (e.g., `avr`).
    #[prost(string, tag = "1")]
    pub architecture: std::string::String,
    /// Category of the platform. Set to `Contributed` for 3rd party platforms.
    #[prost(string, tag = "2")]
    pub category: std::string::String,
    /// Download URL of the platform archive file.
    #[prost(string, tag = "3")]
    pub url: std::string::String,
    /// File name of the platform archive.
    #[prost(string, tag = "4")]
    pub archive_file_name: std::string::String,
    /// Checksum of the platform archive.
    #[prost(string, tag = "5")]
    pub checksum: std::string::String,
    /// File size of the platform archive.
    #[prost(int64, tag = "6")]
    pub size: i64,
    /// Name used to identify the platform to humans.
    #[prost(string, tag = "7")]
    pub name: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToolsDependencies {
    /// Vendor name of the package containing the tool definition.
    #[prost(string, tag = "1")]
    pub packager: std::string::String,
    /// Tool name.
    #[prost(string, tag = "2")]
    pub name: std::string::String,
    /// Tool version.
    #[prost(string, tag = "3")]
    pub version: std::string::String,
    /// Data for the operating system-specific builds of the tool.
    #[prost(message, repeated, tag = "4")]
    pub systems: ::std::vec::Vec<Systems>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Systems {
    /// Checksum of the tool archive.
    #[prost(string, tag = "1")]
    pub checksum: std::string::String,
    /// Operating system identifier.
    #[prost(string, tag = "2")]
    pub host: std::string::String,
    /// File name of the tool archive.
    #[prost(string, tag = "3")]
    pub archive_file_name: std::string::String,
    /// Download URL of the tool archive.
    #[prost(string, tag = "4")]
    pub url: std::string::String,
    /// File size of the tool archive.
    #[prost(int64, tag = "5")]
    pub size: i64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConfigOption {
    /// ID of the configuration option. For identifying the option to machines.
    #[prost(string, tag = "1")]
    pub option: std::string::String,
    /// Name of the configuration option for identifying the option to humans.
    #[prost(string, tag = "2")]
    pub option_label: std::string::String,
    /// Possible values of the configuration option.
    #[prost(message, repeated, tag = "3")]
    pub values: ::std::vec::Vec<ConfigValue>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConfigValue {
    /// The configuration option value.
    #[prost(string, tag = "1")]
    pub value: std::string::String,
    /// Label to identify the configuration option to humans.
    #[prost(string, tag = "2")]
    pub value_label: std::string::String,
    /// Whether the configuration option is selected.
    #[prost(bool, tag = "3")]
    pub selected: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoardAttachReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// The board's URI (e.g., /dev/ttyACM0).
    #[prost(string, tag = "2")]
    pub board_uri: std::string::String,
    /// Path of the sketch to attach the board to. The board attachment
    /// metadata will be saved to `{sketch_path}/sketch.json`.
    #[prost(string, tag = "3")]
    pub sketch_path: std::string::String,
    /// Duration in seconds to search the given URI for a connected board before
    /// timing out. The default value is 5 seconds.
    #[prost(string, tag = "4")]
    pub search_timeout: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoardAttachResp {
    /// Description of the current stage of the board attachment.
    #[prost(message, optional, tag = "1")]
    pub task_progress: ::std::option::Option<TaskProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoardListReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoardListResp {
    /// List of ports and the boards detected on those ports.
    #[prost(message, repeated, tag = "1")]
    pub ports: ::std::vec::Vec<DetectedPort>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DetectedPort {
    /// Address of the port (e.g., `serial:///dev/ttyACM0`).
    #[prost(string, tag = "1")]
    pub address: std::string::String,
    /// Protocol of the port (e.g., `serial`).
    #[prost(string, tag = "2")]
    pub protocol: std::string::String,
    /// A human friendly description of the protocol (e.g., "Serial Port (USB)").
    #[prost(string, tag = "3")]
    pub protocol_label: std::string::String,
    /// The boards attached to the port.
    #[prost(message, repeated, tag = "4")]
    pub boards: ::std::vec::Vec<BoardListItem>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoardListAllReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// The search query to filter the board list by.
    #[prost(string, repeated, tag = "2")]
    pub search_args: ::std::vec::Vec<std::string::String>,
    /// Set to true to get also the boards marked as "hidden" in the platform
    #[prost(bool, tag = "3")]
    pub include_hidden_boards: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoardListAllResp {
    /// List of installed boards.
    #[prost(message, repeated, tag = "1")]
    pub boards: ::std::vec::Vec<BoardListItem>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoardListWatchReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Set this to true to stop the discovery process
    #[prost(bool, tag = "2")]
    pub interrupt: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoardListWatchResp {
    /// Event type as received from the serial discovery tool
    #[prost(string, tag = "1")]
    pub event_type: std::string::String,
    /// Information about the port
    #[prost(message, optional, tag = "2")]
    pub port: ::std::option::Option<DetectedPort>,
    /// Eventual errors when detecting connected boards
    #[prost(string, tag = "3")]
    pub error: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoardListItem {
    /// The name for use when identifying the board to a human.
    #[prost(string, tag = "1")]
    pub name: std::string::String,
    /// The fully qualified board name. Used to identify the board to a machine.
    #[prost(string, tag = "2")]
    pub fqbn: std::string::String,
    /// If the board is marked as "hidden" in the platform
    #[prost(bool, tag = "3")]
    pub is_hidden: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompileReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Fully Qualified Board Name, e.g.: `arduino:avr:uno`. If this field is not defined, the FQBN of the board attached to the sketch via the `BoardAttach` method is used.
    #[prost(string, tag = "2")]
    pub fqbn: std::string::String,
    /// The path where the sketch is stored.
    #[prost(string, tag = "3")]
    pub sketch_path: std::string::String,
    /// Show all build preferences used instead of compiling.
    #[prost(bool, tag = "4")]
    pub show_properties: bool,
    /// Print preprocessed code to stdout instead of compiling.
    #[prost(bool, tag = "5")]
    pub preprocess: bool,
    /// Builds of 'core.a' are saved into this path to be cached and reused.
    #[prost(string, tag = "6")]
    pub build_cache_path: std::string::String,
    /// Path to use to store the files used for the compilation. If omitted, a directory will be created in the operating system's default temporary path.
    #[prost(string, tag = "7")]
    pub build_path: std::string::String,
    /// List of custom build properties separated by commas.
    #[prost(string, repeated, tag = "8")]
    pub build_properties: ::std::vec::Vec<std::string::String>,
    /// Used to tell gcc which warning level to use. The level names are: "none", "default", "more" and "all".
    #[prost(string, tag = "9")]
    pub warnings: std::string::String,
    /// Turns on verbose mode.
    #[prost(bool, tag = "10")]
    pub verbose: bool,
    /// Suppresses almost every output.
    #[prost(bool, tag = "11")]
    pub quiet: bool,
    /// VID/PID specific build properties.
    #[prost(string, tag = "12")]
    pub vid_pid: std::string::String,
    /// The max number of concurrent compiler instances to run (as `make -jx`). If jobs is set to 0, it will use the number of available CPUs as the maximum.
    #[prost(int32, tag = "14")]
    pub jobs: i32,
    /// List of custom libraries paths separated by commas.
    #[prost(string, repeated, tag = "15")]
    pub libraries: ::std::vec::Vec<std::string::String>,
    /// Optimize compile output for debug, not for release.
    #[prost(bool, tag = "16")]
    pub optimize_for_debug: bool,
    /// Optional: save the build artifacts in this directory, the directory must exist.
    #[prost(string, tag = "18")]
    pub export_dir: std::string::String,
    /// Optional: cleanup the build folder and do not use any previously cached build
    #[prost(bool, tag = "19")]
    pub clean: bool,
    /// When set to `true` the compiled binary will be copied to the export directory.
    #[prost(bool, tag = "20")]
    pub export_binaries: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompileResp {
    /// The output of the compilation process.
    #[prost(bytes, tag = "1")]
    pub out_stream: std::vec::Vec<u8>,
    /// The error output of the compilation process.
    #[prost(bytes, tag = "2")]
    pub err_stream: std::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlatformInstallReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Vendor name of the platform (e.g., `arduino`).
    #[prost(string, tag = "2")]
    pub platform_package: std::string::String,
    /// Architecture name of the platform (e.g., `avr`).
    #[prost(string, tag = "3")]
    pub architecture: std::string::String,
    /// Platform version to install.
    #[prost(string, tag = "4")]
    pub version: std::string::String,
    /// Set to true to not run (eventual) post install scripts for trusted platforms
    #[prost(bool, tag = "5")]
    pub skip_post_install: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlatformInstallResp {
    /// Progress of the downloads of the platform and tool files.
    #[prost(message, optional, tag = "1")]
    pub progress: ::std::option::Option<DownloadProgress>,
    /// Description of the current stage of the installation.
    #[prost(message, optional, tag = "2")]
    pub task_progress: ::std::option::Option<TaskProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlatformDownloadReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    #[prost(string, tag = "2")]
    pub platform_package: std::string::String,
    /// Architecture name of the platform (e.g., `avr`).
    #[prost(string, tag = "3")]
    pub architecture: std::string::String,
    /// Platform version to download.
    #[prost(string, tag = "4")]
    pub version: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlatformDownloadResp {
    /// Progress of the downloads of platform and tool files.
    #[prost(message, optional, tag = "1")]
    pub progress: ::std::option::Option<DownloadProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlatformUninstallReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Vendor name of the platform (e.g., `arduino`).
    #[prost(string, tag = "2")]
    pub platform_package: std::string::String,
    /// Architecture name of the platform (e.g., `avr`).
    #[prost(string, tag = "3")]
    pub architecture: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlatformUninstallResp {
    /// Description of the current stage of the uninstall.
    #[prost(message, optional, tag = "1")]
    pub task_progress: ::std::option::Option<TaskProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlatformUpgradeReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Vendor name of the platform (e.g., `arduino`).
    #[prost(string, tag = "2")]
    pub platform_package: std::string::String,
    /// Architecture name of the platform (e.g., `avr`).
    #[prost(string, tag = "3")]
    pub architecture: std::string::String,
    /// Set to true to not run (eventual) post install scripts for trusted platforms
    #[prost(bool, tag = "4")]
    pub skip_post_install: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlatformUpgradeResp {
    /// Progress of the downloads of the platform and tool files.
    #[prost(message, optional, tag = "1")]
    pub progress: ::std::option::Option<DownloadProgress>,
    /// Description of the current stage of the upgrade.
    #[prost(message, optional, tag = "2")]
    pub task_progress: ::std::option::Option<TaskProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlatformSearchReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Keywords for the search.
    #[prost(string, tag = "2")]
    pub search_args: std::string::String,
    /// Whether to show all available versions. `false` causes only the newest
    /// versions of the cores to be listed in the search results.
    #[prost(bool, tag = "3")]
    pub all_versions: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlatformSearchResp {
    /// Results of the search.
    #[prost(message, repeated, tag = "1")]
    pub search_output: ::std::vec::Vec<Platform>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlatformListReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Set to true to only list platforms which have a newer version available
    /// than the one currently installed.
    #[prost(bool, tag = "2")]
    pub updatable_only: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlatformListResp {
    /// The installed platforms.
    #[prost(message, repeated, tag = "1")]
    pub installed_platform: ::std::vec::Vec<Platform>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Platform {
    /// Platform ID (e.g., `arduino:avr`).
    #[prost(string, tag = "1")]
    pub id: std::string::String,
    /// Version of the platform.
    #[prost(string, tag = "2")]
    pub installed: std::string::String,
    /// Newest available version of the platform.
    #[prost(string, tag = "3")]
    pub latest: std::string::String,
    /// Name used to identify the platform to humans (e.g., "Arduino AVR Boards").
    #[prost(string, tag = "4")]
    pub name: std::string::String,
    /// Maintainer of the platform's package.
    #[prost(string, tag = "5")]
    pub maintainer: std::string::String,
    /// A URL provided by the author of the platform's package, intended to point
    /// to their website.
    #[prost(string, tag = "6")]
    pub website: std::string::String,
    /// Email of the maintainer of the platform's package.
    #[prost(string, tag = "7")]
    pub email: std::string::String,
    /// List of boards provided by the platform. If the platform is installed,
    /// this is the boards listed in the platform's boards.txt. If the platform is
    /// not installed, this is an arbitrary list of board names provided by the
    /// platform author for display and may not match boards.txt.
    #[prost(message, repeated, tag = "8")]
    pub boards: ::std::vec::Vec<Board>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Board {
    /// Name used to identify the board to humans.
    #[prost(string, tag = "1")]
    pub name: std::string::String,
    /// Fully qualified board name used to identify the board to machines. The FQBN
    /// is only available for installed boards.
    #[prost(string, tag = "2")]
    pub fqbn: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UploadReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Fully qualified board name of the target board (e.g., `arduino:avr:uno`).
    /// If this field is not defined, the FQBN of the board attached to the sketch
    /// via the `BoardAttach` method is used.
    #[prost(string, tag = "2")]
    pub fqbn: std::string::String,
    /// Path where the sketch to be uploaded is stored. Unless the `import_file`
    /// field is defined, the compiled binary is assumed to be at the location and
    /// filename under this path where it is saved by the `Compile` method.
    #[prost(string, tag = "3")]
    pub sketch_path: std::string::String,
    /// The port of the board.
    #[prost(string, tag = "4")]
    pub port: std::string::String,
    /// Whether to turn on verbose output during the upload.
    #[prost(bool, tag = "5")]
    pub verbose: bool,
    /// After upload, verify that the contents of the memory on the board match the
    /// uploaded binary.
    #[prost(bool, tag = "6")]
    pub verify: bool,
    /// When `import_file` is specified, it overrides the `import_dir` and `sketch_path`
    /// params.
    #[prost(string, tag = "7")]
    pub import_file: std::string::String,
    /// Custom path to a directory containing compiled files. When `import_dir` is
    /// not specified, the standard build directory under `sketch_path` is used.
    #[prost(string, tag = "8")]
    pub import_dir: std::string::String,
    /// The programmer to use for upload. If set an UploadUsingProgrammer is triggered
    /// instead of a normal upload. The UploadUsingProgrammer call may also be used for
    /// explicit error check.
    #[prost(string, tag = "9")]
    pub programmer: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UploadResp {
    /// The output of the upload process.
    #[prost(bytes, tag = "1")]
    pub out_stream: std::vec::Vec<u8>,
    /// The error output of the upload process.
    #[prost(bytes, tag = "2")]
    pub err_stream: std::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UploadUsingProgrammerReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Fully qualified board name of the target board (e.g., `arduino:avr:uno`).
    /// If this field is not defined, the FQBN of the board attached to the sketch
    /// via the `BoardAttach` method is used.
    #[prost(string, tag = "2")]
    pub fqbn: std::string::String,
    /// Path where the sketch to be uploaded is stored. Unless the `import_file`
    /// field is defined, the compiled binary is assumed to be at the location and
    /// filename under this path where it is saved by the `Compile` method.
    #[prost(string, tag = "3")]
    pub sketch_path: std::string::String,
    /// The port of the board.
    #[prost(string, tag = "4")]
    pub port: std::string::String,
    /// Whether to turn on verbose output during the upload.
    #[prost(bool, tag = "5")]
    pub verbose: bool,
    /// After upload, verify that the contents of the memory on the board match the
    /// uploaded binary.
    #[prost(bool, tag = "6")]
    pub verify: bool,
    /// When `import_file` is specified, it overrides the `import_dir` and `sketch_path`
    /// params.
    #[prost(string, tag = "7")]
    pub import_file: std::string::String,
    /// Custom path to a directory containing compiled files. When `import_dir` is
    /// not specified, the standard build directory under `sketch_path` is used.
    #[prost(string, tag = "8")]
    pub import_dir: std::string::String,
    /// The programmer to use for upload.
    #[prost(string, tag = "9")]
    pub programmer: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UploadUsingProgrammerResp {
    /// The output of the upload process.
    #[prost(bytes, tag = "1")]
    pub out_stream: std::vec::Vec<u8>,
    /// The error output of the upload process.
    #[prost(bytes, tag = "2")]
    pub err_stream: std::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BurnBootloaderReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Fully qualified board name of the target board (e.g., `arduino:avr:uno`).
    #[prost(string, tag = "2")]
    pub fqbn: std::string::String,
    /// The port of the programmer used to program the bootloader.
    #[prost(string, tag = "3")]
    pub port: std::string::String,
    /// Whether to turn on verbose output during the programming.
    #[prost(bool, tag = "4")]
    pub verbose: bool,
    /// After programming, verify the contents of the memory on the board match the
    /// uploaded binary.
    #[prost(bool, tag = "5")]
    pub verify: bool,
    /// The programmer to use for burning bootloader.
    #[prost(string, tag = "6")]
    pub programmer: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BurnBootloaderResp {
    /// The output of the burn bootloader process.
    #[prost(bytes, tag = "1")]
    pub out_stream: std::vec::Vec<u8>,
    /// The error output of the burn bootloader process.
    #[prost(bytes, tag = "2")]
    pub err_stream: std::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProgrammersAvailableForUploadReq {
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    #[prost(string, tag = "2")]
    pub fqbn: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProgrammersAvailableForUploadResp {
    #[prost(message, repeated, tag = "1")]
    pub programmers: ::std::vec::Vec<Programmer>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryDownloadReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Name of the library.
    #[prost(string, tag = "2")]
    pub name: std::string::String,
    /// The version of the library to download.
    #[prost(string, tag = "3")]
    pub version: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryDownloadResp {
    /// Progress of the library download.
    #[prost(message, optional, tag = "1")]
    pub progress: ::std::option::Option<DownloadProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryInstallReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Name of the library.
    #[prost(string, tag = "2")]
    pub name: std::string::String,
    /// The version of the library to install.
    #[prost(string, tag = "3")]
    pub version: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryInstallResp {
    /// Progress of the library download.
    #[prost(message, optional, tag = "1")]
    pub progress: ::std::option::Option<DownloadProgress>,
    /// Description of the current stage of the installation.
    #[prost(message, optional, tag = "2")]
    pub task_progress: ::std::option::Option<TaskProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryUninstallReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Name of the library.
    #[prost(string, tag = "2")]
    pub name: std::string::String,
    /// The version of the library to uninstall.
    #[prost(string, tag = "3")]
    pub version: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryUninstallResp {
    /// Description of the current stage of the uninstallation.
    #[prost(message, optional, tag = "1")]
    pub task_progress: ::std::option::Option<TaskProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryUpgradeAllReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryUpgradeAllResp {
    /// Progress of the downloads of files needed for the upgrades.
    #[prost(message, optional, tag = "1")]
    pub progress: ::std::option::Option<DownloadProgress>,
    /// Description of the current stage of the upgrade.
    #[prost(message, optional, tag = "2")]
    pub task_progress: ::std::option::Option<TaskProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryResolveDependenciesReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Name of the library.
    #[prost(string, tag = "2")]
    pub name: std::string::String,
    /// The version of the library to check dependencies of. If no version is
    /// specified, dependencies of the newest version will be listed.
    #[prost(string, tag = "3")]
    pub version: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryResolveDependenciesResp {
    /// Dependencies of the library.
    #[prost(message, repeated, tag = "1")]
    pub dependencies: ::std::vec::Vec<LibraryDependencyStatus>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryDependencyStatus {
    /// The name of the library dependency.
    #[prost(string, tag = "1")]
    pub name: std::string::String,
    /// The required version of the library dependency.
    #[prost(string, tag = "2")]
    pub version_required: std::string::String,
    /// Version of the library dependency currently installed.
    #[prost(string, tag = "3")]
    pub version_installed: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibrarySearchReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// The search query.
    #[prost(string, tag = "2")]
    pub query: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibrarySearchResp {
    /// The results of the search.
    #[prost(message, repeated, tag = "1")]
    pub libraries: ::std::vec::Vec<SearchedLibrary>,
    /// Whether the search yielded results.
    #[prost(enumeration = "LibrarySearchStatus", tag = "2")]
    pub status: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchedLibrary {
    /// Library name.
    #[prost(string, tag = "1")]
    pub name: std::string::String,
    /// The index data for the available versions of the library. The key of the
    /// map is the library version.
    #[prost(map = "string, message", tag = "2")]
    pub releases: ::std::collections::HashMap<std::string::String, LibraryRelease>,
    /// The index data for the latest version of the library.
    #[prost(message, optional, tag = "3")]
    pub latest: ::std::option::Option<LibraryRelease>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryRelease {
    /// Value of the `author` field in library.properties.
    #[prost(string, tag = "1")]
    pub author: std::string::String,
    /// Value of the `version` field in library.properties.
    #[prost(string, tag = "2")]
    pub version: std::string::String,
    /// Value of the `maintainer` field in library.properties.
    #[prost(string, tag = "3")]
    pub maintainer: std::string::String,
    /// Value of the `sentence` field in library.properties.
    #[prost(string, tag = "4")]
    pub sentence: std::string::String,
    /// Value of the `paragraph` field in library.properties.
    #[prost(string, tag = "5")]
    pub paragraph: std::string::String,
    /// Value of the `url` field in library.properties.
    #[prost(string, tag = "6")]
    pub website: std::string::String,
    /// Value of the `category` field in library.properties.
    #[prost(string, tag = "7")]
    pub category: std::string::String,
    /// Value of the `architectures` field in library.properties.
    #[prost(string, repeated, tag = "8")]
    pub architectures: ::std::vec::Vec<std::string::String>,
    /// The type categories of the library, as defined in the libraries index.
    /// Possible values: `Arduino`, `Partner`, `Recommended`, `Contributed`,
    /// `Retired`.
    #[prost(string, repeated, tag = "9")]
    pub types: ::std::vec::Vec<std::string::String>,
    /// Information about the library archive file.
    #[prost(message, optional, tag = "10")]
    pub resources: ::std::option::Option<DownloadResource>,
    /// Value of the `license` field in library.properties.
    #[prost(string, tag = "11")]
    pub license: std::string::String,
    /// Value of the `includes` field in library.properties.
    #[prost(string, repeated, tag = "12")]
    pub provides_includes: ::std::vec::Vec<std::string::String>,
    /// The names of the library's dependencies, as defined by the 'depends'
    /// field of library.properties.
    #[prost(message, repeated, tag = "13")]
    pub dependencies: ::std::vec::Vec<LibraryDependency>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryDependency {
    /// Library name of the dependency.
    #[prost(string, tag = "1")]
    pub name: std::string::String,
    /// Version constraint of the dependency.
    #[prost(string, tag = "2")]
    pub version_constraint: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DownloadResource {
    /// Download URL of the library archive.
    #[prost(string, tag = "1")]
    pub url: std::string::String,
    /// Filename of the library archive.
    #[prost(string, tag = "2")]
    pub archivefilename: std::string::String,
    /// Checksum of the library archive.
    #[prost(string, tag = "3")]
    pub checksum: std::string::String,
    /// File size of the library archive.
    #[prost(int64, tag = "4")]
    pub size: i64,
    /// The directory under the staging subdirectory of the data directory the
    /// library archive file will be downloaded to.
    #[prost(string, tag = "5")]
    pub cachepath: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryListReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Whether to include built-in libraries (from platforms and the Arduino
    /// IDE) in the listing.
    #[prost(bool, tag = "2")]
    pub all: bool,
    /// Whether to list only libraries for which there is a newer version than
    /// the installed version available in the libraries index.
    #[prost(bool, tag = "3")]
    pub updatable: bool,
    /// If set filters out the libraries not matching name
    #[prost(string, tag = "4")]
    pub name: std::string::String,
    /// By setting this field all duplicate libraries are filtered out leaving
    /// only the libraries that will be used to compile for the specified board FQBN.
    #[prost(string, tag = "5")]
    pub fqbn: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LibraryListResp {
    /// List of installed libraries.
    #[prost(message, repeated, tag = "1")]
    pub installed_library: ::std::vec::Vec<InstalledLibrary>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InstalledLibrary {
    /// Information about the library.
    #[prost(message, optional, tag = "1")]
    pub library: ::std::option::Option<Library>,
    /// When the `updatable` field of the `LibraryList` request is set to `true`,
    /// this will contain information on the latest version of the library in the
    /// libraries index.
    #[prost(message, optional, tag = "2")]
    pub release: ::std::option::Option<LibraryRelease>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Library {
    /// The library's directory name.
    #[prost(string, tag = "1")]
    pub name: std::string::String,
    /// Value of the `author` field in library.properties.
    #[prost(string, tag = "2")]
    pub author: std::string::String,
    /// Value of the `maintainer` field in library.properties.
    #[prost(string, tag = "3")]
    pub maintainer: std::string::String,
    /// Value of the `sentence` field in library.properties.
    #[prost(string, tag = "4")]
    pub sentence: std::string::String,
    /// Value of the `paragraph` field in library.properties.
    #[prost(string, tag = "5")]
    pub paragraph: std::string::String,
    /// Value of the `url` field in library.properties.
    #[prost(string, tag = "6")]
    pub website: std::string::String,
    /// Value of the `category` field in library.properties.
    #[prost(string, tag = "7")]
    pub category: std::string::String,
    /// Value of the `architectures` field in library.properties.
    #[prost(string, repeated, tag = "8")]
    pub architectures: ::std::vec::Vec<std::string::String>,
    /// The type categories of the library. Possible values: `Arduino`,
    /// `Partner`, `Recommended`, `Contributed`, `Retired`.
    #[prost(string, repeated, tag = "9")]
    pub types: ::std::vec::Vec<std::string::String>,
    /// The path of the library directory.
    #[prost(string, tag = "10")]
    pub install_dir: std::string::String,
    /// The location of the library's source files.
    #[prost(string, tag = "11")]
    pub source_dir: std::string::String,
    /// The location of the library's `utility` directory.
    #[prost(string, tag = "12")]
    pub utility_dir: std::string::String,
    /// If `location` is `platform_builtin` or `referenced_platform_builtin`, the
    /// identifying string for the platform containing the library
    /// (e.g., `arduino:avr@1.8.2`).
    #[prost(string, tag = "14")]
    pub container_platform: std::string::String,
    /// Value of the `name` field in library.properties.
    #[prost(string, tag = "16")]
    pub real_name: std::string::String,
    /// Value of the `dot_a_linkage` field in library.properties.
    #[prost(bool, tag = "17")]
    pub dot_a_linkage: bool,
    /// Value of the `precompiled` field in library.properties.
    #[prost(bool, tag = "18")]
    pub precompiled: bool,
    /// Value of the `ldflags` field in library.properties.
    #[prost(string, tag = "19")]
    pub ld_flags: std::string::String,
    /// A library.properties file is not present in the library's root directory.
    #[prost(bool, tag = "20")]
    pub is_legacy: bool,
    /// Value of the `version` field in library.properties.
    #[prost(string, tag = "21")]
    pub version: std::string::String,
    /// Value of the `license` field in library.properties.
    #[prost(string, tag = "22")]
    pub license: std::string::String,
    /// The data from the library's library.properties file, including unused
    /// fields.
    #[prost(map = "string, string", tag = "23")]
    pub properties: ::std::collections::HashMap<std::string::String, std::string::String>,
    /// The location type of the library installation.
    #[prost(enumeration = "LibraryLocation", tag = "24")]
    pub location: i32,
    /// The library format type.
    #[prost(enumeration = "LibraryLayout", tag = "25")]
    pub layout: i32,
    /// The example sketches provided by the library
    #[prost(string, repeated, tag = "26")]
    pub examples: ::std::vec::Vec<std::string::String>,
    /// Value of the `includes` field in library.properties or, if missing, the list of
    /// include files available on the library source root directory.
    #[prost(string, repeated, tag = "27")]
    pub provides_includes: ::std::vec::Vec<std::string::String>,
    /// Map of FQBNs that specifies if library is compatible with this library
    #[prost(map = "string, bool", tag = "28")]
    pub compatible_with: ::std::collections::HashMap<std::string::String, bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ZipLibraryInstallReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    ///Path to the archived library
    #[prost(string, tag = "2")]
    pub path: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ZipLibraryInstallResp {
    /// Description of the current stage of the installation.
    #[prost(message, optional, tag = "1")]
    pub task_progress: ::std::option::Option<TaskProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GitLibraryInstallReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// URL to the repository containing the library
    #[prost(string, tag = "2")]
    pub url: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GitLibraryInstallResp {
    /// Description of the current stage of the installation.
    #[prost(message, optional, tag = "1")]
    pub task_progress: ::std::option::Option<TaskProgress>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LibrarySearchStatus {
    /// No search results were found.
    Failed = 0,
    /// Search results were found.
    Success = 1,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LibraryLayout {
    /// Library is in the 1.0 Arduino library format.
    FlatLayout = 0,
    /// Library is in the 1.5 Arduino library format.
    RecursiveLayout = 1,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LibraryLocation {
    /// In the `libraries` subdirectory of the Arduino IDE installation.
    IdeBuiltin = 0,
    /// In the `libraries` subdirectory of the user directory (sketchbook).
    User = 1,
    /// In the `libraries` subdirectory of a platform.
    PlatformBuiltin = 2,
    /// When `LibraryLocation` is used in a context where a board is specified,
    /// this indicates the library is in the `libraries` subdirectory of a
    /// platform referenced by the board's platform.
    ReferencedPlatformBuiltin = 3,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InitReq {
    /// Start a Arduino Core Service instance that will provide only Library
    /// Manager functionality.
    #[prost(bool, tag = "2")]
    pub library_manager_only: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InitResp {
    /// An Arduino Core Service instance.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Error messages related to any problems encountered while parsing the
    /// platforms index files.
    #[prost(string, repeated, tag = "2")]
    pub platforms_index_errors: ::std::vec::Vec<std::string::String>,
    /// Error message if a problem was encountered while parsing the libraries
    /// index file.
    #[prost(string, tag = "3")]
    pub libraries_index_error: std::string::String,
    /// Progress of the downloads of platforms and libraries index files.
    #[prost(message, optional, tag = "4")]
    pub download_progress: ::std::option::Option<DownloadProgress>,
    /// Describes the current stage of the initialization.
    #[prost(message, optional, tag = "5")]
    pub task_progress: ::std::option::Option<TaskProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DestroyReq {
    /// The Arduino Core Service instance to destroy.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DestroyResp {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RescanReq {
    /// Arduino Core Service instance from the Init response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RescanResp {
    /// Error messages related to any problems encountered while parsing the
    /// platforms index file.
    #[prost(string, repeated, tag = "1")]
    pub platforms_index_errors: ::std::vec::Vec<std::string::String>,
    /// Error message if a problem was encountered while parsing the libraries
    /// index file.
    #[prost(string, tag = "2")]
    pub libraries_index_error: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateIndexReq {
    /// Arduino Core Service instance from the Init response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateIndexResp {
    /// Progress of the platforms index download.
    #[prost(message, optional, tag = "1")]
    pub download_progress: ::std::option::Option<DownloadProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateLibrariesIndexReq {
    /// Arduino Core Service instance from the Init response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateLibrariesIndexResp {
    /// Progress of the libraries index download.
    #[prost(message, optional, tag = "1")]
    pub download_progress: ::std::option::Option<DownloadProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateCoreLibrariesIndexReq {
    /// Arduino Core Service instance from the Init response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateCoreLibrariesIndexResp {
    /// Progress of the index download.
    #[prost(message, optional, tag = "1")]
    pub download_progress: ::std::option::Option<DownloadProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OutdatedReq {
    /// Arduino Core Service instance from the Init response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OutdatedResp {
    /// List of installed libraries that can be updated.
    #[prost(message, repeated, tag = "1")]
    pub outdated_library: ::std::vec::Vec<InstalledLibrary>,
    /// List of installed cores that can be updated.
    #[prost(message, repeated, tag = "2")]
    pub outdated_platform: ::std::vec::Vec<Platform>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpgradeReq {
    /// Arduino Core Service instance from the Init response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Set to true to not run (eventual) post install scripts
    #[prost(bool, tag = "2")]
    pub skip_post_install: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpgradeResp {
    /// Progress of the downloads of the platforms and libraries files.
    #[prost(message, optional, tag = "1")]
    pub progress: ::std::option::Option<DownloadProgress>,
    /// Description of the current stage of the upgrade.
    #[prost(message, optional, tag = "2")]
    pub task_progress: ::std::option::Option<TaskProgress>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VersionReq {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VersionResp {
    /// The version of Arduino CLI in use.
    #[prost(string, tag = "1")]
    pub version: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LoadSketchReq {
    /// Arduino Core Service instance from the Init response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<Instance>,
    /// Absolute path to single sketch file or a sketch folder
    #[prost(string, tag = "2")]
    pub sketch_path: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LoadSketchResp {
    /// Absolute path to a main sketch files
    #[prost(string, tag = "1")]
    pub main_file: std::string::String,
    /// Absolute path to folder that contains main_file
    #[prost(string, tag = "2")]
    pub location_path: std::string::String,
    /// List of absolute paths to other sketch files
    #[prost(string, repeated, tag = "3")]
    pub other_sketch_files: ::std::vec::Vec<std::string::String>,
    /// List of absolute paths to additional sketch files
    #[prost(string, repeated, tag = "4")]
    pub additional_files: ::std::vec::Vec<std::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArchiveSketchReq {
    /// Absolute path to Sketch file or folder containing Sketch file
    #[prost(string, tag = "1")]
    pub sketch_path: std::string::String,
    /// Absolute path to archive that will be created or folder that will contain it
    #[prost(string, tag = "2")]
    pub archive_path: std::string::String,
    /// Specifies if build directory should be included in the archive
    #[prost(bool, tag = "3")]
    pub include_build_dir: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArchiveSketchResp {}
#[doc = r" Generated client implementations."]
pub mod arduino_core_client {
    #![allow(unused_variables, dead_code, missing_docs)]
    use tonic::codegen::*;
    #[doc = " The main Arduino Platform Service"]
    pub struct ArduinoCoreClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ArduinoCoreClient<tonic::transport::Channel> {
        #[doc = r" Attempt to create a new client by connecting to a given endpoint."]
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: std::convert::TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ArduinoCoreClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::ResponseBody: Body + HttpBody + Send + 'static,
        T::Error: Into<StdError>,
        <T::ResponseBody as HttpBody>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_interceptor(inner: T, interceptor: impl Into<tonic::Interceptor>) -> Self {
            let inner = tonic::client::Grpc::with_interceptor(inner, interceptor);
            Self { inner }
        }
        #[doc = " Start a new instance of the Arduino Core Service"]
        pub async fn init(
            &mut self,
            request: impl tonic::IntoRequest<super::InitReq>,
        ) -> Result<tonic::Response<tonic::codec::Streaming<super::InitResp>>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path =
                http::uri::PathAndQuery::from_static("/cc.arduino.cli.commands.ArduinoCore/Init");
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Destroy an instance of the Arduino Core Service"]
        pub async fn destroy(
            &mut self,
            request: impl tonic::IntoRequest<super::DestroyReq>,
        ) -> Result<tonic::Response<super::DestroyResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/Destroy",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Rescan instance of the Arduino Core Service"]
        pub async fn rescan(
            &mut self,
            request: impl tonic::IntoRequest<super::RescanReq>,
        ) -> Result<tonic::Response<super::RescanResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path =
                http::uri::PathAndQuery::from_static("/cc.arduino.cli.commands.ArduinoCore/Rescan");
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Update package index of the Arduino Core Service"]
        pub async fn update_index(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateIndexReq>,
        ) -> Result<tonic::Response<tonic::codec::Streaming<super::UpdateIndexResp>>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/UpdateIndex",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Update libraries index"]
        pub async fn update_libraries_index(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateLibrariesIndexReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::UpdateLibrariesIndexResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/UpdateLibrariesIndex",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Update packages indexes for both Cores and Libraries"]
        pub async fn update_core_libraries_index(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateCoreLibrariesIndexReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::UpdateCoreLibrariesIndexResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/UpdateCoreLibrariesIndex",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Outdated returns a message with a list of outdated Cores and Libraries"]
        pub async fn outdated(
            &mut self,
            request: impl tonic::IntoRequest<super::OutdatedReq>,
        ) -> Result<tonic::Response<super::OutdatedResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/Outdated",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Upgrade both Cores and Libraries"]
        pub async fn upgrade(
            &mut self,
            request: impl tonic::IntoRequest<super::UpgradeReq>,
        ) -> Result<tonic::Response<tonic::codec::Streaming<super::UpgradeResp>>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/Upgrade",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Get the version of Arduino CLI in use."]
        pub async fn version(
            &mut self,
            request: impl tonic::IntoRequest<super::VersionReq>,
        ) -> Result<tonic::Response<super::VersionResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/Version",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Returns all files composing a Sketch"]
        pub async fn load_sketch(
            &mut self,
            request: impl tonic::IntoRequest<super::LoadSketchReq>,
        ) -> Result<tonic::Response<super::LoadSketchResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/LoadSketch",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Creates a zip file containing all files of specified Sketch"]
        pub async fn archive_sketch(
            &mut self,
            request: impl tonic::IntoRequest<super::ArchiveSketchReq>,
        ) -> Result<tonic::Response<super::ArchiveSketchResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/ArchiveSketch",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Requests details about a board"]
        pub async fn board_details(
            &mut self,
            request: impl tonic::IntoRequest<super::BoardDetailsReq>,
        ) -> Result<tonic::Response<super::BoardDetailsResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/BoardDetails",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Attach a board to a sketch. When the `fqbn` field of a request is not"]
        #[doc = " provided, the FQBN of the attached board will be used."]
        pub async fn board_attach(
            &mut self,
            request: impl tonic::IntoRequest<super::BoardAttachReq>,
        ) -> Result<tonic::Response<tonic::codec::Streaming<super::BoardAttachResp>>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/BoardAttach",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " List the boards currently connected to the computer."]
        pub async fn board_list(
            &mut self,
            request: impl tonic::IntoRequest<super::BoardListReq>,
        ) -> Result<tonic::Response<super::BoardListResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/BoardList",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " List all the boards provided by installed platforms."]
        pub async fn board_list_all(
            &mut self,
            request: impl tonic::IntoRequest<super::BoardListAllReq>,
        ) -> Result<tonic::Response<super::BoardListAllResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/BoardListAll",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " List boards connection and disconnected events."]
        pub async fn board_list_watch(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::BoardListWatchReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::BoardListWatchResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/BoardListWatch",
            );
            self.inner
                .streaming(request.into_streaming_request(), path, codec)
                .await
        }
        #[doc = " Compile an Arduino sketch."]
        pub async fn compile(
            &mut self,
            request: impl tonic::IntoRequest<super::CompileReq>,
        ) -> Result<tonic::Response<tonic::codec::Streaming<super::CompileResp>>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/Compile",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Download and install a platform and its tool dependencies."]
        pub async fn platform_install(
            &mut self,
            request: impl tonic::IntoRequest<super::PlatformInstallReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::PlatformInstallResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/PlatformInstall",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Download a platform and its tool dependencies to the `staging/packages`"]
        #[doc = " subdirectory of the data directory."]
        pub async fn platform_download(
            &mut self,
            request: impl tonic::IntoRequest<super::PlatformDownloadReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::PlatformDownloadResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/PlatformDownload",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Uninstall a platform as well as its tool dependencies that are not used by"]
        #[doc = " other installed platforms."]
        pub async fn platform_uninstall(
            &mut self,
            request: impl tonic::IntoRequest<super::PlatformUninstallReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::PlatformUninstallResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/PlatformUninstall",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Upgrade an installed platform to the latest version."]
        pub async fn platform_upgrade(
            &mut self,
            request: impl tonic::IntoRequest<super::PlatformUpgradeReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::PlatformUpgradeResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/PlatformUpgrade",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Upload a compiled sketch to a board."]
        pub async fn upload(
            &mut self,
            request: impl tonic::IntoRequest<super::UploadReq>,
        ) -> Result<tonic::Response<tonic::codec::Streaming<super::UploadResp>>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path =
                http::uri::PathAndQuery::from_static("/cc.arduino.cli.commands.ArduinoCore/Upload");
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Upload a compiled sketch to a board using a programmer."]
        pub async fn upload_using_programmer(
            &mut self,
            request: impl tonic::IntoRequest<super::UploadUsingProgrammerReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::UploadUsingProgrammerResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/UploadUsingProgrammer",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " List programmers available for a board."]
        pub async fn list_programmers_available_for_upload(
            &mut self,
            request: impl tonic::IntoRequest<super::ListProgrammersAvailableForUploadReq>,
        ) -> Result<tonic::Response<super::ListProgrammersAvailableForUploadResp>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/ListProgrammersAvailableForUpload",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Burn bootloader to a board."]
        pub async fn burn_bootloader(
            &mut self,
            request: impl tonic::IntoRequest<super::BurnBootloaderReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::BurnBootloaderResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/BurnBootloader",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Search for a platform in the platforms indexes."]
        pub async fn platform_search(
            &mut self,
            request: impl tonic::IntoRequest<super::PlatformSearchReq>,
        ) -> Result<tonic::Response<super::PlatformSearchResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/PlatformSearch",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " List all installed platforms."]
        pub async fn platform_list(
            &mut self,
            request: impl tonic::IntoRequest<super::PlatformListReq>,
        ) -> Result<tonic::Response<super::PlatformListResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/PlatformList",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Download the archive file of an Arduino library in the libraries index to"]
        #[doc = " the staging directory."]
        pub async fn library_download(
            &mut self,
            request: impl tonic::IntoRequest<super::LibraryDownloadReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::LibraryDownloadResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/LibraryDownload",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Download and install an Arduino library from the libraries index."]
        pub async fn library_install(
            &mut self,
            request: impl tonic::IntoRequest<super::LibraryInstallReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::LibraryInstallResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/LibraryInstall",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Install a library from a Zip File "]
        pub async fn zip_library_install(
            &mut self,
            request: impl tonic::IntoRequest<super::ZipLibraryInstallReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::ZipLibraryInstallResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/ZipLibraryInstall",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Download and install a library from a git url"]
        pub async fn git_library_install(
            &mut self,
            request: impl tonic::IntoRequest<super::GitLibraryInstallReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::GitLibraryInstallResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/GitLibraryInstall",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Uninstall an Arduino library."]
        pub async fn library_uninstall(
            &mut self,
            request: impl tonic::IntoRequest<super::LibraryUninstallReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::LibraryUninstallResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/LibraryUninstall",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Upgrade all installed Arduino libraries to the newest version available."]
        pub async fn library_upgrade_all(
            &mut self,
            request: impl tonic::IntoRequest<super::LibraryUpgradeAllReq>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::LibraryUpgradeAllResp>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/LibraryUpgradeAll",
            );
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " List the recursive dependencies of a library, as defined by the `depends`"]
        #[doc = " field of the library.properties files."]
        pub async fn library_resolve_dependencies(
            &mut self,
            request: impl tonic::IntoRequest<super::LibraryResolveDependenciesReq>,
        ) -> Result<tonic::Response<super::LibraryResolveDependenciesResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/LibraryResolveDependencies",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Search the Arduino libraries index for libraries."]
        pub async fn library_search(
            &mut self,
            request: impl tonic::IntoRequest<super::LibrarySearchReq>,
        ) -> Result<tonic::Response<super::LibrarySearchResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/LibrarySearch",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " List the installed libraries."]
        pub async fn library_list(
            &mut self,
            request: impl tonic::IntoRequest<super::LibraryListReq>,
        ) -> Result<tonic::Response<super::LibraryListResp>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/cc.arduino.cli.commands.ArduinoCore/LibraryList",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
    }
    impl<T: Clone> Clone for ArduinoCoreClient<T> {
        fn clone(&self) -> Self {
            Self {
                inner: self.inner.clone(),
            }
        }
    }
    impl<T> std::fmt::Debug for ArduinoCoreClient<T> {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "ArduinoCoreClient {{ ... }}")
        }
    }
}