/// The top-level message sent by the client for the `Debug` method.
/// Multiple `DebugReq` messages can be sent but the first message
/// must contain a `DebugConfigReq` message to initialize the debug session.
/// All subsequent messages must contain bytes to be sent to the debug session
/// and must not contain a `DebugReq` message.
///
/// Content must be either a debug session config or data to be sent.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DebugReq {
    /// Provides information to the debug that specifies which is the target.
    /// The first `StreamingOpenReq` message must contain a `DebugReq`
    /// message.
    #[prost(message, optional, tag = "1")]
    pub debug_req: ::std::option::Option<DebugConfigReq>,
    /// The data to be sent to the target being monitored.
    #[prost(bytes, tag = "2")]
    pub data: std::vec::Vec<u8>,
    /// Set this to true to send and Interrupt signal to the debugger process
    #[prost(bool, tag = "3")]
    pub send_interrupt: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DebugConfigReq {
    /// Arduino Core Service instance from the `Init` response.
    #[prost(message, optional, tag = "1")]
    pub instance: ::std::option::Option<super::commands::Instance>,
    /// Fully qualified board name of the board in use
    /// (e.g., `arduino:samd:mkr1000`). If this is omitted, the FQBN attached to
    /// the sketch will be used.
    #[prost(string, tag = "2")]
    pub fqbn: std::string::String,
    /// Path to the sketch that is running on the board. The compiled executable
    /// is expected to be located under this path.
    #[prost(string, tag = "3")]
    pub sketch_path: std::string::String,
    /// Port of the debugger (optional).
    #[prost(string, tag = "4")]
    pub port: std::string::String,
    /// Which GDB command interpreter to use.
    #[prost(string, tag = "5")]
    pub interpreter: std::string::String,
    /// Directory containing the compiled executable. If `import_dir` is not
    /// specified, the executable is assumed to be in
    /// `{sketch_path}/build/{fqbn}/`.
    #[prost(string, tag = "8")]
    pub import_dir: std::string::String,
    /// The programmer to use for debugging.
    #[prost(string, tag = "9")]
    pub programmer: std::string::String,
}
///
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DebugResp {
    /// Incoming data from the debugger tool.
    #[prost(bytes, tag = "1")]
    pub data: std::vec::Vec<u8>,
    /// Incoming error output from the debugger tool.
    #[prost(string, tag = "2")]
    pub error: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDebugConfigResp {
    /// The executable binary to debug
    #[prost(string, tag = "1")]
    pub executable: std::string::String,
    /// The toolchain type used for the build (for example "gcc")
    #[prost(string, tag = "2")]
    pub toolchain: std::string::String,
    /// The toolchain directory
    #[prost(string, tag = "3")]
    pub toolchain_path: std::string::String,
    /// The toolchain architecture prefix (for example "arm-none-eabi-")
    #[prost(string, tag = "4")]
    pub toolchain_prefix: std::string::String,
    /// The GDB server type used to connect to the programmer/board (for example "openocd")
    #[prost(string, tag = "5")]
    pub server: std::string::String,
    /// The GDB server directory
    #[prost(string, tag = "6")]
    pub server_path: std::string::String,
    /// Extra configuration parameters wrt toolchain
    #[prost(map = "string, string", tag = "7")]
    pub toolchain_configuration:
        ::std::collections::HashMap<std::string::String, std::string::String>,
    /// Extra configuration parameters wrt GDB server
    #[prost(map = "string, string", tag = "8")]
    pub server_configuration: ::std::collections::HashMap<std::string::String, std::string::String>,
}
#[doc = r" Generated client implementations."]
pub mod debug_client {
    #![allow(unused_variables, dead_code, missing_docs)]
    use tonic::codegen::*;
    #[doc = " Service that abstract a debug Session usage"]
    pub struct DebugClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl DebugClient<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> DebugClient<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 debug session and communicate with the debugger tool."]
        pub async fn debug(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::DebugReq>,
        ) -> Result<tonic::Response<tonic::codec::Streaming<super::DebugResp>>, 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.debug.Debug/Debug");
            self.inner
                .streaming(request.into_streaming_request(), path, codec)
                .await
        }
        pub async fn get_debug_config(
            &mut self,
            request: impl tonic::IntoRequest<super::DebugConfigReq>,
        ) -> Result<tonic::Response<super::GetDebugConfigResp>, 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.debug.Debug/GetDebugConfig");
            self.inner.unary(request.into_request(), path, codec).await
        }
    }
    impl<T: Clone> Clone for DebugClient<T> {
        fn clone(&self) -> Self {
            Self {
                inner: self.inner.clone(),
            }
        }
    }
    impl<T> std::fmt::Debug for DebugClient<T> {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "DebugClient {{ ... }}")
        }
    }
}