/// The device resource.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Device {
    /// The user-defined device identifier. The device ID must be unique
    /// within a device registry.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// The resource path name. For example,
    /// `projects/p1/locations/us-central1/registries/registry0/devices/dev0` or
    /// `projects/p1/locations/us-central1/registries/registry0/devices/{num_id}`.
    /// When `name` is populated as a response from the service, it always ends
    /// in the device numeric ID.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// [Output only] A server-defined unique numeric ID for the device. This is a
    /// more compact way to identify devices, and it is globally unique.
    #[prost(uint64, tag = "3")]
    pub num_id: u64,
    /// The credentials used to authenticate this device. To allow credential
    /// rotation without interruption, multiple device credentials can be bound to
    /// this device. No more than 3 credentials can be bound to a single device at
    /// a time. When new credentials are added to a device, they are verified
    /// against the registry credentials. For details, see the description of the
    /// `DeviceRegistry.credentials` field.
    #[prost(message, repeated, tag = "12")]
    pub credentials: ::prost::alloc::vec::Vec<DeviceCredential>,
    /// [Output only] The last time an MQTT `PINGREQ` was received. This field
    /// applies only to devices connecting through MQTT. MQTT clients usually only
    /// send `PINGREQ` messages if the connection is idle, and no other messages
    /// have been sent. Timestamps are periodically collected and written to
    /// storage; they may be stale by a few minutes.
    #[prost(message, optional, tag = "7")]
    pub last_heartbeat_time: ::core::option::Option<::prost_types::Timestamp>,
    /// [Output only] The last time a telemetry event was received. Timestamps are
    /// periodically collected and written to storage; they may be stale by a few
    /// minutes.
    #[prost(message, optional, tag = "8")]
    pub last_event_time: ::core::option::Option<::prost_types::Timestamp>,
    /// [Output only] The last time a state event was received. Timestamps are
    /// periodically collected and written to storage; they may be stale by a few
    /// minutes.
    #[prost(message, optional, tag = "20")]
    pub last_state_time: ::core::option::Option<::prost_types::Timestamp>,
    /// [Output only] The last time a cloud-to-device config version acknowledgment
    /// was received from the device. This field is only for configurations
    /// sent through MQTT.
    #[prost(message, optional, tag = "14")]
    pub last_config_ack_time: ::core::option::Option<::prost_types::Timestamp>,
    /// [Output only] The last time a cloud-to-device config version was sent to
    /// the device.
    #[prost(message, optional, tag = "18")]
    pub last_config_send_time: ::core::option::Option<::prost_types::Timestamp>,
    /// If a device is blocked, connections or requests from this device will fail.
    /// Can be used to temporarily prevent the device from connecting if, for
    /// example, the sensor is generating bad data and needs maintenance.
    #[prost(bool, tag = "19")]
    pub blocked: bool,
    /// [Output only] The time the most recent error occurred, such as a failure to
    /// publish to Cloud Pub/Sub. This field is the timestamp of
    /// 'last_error_status'.
    #[prost(message, optional, tag = "10")]
    pub last_error_time: ::core::option::Option<::prost_types::Timestamp>,
    /// [Output only] The error message of the most recent error, such as a failure
    /// to publish to Cloud Pub/Sub. 'last_error_time' is the timestamp of this
    /// field. If no errors have occurred, this field has an empty message
    /// and the status code 0 == OK. Otherwise, this field is expected to have a
    /// status code other than OK.
    #[prost(message, optional, tag = "11")]
    pub last_error_status: ::core::option::Option<super::super::super::rpc::Status>,
    /// The most recent device configuration, which is eventually sent from
    /// Cloud IoT Core to the device. If not present on creation, the
    /// configuration will be initialized with an empty payload and version value
    /// of `1`. To update this field after creation, use the
    /// `DeviceManager.ModifyCloudToDeviceConfig` method.
    #[prost(message, optional, tag = "13")]
    pub config: ::core::option::Option<DeviceConfig>,
    /// [Output only] The state most recently received from the device. If no state
    /// has been reported, this field is not present.
    #[prost(message, optional, tag = "16")]
    pub state: ::core::option::Option<DeviceState>,
    /// **Beta Feature**
    ///
    /// The logging verbosity for device activity. If unspecified,
    /// DeviceRegistry.log_level will be used.
    #[prost(enumeration = "LogLevel", tag = "21")]
    pub log_level: i32,
    /// The metadata key-value pairs assigned to the device. This metadata is not
    /// interpreted or indexed by Cloud IoT Core. It can be used to add contextual
    /// information for the device.
    ///
    /// Keys must conform to the regular expression \[a-zA-Z][a-zA-Z0-9-_.+~%\]+ and
    /// be less than 128 bytes in length.
    ///
    /// Values are free-form strings. Each value must be less than or equal to 32
    /// KB in size.
    ///
    /// The total size of all keys and values must be less than 256 KB, and the
    /// maximum number of key-value pairs is 500.
    #[prost(map = "string, string", tag = "17")]
    pub metadata:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Gateway-related configuration and state.
    #[prost(message, optional, tag = "24")]
    pub gateway_config: ::core::option::Option<GatewayConfig>,
}
/// Gateway-related configuration and state.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GatewayConfig {
    /// Indicates whether the device is a gateway.
    #[prost(enumeration = "GatewayType", tag = "1")]
    pub gateway_type: i32,
    /// Indicates how to authorize and/or authenticate devices to access the
    /// gateway.
    #[prost(enumeration = "GatewayAuthMethod", tag = "2")]
    pub gateway_auth_method: i32,
    /// [Output only] The ID of the gateway the device accessed most recently.
    #[prost(string, tag = "3")]
    pub last_accessed_gateway_id: ::prost::alloc::string::String,
    /// [Output only] The most recent time at which the device accessed the gateway
    /// specified in `last_accessed_gateway`.
    #[prost(message, optional, tag = "4")]
    pub last_accessed_gateway_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// A container for a group of devices.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeviceRegistry {
    /// The identifier of this device registry. For example, `myRegistry`.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// The resource path name. For example,
    /// `projects/example-project/locations/us-central1/registries/my-registry`.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// The configuration for notification of telemetry events received from the
    /// device. All telemetry events that were successfully published by the
    /// device and acknowledged by Cloud IoT Core are guaranteed to be
    /// delivered to Cloud Pub/Sub. If multiple configurations match a message,
    /// only the first matching configuration is used. If you try to publish a
    /// device telemetry event using MQTT without specifying a Cloud Pub/Sub topic
    /// for the device's registry, the connection closes automatically. If you try
    /// to do so using an HTTP connection, an error is returned. Up to 10
    /// configurations may be provided.
    #[prost(message, repeated, tag = "10")]
    pub event_notification_configs: ::prost::alloc::vec::Vec<EventNotificationConfig>,
    /// The configuration for notification of new states received from the device.
    /// State updates are guaranteed to be stored in the state history, but
    /// notifications to Cloud Pub/Sub are not guaranteed. For example, if
    /// permissions are misconfigured or the specified topic doesn't exist, no
    /// notification will be published but the state will still be stored in Cloud
    /// IoT Core.
    #[prost(message, optional, tag = "7")]
    pub state_notification_config: ::core::option::Option<StateNotificationConfig>,
    /// The MQTT configuration for this device registry.
    #[prost(message, optional, tag = "4")]
    pub mqtt_config: ::core::option::Option<MqttConfig>,
    /// The DeviceService (HTTP) configuration for this device registry.
    #[prost(message, optional, tag = "9")]
    pub http_config: ::core::option::Option<HttpConfig>,
    /// **Beta Feature**
    ///
    /// The default logging verbosity for activity from devices in this registry.
    /// The verbosity level can be overridden by Device.log_level.
    #[prost(enumeration = "LogLevel", tag = "11")]
    pub log_level: i32,
    /// The credentials used to verify the device credentials. No more than 10
    /// credentials can be bound to a single registry at a time. The verification
    /// process occurs at the time of device creation or update. If this field is
    /// empty, no verification is performed. Otherwise, the credentials of a newly
    /// created device or added credentials of an updated device should be signed
    /// with one of these registry credentials.
    ///
    /// Note, however, that existing devices will never be affected by
    /// modifications to this list of credentials: after a device has been
    /// successfully created in a registry, it should be able to connect even if
    /// its registry credentials are revoked, deleted, or modified.
    #[prost(message, repeated, tag = "8")]
    pub credentials: ::prost::alloc::vec::Vec<RegistryCredential>,
}
/// The configuration of MQTT for a device registry.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MqttConfig {
    /// If enabled, allows connections using the MQTT protocol. Otherwise, MQTT
    /// connections to this registry will fail.
    #[prost(enumeration = "MqttState", tag = "1")]
    pub mqtt_enabled_state: i32,
}
/// The configuration of the HTTP bridge for a device registry.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HttpConfig {
    /// If enabled, allows devices to use DeviceService via the HTTP protocol.
    /// Otherwise, any requests to DeviceService will fail for this registry.
    #[prost(enumeration = "HttpState", tag = "1")]
    pub http_enabled_state: i32,
}
/// The configuration for forwarding telemetry events.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventNotificationConfig {
    /// If the subfolder name matches this string exactly, this configuration will
    /// be used. The string must not include the leading '/' character. If empty,
    /// all strings are matched. This field is used only for telemetry events;
    /// subfolders are not supported for state changes.
    #[prost(string, tag = "2")]
    pub subfolder_matches: ::prost::alloc::string::String,
    /// A Cloud Pub/Sub topic name. For example,
    /// `projects/myProject/topics/deviceEvents`.
    #[prost(string, tag = "1")]
    pub pubsub_topic_name: ::prost::alloc::string::String,
}
/// The configuration for notification of new states received from the device.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StateNotificationConfig {
    /// A Cloud Pub/Sub topic name. For example,
    /// `projects/myProject/topics/deviceEvents`.
    #[prost(string, tag = "1")]
    pub pubsub_topic_name: ::prost::alloc::string::String,
}
/// A server-stored registry credential used to validate device credentials.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RegistryCredential {
    /// The credential data. Reserved for expansion in the future.
    #[prost(oneof = "registry_credential::Credential", tags = "1")]
    pub credential: ::core::option::Option<registry_credential::Credential>,
}
/// Nested message and enum types in `RegistryCredential`.
pub mod registry_credential {
    /// The credential data. Reserved for expansion in the future.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Credential {
        /// A public key certificate used to verify the device credentials.
        #[prost(message, tag = "1")]
        PublicKeyCertificate(super::PublicKeyCertificate),
    }
}
/// Details of an X.509 certificate. For informational purposes only.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct X509CertificateDetails {
    /// The entity that signed the certificate.
    #[prost(string, tag = "1")]
    pub issuer: ::prost::alloc::string::String,
    /// The entity the certificate and public key belong to.
    #[prost(string, tag = "2")]
    pub subject: ::prost::alloc::string::String,
    /// The time the certificate becomes valid.
    #[prost(message, optional, tag = "3")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The time the certificate becomes invalid.
    #[prost(message, optional, tag = "4")]
    pub expiry_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The algorithm used to sign the certificate.
    #[prost(string, tag = "5")]
    pub signature_algorithm: ::prost::alloc::string::String,
    /// The type of public key in the certificate.
    #[prost(string, tag = "6")]
    pub public_key_type: ::prost::alloc::string::String,
}
/// A public key certificate format and data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublicKeyCertificate {
    /// The certificate format.
    #[prost(enumeration = "PublicKeyCertificateFormat", tag = "1")]
    pub format: i32,
    /// The certificate data.
    #[prost(string, tag = "2")]
    pub certificate: ::prost::alloc::string::String,
    /// [Output only] The certificate details. Used only for X.509 certificates.
    #[prost(message, optional, tag = "3")]
    pub x509_details: ::core::option::Option<X509CertificateDetails>,
}
/// A server-stored device credential used for authentication.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeviceCredential {
    /// \[Optional\] The time at which this credential becomes invalid. This
    /// credential will be ignored for new client authentication requests after
    /// this timestamp; however, it will not be automatically deleted.
    #[prost(message, optional, tag = "6")]
    pub expiration_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The credential data. Reserved for expansion in the future.
    #[prost(oneof = "device_credential::Credential", tags = "2")]
    pub credential: ::core::option::Option<device_credential::Credential>,
}
/// Nested message and enum types in `DeviceCredential`.
pub mod device_credential {
    /// The credential data. Reserved for expansion in the future.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Credential {
        /// A public key used to verify the signature of JSON Web Tokens (JWTs).
        /// When adding a new device credential, either via device creation or via
        /// modifications, this public key credential may be required to be signed by
        /// one of the registry level certificates. More specifically, if the
        /// registry contains at least one certificate, any new device credential
        /// must be signed by one of the registry certificates. As a result,
        /// when the registry contains certificates, only X.509 certificates are
        /// accepted as device credentials. However, if the registry does
        /// not contain a certificate, self-signed certificates and public keys will
        /// be accepted. New device credentials must be different from every
        /// registry-level certificate.
        #[prost(message, tag = "2")]
        PublicKey(super::PublicKeyCredential),
    }
}
/// A public key format and data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublicKeyCredential {
    /// The format of the key.
    #[prost(enumeration = "PublicKeyFormat", tag = "1")]
    pub format: i32,
    /// The key data.
    #[prost(string, tag = "2")]
    pub key: ::prost::alloc::string::String,
}
/// The device configuration. Eventually delivered to devices.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeviceConfig {
    /// [Output only] The version of this update. The version number is assigned by
    /// the server, and is always greater than 0 after device creation. The
    /// version must be 0 on the `CreateDevice` request if a `config` is
    /// specified; the response of `CreateDevice` will always have a value of 1.
    #[prost(int64, tag = "1")]
    pub version: i64,
    /// [Output only] The time at which this configuration version was updated in
    /// Cloud IoT Core. This timestamp is set by the server.
    #[prost(message, optional, tag = "2")]
    pub cloud_update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// [Output only] The time at which Cloud IoT Core received the
    /// acknowledgment from the device, indicating that the device has received
    /// this configuration version. If this field is not present, the device has
    /// not yet acknowledged that it received this version. Note that when
    /// the config was sent to the device, many config versions may have been
    /// available in Cloud IoT Core while the device was disconnected, and on
    /// connection, only the latest version is sent to the device. Some
    /// versions may never be sent to the device, and therefore are never
    /// acknowledged. This timestamp is set by Cloud IoT Core.
    #[prost(message, optional, tag = "3")]
    pub device_ack_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The device configuration data.
    #[prost(bytes = "vec", tag = "4")]
    pub binary_data: ::prost::alloc::vec::Vec<u8>,
}
/// The device state, as reported by the device.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeviceState {
    /// [Output only] The time at which this state version was updated in Cloud
    /// IoT Core.
    #[prost(message, optional, tag = "1")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The device state data.
    #[prost(bytes = "vec", tag = "2")]
    pub binary_data: ::prost::alloc::vec::Vec<u8>,
}
/// Indicates whether an MQTT connection is enabled or disabled. See the field
/// description for details.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum MqttState {
    /// No MQTT state specified. If not specified, MQTT will be enabled by default.
    Unspecified = 0,
    /// Enables a MQTT connection.
    MqttEnabled = 1,
    /// Disables a MQTT connection.
    MqttDisabled = 2,
}
/// Indicates whether DeviceService (HTTP) is enabled or disabled for the
/// registry. See the field description for details.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum HttpState {
    /// No HTTP state specified. If not specified, DeviceService will be
    /// enabled by default.
    Unspecified = 0,
    /// Enables DeviceService (HTTP) service for the registry.
    HttpEnabled = 1,
    /// Disables DeviceService (HTTP) service for the registry.
    HttpDisabled = 2,
}
/// **Beta Feature**
///
/// The logging verbosity for device activity. Specifies which events should be
/// written to logs. For example, if the LogLevel is ERROR, only events that
/// terminate in errors will be logged. LogLevel is inclusive; enabling INFO
/// logging will also enable ERROR logging.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LogLevel {
    /// No logging specified. If not specified, logging will be disabled.
    Unspecified = 0,
    /// Disables logging.
    None = 10,
    /// Error events will be logged.
    Error = 20,
    /// Informational events will be logged, such as connections and
    /// disconnections.
    Info = 30,
    /// All events will be logged.
    Debug = 40,
}
/// Gateway type.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum GatewayType {
    /// If unspecified, the device is considered a non-gateway device.
    Unspecified = 0,
    /// The device is a gateway.
    Gateway = 1,
    /// The device is not a gateway.
    NonGateway = 2,
}
/// The gateway authorization/authentication method. This setting determines how
/// Cloud IoT Core authorizes/authenticate devices to access the gateway.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum GatewayAuthMethod {
    /// No authentication/authorization method specified. No devices are allowed to
    /// access the gateway.
    Unspecified = 0,
    /// The device is authenticated through the gateway association only. Device
    /// credentials are ignored even if provided.
    AssociationOnly = 1,
    /// The device is authenticated through its own credentials. Gateway
    /// association is not checked.
    DeviceAuthTokenOnly = 2,
    /// The device is authenticated through both device credentials and gateway
    /// association. The device must be bound to the gateway and must provide its
    /// own credentials.
    AssociationAndDeviceAuthToken = 3,
}
/// The supported formats for the public key.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PublicKeyCertificateFormat {
    /// The format has not been specified. This is an invalid default value and
    /// must not be used.
    UnspecifiedPublicKeyCertificateFormat = 0,
    /// An X.509v3 certificate (\[RFC5280\](<https://www.ietf.org/rfc/rfc5280.txt>)),
    /// encoded in base64, and wrapped by `-----BEGIN CERTIFICATE-----` and
    /// `-----END CERTIFICATE-----`.
    X509CertificatePem = 1,
}
/// The supported formats for the public key.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PublicKeyFormat {
    /// The format has not been specified. This is an invalid default value and
    /// must not be used.
    UnspecifiedPublicKeyFormat = 0,
    /// An RSA public key encoded in base64, and wrapped by
    /// `-----BEGIN PUBLIC KEY-----` and `-----END PUBLIC KEY-----`. This can be
    /// used to verify `RS256` signatures in JWT tokens (\[RFC7518\](
    /// <https://www.ietf.org/rfc/rfc7518.txt>)).
    RsaPem = 3,
    /// As RSA_PEM, but wrapped in an X.509v3 certificate (\[RFC5280\](
    /// <https://www.ietf.org/rfc/rfc5280.txt>)), encoded in base64, and wrapped by
    /// `-----BEGIN CERTIFICATE-----` and `-----END CERTIFICATE-----`.
    RsaX509Pem = 1,
    /// Public key for the ECDSA algorithm using P-256 and SHA-256, encoded in
    /// base64, and wrapped by `-----BEGIN PUBLIC KEY-----` and `-----END
    /// PUBLIC KEY-----`. This can be used to verify JWT tokens with the `ES256`
    /// algorithm (\[RFC7518\](<https://www.ietf.org/rfc/rfc7518.txt>)). This curve is
    /// defined in \[OpenSSL\](<https://www.openssl.org/>) as the `prime256v1` curve.
    Es256Pem = 2,
    /// As ES256_PEM, but wrapped in an X.509v3 certificate (\[RFC5280\](
    /// <https://www.ietf.org/rfc/rfc5280.txt>)), encoded in base64, and wrapped by
    /// `-----BEGIN CERTIFICATE-----` and `-----END CERTIFICATE-----`.
    Es256X509Pem = 4,
}
/// Request for `CreateDeviceRegistry`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateDeviceRegistryRequest {
    /// Required. The project and cloud region where this device registry must be created.
    /// For example, `projects/example-project/locations/us-central1`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The device registry. The field `name` must be empty. The server will
    /// generate that field from the device registry `id` provided and the
    /// `parent` field.
    #[prost(message, optional, tag = "2")]
    pub device_registry: ::core::option::Option<DeviceRegistry>,
}
/// Request for `GetDeviceRegistry`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDeviceRegistryRequest {
    /// Required. The name of the device registry. For example,
    /// `projects/example-project/locations/us-central1/registries/my-registry`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for `DeleteDeviceRegistry`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteDeviceRegistryRequest {
    /// Required. The name of the device registry. For example,
    /// `projects/example-project/locations/us-central1/registries/my-registry`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for `UpdateDeviceRegistry`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateDeviceRegistryRequest {
    /// Required. The new values for the device registry. The `id` field must be empty, and
    /// the `name` field must indicate the path of the resource. For example,
    /// `projects/example-project/locations/us-central1/registries/my-registry`.
    #[prost(message, optional, tag = "1")]
    pub device_registry: ::core::option::Option<DeviceRegistry>,
    /// Required. Only updates the `device_registry` fields indicated by this mask.
    /// The field mask must not be empty, and it must not contain fields that
    /// are immutable or only set by the server.
    /// Mutable top-level fields: `event_notification_config`, `http_config`,
    /// `mqtt_config`, and `state_notification_config`.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request for `ListDeviceRegistries`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDeviceRegistriesRequest {
    /// Required. The project and cloud region path. For example,
    /// `projects/example-project/locations/us-central1`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of registries to return in the response. If this value
    /// is zero, the service will select a default size. A call may return fewer
    /// objects than requested. A non-empty `next_page_token` in the response
    /// indicates that more data is available.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The value returned by the last `ListDeviceRegistriesResponse`; indicates
    /// that this is a continuation of a prior `ListDeviceRegistries` call and
    /// the system should return the next page of data.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response for `ListDeviceRegistries`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDeviceRegistriesResponse {
    /// The registries that matched the query.
    #[prost(message, repeated, tag = "1")]
    pub device_registries: ::prost::alloc::vec::Vec<DeviceRegistry>,
    /// If not empty, indicates that there may be more registries that match the
    /// request; this value should be passed in a new
    /// `ListDeviceRegistriesRequest`.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request for `CreateDevice`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateDeviceRequest {
    /// Required. The name of the device registry where this device should be created.
    /// For example,
    /// `projects/example-project/locations/us-central1/registries/my-registry`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The device registration details. The field `name` must be empty. The server
    /// generates `name` from the device registry `id` and the
    /// `parent` field.
    #[prost(message, optional, tag = "2")]
    pub device: ::core::option::Option<Device>,
}
/// Request for `GetDevice`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDeviceRequest {
    /// Required. The name of the device. For example,
    /// `projects/p0/locations/us-central1/registries/registry0/devices/device0` or
    /// `projects/p0/locations/us-central1/registries/registry0/devices/{num_id}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The fields of the `Device` resource to be returned in the response. If the
    /// field mask is unset or empty, all fields are returned. Fields have to be
    /// provided in snake_case format, for example: `last_heartbeat_time`.
    #[prost(message, optional, tag = "2")]
    pub field_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request for `UpdateDevice`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateDeviceRequest {
    /// Required. The new values for the device. The `id` and `num_id` fields must
    /// be empty, and the field `name` must specify the name path. For example,
    /// `projects/p0/locations/us-central1/registries/registry0/devices/device0`or
    /// `projects/p0/locations/us-central1/registries/registry0/devices/{num_id}`.
    #[prost(message, optional, tag = "2")]
    pub device: ::core::option::Option<Device>,
    /// Required. Only updates the `device` fields indicated by this mask.
    /// The field mask must not be empty, and it must not contain fields that
    /// are immutable or only set by the server.
    /// Mutable top-level fields: `credentials`, `blocked`, and `metadata`
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request for `DeleteDevice`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteDeviceRequest {
    /// Required. The name of the device. For example,
    /// `projects/p0/locations/us-central1/registries/registry0/devices/device0` or
    /// `projects/p0/locations/us-central1/registries/registry0/devices/{num_id}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for `ListDevices`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDevicesRequest {
    /// Required. The device registry path. Required. For example,
    /// `projects/my-project/locations/us-central1/registries/my-registry`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// A list of device numeric IDs. If empty, this field is ignored. Maximum
    /// IDs: 10,000.
    #[prost(uint64, repeated, tag = "2")]
    pub device_num_ids: ::prost::alloc::vec::Vec<u64>,
    /// A list of device string IDs. For example, `['device0', 'device12']`.
    /// If empty, this field is ignored. Maximum IDs: 10,000
    #[prost(string, repeated, tag = "3")]
    pub device_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The fields of the `Device` resource to be returned in the response. The
    /// fields `id` and `num_id` are always returned, along with any
    /// other fields specified in snake_case format, for example:
    /// `last_heartbeat_time`.
    #[prost(message, optional, tag = "4")]
    pub field_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Options related to gateways.
    #[prost(message, optional, tag = "6")]
    pub gateway_list_options: ::core::option::Option<GatewayListOptions>,
    /// The maximum number of devices to return in the response. If this value
    /// is zero, the service will select a default size. A call may return fewer
    /// objects than requested. A non-empty `next_page_token` in the response
    /// indicates that more data is available.
    #[prost(int32, tag = "100")]
    pub page_size: i32,
    /// The value returned by the last `ListDevicesResponse`; indicates
    /// that this is a continuation of a prior `ListDevices` call and
    /// the system should return the next page of data.
    #[prost(string, tag = "101")]
    pub page_token: ::prost::alloc::string::String,
}
/// Options for limiting the list based on gateway type and associations.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GatewayListOptions {
    /// If not set, all devices and gateways are returned. If set, the list is
    /// filtered based on gateway type and associations.
    #[prost(oneof = "gateway_list_options::Filter", tags = "1, 2, 3")]
    pub filter: ::core::option::Option<gateway_list_options::Filter>,
}
/// Nested message and enum types in `GatewayListOptions`.
pub mod gateway_list_options {
    /// If not set, all devices and gateways are returned. If set, the list is
    /// filtered based on gateway type and associations.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Filter {
        /// If `GATEWAY` is specified, only gateways are returned. If `NON_GATEWAY`
        /// is specified, only non-gateway devices are returned. If
        /// `GATEWAY_TYPE_UNSPECIFIED` is specified, all devices are returned.
        #[prost(enumeration = "super::GatewayType", tag = "1")]
        GatewayType(i32),
        /// If set, only devices associated with the specified gateway are returned.
        /// The gateway ID can be numeric (`num_id`) or the user-defined string
        /// (`id`). For example, if `123` is specified, only devices bound to the
        /// gateway with `num_id` 123 are returned.
        #[prost(string, tag = "2")]
        AssociationsGatewayId(::prost::alloc::string::String),
        /// If set, returns only the gateways with which the specified device is
        /// associated. The device ID can be numeric (`num_id`) or the user-defined
        /// string (`id`). For example, if `456` is specified, returns only the
        /// gateways to which the device with `num_id` 456 is bound.
        #[prost(string, tag = "3")]
        AssociationsDeviceId(::prost::alloc::string::String),
    }
}
/// Response for `ListDevices`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDevicesResponse {
    /// The devices that match the request.
    #[prost(message, repeated, tag = "1")]
    pub devices: ::prost::alloc::vec::Vec<Device>,
    /// If not empty, indicates that there may be more devices that match the
    /// request; this value should be passed in a new `ListDevicesRequest`.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request for `ModifyCloudToDeviceConfig`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ModifyCloudToDeviceConfigRequest {
    /// Required. The name of the device. For example,
    /// `projects/p0/locations/us-central1/registries/registry0/devices/device0` or
    /// `projects/p0/locations/us-central1/registries/registry0/devices/{num_id}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The version number to update. If this value is zero, it will not check the
    /// version number of the server and will always update the current version;
    /// otherwise, this update will fail if the version number found on the server
    /// does not match this version number. This is used to support multiple
    /// simultaneous updates without losing data.
    #[prost(int64, tag = "2")]
    pub version_to_update: i64,
    /// Required. The configuration data for the device.
    #[prost(bytes = "vec", tag = "3")]
    pub binary_data: ::prost::alloc::vec::Vec<u8>,
}
/// Request for `ListDeviceConfigVersions`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDeviceConfigVersionsRequest {
    /// Required. The name of the device. For example,
    /// `projects/p0/locations/us-central1/registries/registry0/devices/device0` or
    /// `projects/p0/locations/us-central1/registries/registry0/devices/{num_id}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The number of versions to list. Versions are listed in decreasing order of
    /// the version number. The maximum number of versions retained is 10. If this
    /// value is zero, it will return all the versions available.
    #[prost(int32, tag = "2")]
    pub num_versions: i32,
}
/// Response for `ListDeviceConfigVersions`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDeviceConfigVersionsResponse {
    /// The device configuration for the last few versions. Versions are listed
    /// in decreasing order, starting from the most recent one.
    #[prost(message, repeated, tag = "1")]
    pub device_configs: ::prost::alloc::vec::Vec<DeviceConfig>,
}
/// Request for `ListDeviceStates`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDeviceStatesRequest {
    /// Required. The name of the device. For example,
    /// `projects/p0/locations/us-central1/registries/registry0/devices/device0` or
    /// `projects/p0/locations/us-central1/registries/registry0/devices/{num_id}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The number of states to list. States are listed in descending order of
    /// update time. The maximum number of states retained is 10. If this
    /// value is zero, it will return all the states available.
    #[prost(int32, tag = "2")]
    pub num_states: i32,
}
/// Response for `ListDeviceStates`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDeviceStatesResponse {
    /// The last few device states. States are listed in descending order of server
    /// update time, starting from the most recent one.
    #[prost(message, repeated, tag = "1")]
    pub device_states: ::prost::alloc::vec::Vec<DeviceState>,
}
/// Request for `SendCommandToDevice`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SendCommandToDeviceRequest {
    /// Required. The name of the device. For example,
    /// `projects/p0/locations/us-central1/registries/registry0/devices/device0` or
    /// `projects/p0/locations/us-central1/registries/registry0/devices/{num_id}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The command data to send to the device.
    #[prost(bytes = "vec", tag = "2")]
    pub binary_data: ::prost::alloc::vec::Vec<u8>,
    /// Optional subfolder for the command. If empty, the command will be delivered
    /// to the /devices/{device-id}/commands topic, otherwise it will be delivered
    /// to the /devices/{device-id}/commands/{subfolder} topic. Multi-level
    /// subfolders are allowed. This field must not have more than 256 characters,
    /// and must not contain any MQTT wildcards ("+" or "#") or null characters.
    #[prost(string, tag = "3")]
    pub subfolder: ::prost::alloc::string::String,
}
/// Response for `SendCommandToDevice`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SendCommandToDeviceResponse {}
/// Request for `BindDeviceToGateway`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BindDeviceToGatewayRequest {
    /// Required. The name of the registry. For example,
    /// `projects/example-project/locations/us-central1/registries/my-registry`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The value of `gateway_id` can be either the device numeric ID or the
    /// user-defined device identifier.
    #[prost(string, tag = "2")]
    pub gateway_id: ::prost::alloc::string::String,
    /// Required. The device to associate with the specified gateway. The value of
    /// `device_id` can be either the device numeric ID or the user-defined device
    /// identifier.
    #[prost(string, tag = "3")]
    pub device_id: ::prost::alloc::string::String,
}
/// Response for `BindDeviceToGateway`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BindDeviceToGatewayResponse {}
/// Request for `UnbindDeviceFromGateway`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UnbindDeviceFromGatewayRequest {
    /// Required. The name of the registry. For example,
    /// `projects/example-project/locations/us-central1/registries/my-registry`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The value of `gateway_id` can be either the device numeric ID or the
    /// user-defined device identifier.
    #[prost(string, tag = "2")]
    pub gateway_id: ::prost::alloc::string::String,
    /// Required. The device to disassociate from the specified gateway. The value of
    /// `device_id` can be either the device numeric ID or the user-defined device
    /// identifier.
    #[prost(string, tag = "3")]
    pub device_id: ::prost::alloc::string::String,
}
/// Response for `UnbindDeviceFromGateway`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UnbindDeviceFromGatewayResponse {}
#[doc = r" Generated client implementations."]
pub mod device_manager_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    #[doc = " Internet of Things (IoT) service. Securely connect and manage IoT devices."]
    #[derive(Debug, Clone)]
    pub struct DeviceManagerClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> DeviceManagerClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::ResponseBody: Body + Send + 'static,
        T::Error: Into<StdError>,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> DeviceManagerClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
                Into<StdError> + Send + Sync,
        {
            DeviceManagerClient::new(InterceptedService::new(inner, interceptor))
        }
        #[doc = r" Compress requests with `gzip`."]
        #[doc = r""]
        #[doc = r" This requires the server to support it otherwise it might respond with an"]
        #[doc = r" error."]
        pub fn send_gzip(mut self) -> Self {
            self.inner = self.inner.send_gzip();
            self
        }
        #[doc = r" Enable decompressing responses with `gzip`."]
        pub fn accept_gzip(mut self) -> Self {
            self.inner = self.inner.accept_gzip();
            self
        }
        #[doc = " Creates a device registry that contains devices."]
        pub async fn create_device_registry(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateDeviceRegistryRequest>,
        ) -> Result<tonic::Response<super::DeviceRegistry>, 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(
                "/google.cloud.iot.v1.DeviceManager/CreateDeviceRegistry",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Gets a device registry configuration."]
        pub async fn get_device_registry(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDeviceRegistryRequest>,
        ) -> Result<tonic::Response<super::DeviceRegistry>, 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(
                "/google.cloud.iot.v1.DeviceManager/GetDeviceRegistry",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Updates a device registry configuration."]
        pub async fn update_device_registry(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateDeviceRegistryRequest>,
        ) -> Result<tonic::Response<super::DeviceRegistry>, 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(
                "/google.cloud.iot.v1.DeviceManager/UpdateDeviceRegistry",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Deletes a device registry configuration."]
        pub async fn delete_device_registry(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteDeviceRegistryRequest>,
        ) -> Result<tonic::Response<()>, 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(
                "/google.cloud.iot.v1.DeviceManager/DeleteDeviceRegistry",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Lists device registries."]
        pub async fn list_device_registries(
            &mut self,
            request: impl tonic::IntoRequest<super::ListDeviceRegistriesRequest>,
        ) -> Result<tonic::Response<super::ListDeviceRegistriesResponse>, 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(
                "/google.cloud.iot.v1.DeviceManager/ListDeviceRegistries",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Creates a device in a device registry."]
        pub async fn create_device(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateDeviceRequest>,
        ) -> Result<tonic::Response<super::Device>, 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(
                "/google.cloud.iot.v1.DeviceManager/CreateDevice",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Gets details about a device."]
        pub async fn get_device(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDeviceRequest>,
        ) -> Result<tonic::Response<super::Device>, 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(
                "/google.cloud.iot.v1.DeviceManager/GetDevice",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Updates a device."]
        pub async fn update_device(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateDeviceRequest>,
        ) -> Result<tonic::Response<super::Device>, 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(
                "/google.cloud.iot.v1.DeviceManager/UpdateDevice",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Deletes a device."]
        pub async fn delete_device(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteDeviceRequest>,
        ) -> Result<tonic::Response<()>, 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(
                "/google.cloud.iot.v1.DeviceManager/DeleteDevice",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " List devices in a device registry."]
        pub async fn list_devices(
            &mut self,
            request: impl tonic::IntoRequest<super::ListDevicesRequest>,
        ) -> Result<tonic::Response<super::ListDevicesResponse>, 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(
                "/google.cloud.iot.v1.DeviceManager/ListDevices",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Modifies the configuration for the device, which is eventually sent from"]
        #[doc = " the Cloud IoT Core servers. Returns the modified configuration version and"]
        #[doc = " its metadata."]
        pub async fn modify_cloud_to_device_config(
            &mut self,
            request: impl tonic::IntoRequest<super::ModifyCloudToDeviceConfigRequest>,
        ) -> Result<tonic::Response<super::DeviceConfig>, 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(
                "/google.cloud.iot.v1.DeviceManager/ModifyCloudToDeviceConfig",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Lists the last few versions of the device configuration in descending"]
        #[doc = " order (i.e.: newest first)."]
        pub async fn list_device_config_versions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListDeviceConfigVersionsRequest>,
        ) -> Result<tonic::Response<super::ListDeviceConfigVersionsResponse>, 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(
                "/google.cloud.iot.v1.DeviceManager/ListDeviceConfigVersions",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Lists the last few versions of the device state in descending order (i.e.:"]
        #[doc = " newest first)."]
        pub async fn list_device_states(
            &mut self,
            request: impl tonic::IntoRequest<super::ListDeviceStatesRequest>,
        ) -> Result<tonic::Response<super::ListDeviceStatesResponse>, 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(
                "/google.cloud.iot.v1.DeviceManager/ListDeviceStates",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Sets the access control policy on the specified resource. Replaces any"]
        #[doc = " existing policy."]
        pub async fn set_iam_policy(
            &mut self,
            request: impl tonic::IntoRequest<super::super::super::super::iam::v1::SetIamPolicyRequest>,
        ) -> Result<tonic::Response<super::super::super::super::iam::v1::Policy>, 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(
                "/google.cloud.iot.v1.DeviceManager/SetIamPolicy",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Gets the access control policy for a resource."]
        #[doc = " Returns an empty policy if the resource exists and does not have a policy"]
        #[doc = " set."]
        pub async fn get_iam_policy(
            &mut self,
            request: impl tonic::IntoRequest<super::super::super::super::iam::v1::GetIamPolicyRequest>,
        ) -> Result<tonic::Response<super::super::super::super::iam::v1::Policy>, 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(
                "/google.cloud.iot.v1.DeviceManager/GetIamPolicy",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Returns permissions that a caller has on the specified resource."]
        #[doc = " If the resource does not exist, this will return an empty set of"]
        #[doc = " permissions, not a NOT_FOUND error."]
        pub async fn test_iam_permissions(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::super::iam::v1::TestIamPermissionsRequest,
            >,
        ) -> Result<
            tonic::Response<super::super::super::super::iam::v1::TestIamPermissionsResponse>,
            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(
                "/google.cloud.iot.v1.DeviceManager/TestIamPermissions",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Sends a command to the specified device. In order for a device to be able"]
        #[doc = " to receive commands, it must:"]
        #[doc = " 1) be connected to Cloud IoT Core using the MQTT protocol, and"]
        #[doc = " 2) be subscribed to the group of MQTT topics specified by"]
        #[doc = "    /devices/{device-id}/commands/#. This subscription will receive commands"]
        #[doc = "    at the top-level topic /devices/{device-id}/commands as well as commands"]
        #[doc = "    for subfolders, like /devices/{device-id}/commands/subfolder."]
        #[doc = "    Note that subscribing to specific subfolders is not supported."]
        #[doc = " If the command could not be delivered to the device, this method will"]
        #[doc = " return an error; in particular, if the device is not subscribed, this"]
        #[doc = " method will return FAILED_PRECONDITION. Otherwise, this method will"]
        #[doc = " return OK. If the subscription is QoS 1, at least once delivery will be"]
        #[doc = " guaranteed; for QoS 0, no acknowledgment will be expected from the device."]
        pub async fn send_command_to_device(
            &mut self,
            request: impl tonic::IntoRequest<super::SendCommandToDeviceRequest>,
        ) -> Result<tonic::Response<super::SendCommandToDeviceResponse>, 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(
                "/google.cloud.iot.v1.DeviceManager/SendCommandToDevice",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Associates the device with the gateway."]
        pub async fn bind_device_to_gateway(
            &mut self,
            request: impl tonic::IntoRequest<super::BindDeviceToGatewayRequest>,
        ) -> Result<tonic::Response<super::BindDeviceToGatewayResponse>, 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(
                "/google.cloud.iot.v1.DeviceManager/BindDeviceToGateway",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Deletes the association between the device and the gateway."]
        pub async fn unbind_device_from_gateway(
            &mut self,
            request: impl tonic::IntoRequest<super::UnbindDeviceFromGatewayRequest>,
        ) -> Result<tonic::Response<super::UnbindDeviceFromGatewayResponse>, 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(
                "/google.cloud.iot.v1.DeviceManager/UnbindDeviceFromGateway",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
    }
}