chore: add generated rpc code

1 files changed, 604 insertions, 0 deletions

diff --git a/src/rpc/google.rpc.rs b/src/rpc/google.rpc.rs
new file mode 100644
index 00000000..3def3d13
--- /dev/null
+++ b/src/rpc/google.rpc.rs
@@ -0,0 +1,604 @@
+// @generated
+// This file is @generated by prost-build.
+/// The `Status` type defines a logical error model that is suitable for
+/// different programming environments, including REST APIs and RPC APIs. It is
+/// used by [gRPC](<https://github.com/grpc>). Each `Status` message contains
+/// three pieces of data: error code, error message, and error details.
+///
+/// You can find out more about this error model and how to work with it in the
+/// [API Design Guide](<https://cloud.google.com/apis/design/errors>).
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Status {
+    /// The status code, which should be an enum value of
+    /// [google.rpc.Code][google.rpc.Code].
+    #[prost(int32, tag="1")]
+    pub code: i32,
+    /// A developer-facing error message, which should be in English. Any
+    /// user-facing error message should be localized and sent in the
+    /// [google.rpc.Status.details][google.rpc.Status.details] field, or localized
+    /// by the client.
+    #[prost(string, tag="2")]
+    pub message: ::prost::alloc::string::String,
+    /// A list of messages that carry the error details.  There is a common set of
+    /// message types for APIs to use.
+    #[prost(message, repeated, tag="3")]
+    pub details: ::prost::alloc::vec::Vec<super::protobuf::Any>,
+}
+/// The canonical error codes for gRPC APIs.
+///
+///
+/// Sometimes multiple error codes may apply.  Services should return
+/// the most specific error code that applies.  For example, prefer
+/// `OUT_OF_RANGE` over `FAILED_PRECONDITION` if both codes apply.
+/// Similarly prefer `NOT_FOUND` or `ALREADY_EXISTS` over `FAILED_PRECONDITION`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum Code {
+    /// Not an error; returned on success.
+    ///
+    /// HTTP Mapping: 200 OK
+    Ok = 0,
+    /// The operation was cancelled, typically by the caller.
+    ///
+    /// HTTP Mapping: 499 Client Closed Request
+    Cancelled = 1,
+    /// Unknown error.  For example, this error may be returned when
+    /// a `Status` value received from another address space belongs to
+    /// an error space that is not known in this address space.  Also
+    /// errors raised by APIs that do not return enough error information
+    /// may be converted to this error.
+    ///
+    /// HTTP Mapping: 500 Internal Server Error
+    Unknown = 2,
+    /// The client specified an invalid argument.  Note that this differs
+    /// from `FAILED_PRECONDITION`.  `INVALID_ARGUMENT` indicates arguments
+    /// that are problematic regardless of the state of the system
+    /// (e.g., a malformed file name).
+    ///
+    /// HTTP Mapping: 400 Bad Request
+    InvalidArgument = 3,
+    /// The deadline expired before the operation could complete. For operations
+    /// that change the state of the system, this error may be returned
+    /// even if the operation has completed successfully.  For example, a
+    /// successful response from a server could have been delayed long
+    /// enough for the deadline to expire.
+    ///
+    /// HTTP Mapping: 504 Gateway Timeout
+    DeadlineExceeded = 4,
+    /// Some requested entity (e.g., file or directory) was not found.
+    ///
+    /// Note to server developers: if a request is denied for an entire class
+    /// of users, such as gradual feature rollout or undocumented allowlist,
+    /// `NOT_FOUND` may be used. If a request is denied for some users within
+    /// a class of users, such as user-based access control, `PERMISSION_DENIED`
+    /// must be used.
+    ///
+    /// HTTP Mapping: 404 Not Found
+    NotFound = 5,
+    /// The entity that a client attempted to create (e.g., file or directory)
+    /// already exists.
+    ///
+    /// HTTP Mapping: 409 Conflict
+    AlreadyExists = 6,
+    /// The caller does not have permission to execute the specified
+    /// operation. `PERMISSION_DENIED` must not be used for rejections
+    /// caused by exhausting some resource (use `RESOURCE_EXHAUSTED`
+    /// instead for those errors). `PERMISSION_DENIED` must not be
+    /// used if the caller can not be identified (use `UNAUTHENTICATED`
+    /// instead for those errors). This error code does not imply the
+    /// request is valid or the requested entity exists or satisfies
+    /// other pre-conditions.
+    ///
+    /// HTTP Mapping: 403 Forbidden
+    PermissionDenied = 7,
+    /// The request does not have valid authentication credentials for the
+    /// operation.
+    ///
+    /// HTTP Mapping: 401 Unauthorized
+    Unauthenticated = 16,
+    /// Some resource has been exhausted, perhaps a per-user quota, or
+    /// perhaps the entire file system is out of space.
+    ///
+    /// HTTP Mapping: 429 Too Many Requests
+    ResourceExhausted = 8,
+    /// The operation was rejected because the system is not in a state
+    /// required for the operation's execution.  For example, the directory
+    /// to be deleted is non-empty, an rmdir operation is applied to
+    /// a non-directory, etc.
+    ///
+    /// Service implementors can use the following guidelines to decide
+    /// between `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`:
+    ///   (a) Use `UNAVAILABLE` if the client can retry just the failing call.
+    ///   (b) Use `ABORTED` if the client should retry at a higher level. For
+    ///       example, when a client-specified test-and-set fails, indicating the
+    ///       client should restart a read-modify-write sequence.
+    ///   (c) Use `FAILED_PRECONDITION` if the client should not retry until
+    ///       the system state has been explicitly fixed. For example, if an "rmdir"
+    ///       fails because the directory is non-empty, `FAILED_PRECONDITION`
+    ///       should be returned since the client should not retry unless
+    ///       the files are deleted from the directory.
+    ///
+    /// HTTP Mapping: 400 Bad Request
+    FailedPrecondition = 9,
+    /// The operation was aborted, typically due to a concurrency issue such as
+    /// a sequencer check failure or transaction abort.
+    ///
+    /// See the guidelines above for deciding between `FAILED_PRECONDITION`,
+    /// `ABORTED`, and `UNAVAILABLE`.
+    ///
+    /// HTTP Mapping: 409 Conflict
+    Aborted = 10,
+    /// The operation was attempted past the valid range.  E.g., seeking or
+    /// reading past end-of-file.
+    ///
+    /// Unlike `INVALID_ARGUMENT`, this error indicates a problem that may
+    /// be fixed if the system state changes. For example, a 32-bit file
+    /// system will generate `INVALID_ARGUMENT` if asked to read at an
+    /// offset that is not in the range \[0,2^32-1\], but it will generate
+    /// `OUT_OF_RANGE` if asked to read from an offset past the current
+    /// file size.
+    ///
+    /// There is a fair bit of overlap between `FAILED_PRECONDITION` and
+    /// `OUT_OF_RANGE`.  We recommend using `OUT_OF_RANGE` (the more specific
+    /// error) when it applies so that callers who are iterating through
+    /// a space can easily look for an `OUT_OF_RANGE` error to detect when
+    /// they are done.
+    ///
+    /// HTTP Mapping: 400 Bad Request
+    OutOfRange = 11,
+    /// The operation is not implemented or is not supported/enabled in this
+    /// service.
+    ///
+    /// HTTP Mapping: 501 Not Implemented
+    Unimplemented = 12,
+    /// Internal errors.  This means that some invariants expected by the
+    /// underlying system have been broken.  This error code is reserved
+    /// for serious errors.
+    ///
+    /// HTTP Mapping: 500 Internal Server Error
+    Internal = 13,
+    /// The service is currently unavailable.  This is most likely a
+    /// transient condition, which can be corrected by retrying with
+    /// a backoff. Note that it is not always safe to retry
+    /// non-idempotent operations.
+    ///
+    /// See the guidelines above for deciding between `FAILED_PRECONDITION`,
+    /// `ABORTED`, and `UNAVAILABLE`.
+    ///
+    /// HTTP Mapping: 503 Service Unavailable
+    Unavailable = 14,
+    /// Unrecoverable data loss or corruption.
+    ///
+    /// HTTP Mapping: 500 Internal Server Error
+    DataLoss = 15,
+}
+impl Code {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            Code::Ok => "OK",
+            Code::Cancelled => "CANCELLED",
+            Code::Unknown => "UNKNOWN",
+            Code::InvalidArgument => "INVALID_ARGUMENT",
+            Code::DeadlineExceeded => "DEADLINE_EXCEEDED",
+            Code::NotFound => "NOT_FOUND",
+            Code::AlreadyExists => "ALREADY_EXISTS",
+            Code::PermissionDenied => "PERMISSION_DENIED",
+            Code::Unauthenticated => "UNAUTHENTICATED",
+            Code::ResourceExhausted => "RESOURCE_EXHAUSTED",
+            Code::FailedPrecondition => "FAILED_PRECONDITION",
+            Code::Aborted => "ABORTED",
+            Code::OutOfRange => "OUT_OF_RANGE",
+            Code::Unimplemented => "UNIMPLEMENTED",
+            Code::Internal => "INTERNAL",
+            Code::Unavailable => "UNAVAILABLE",
+            Code::DataLoss => "DATA_LOSS",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "OK" => Some(Self::Ok),
+            "CANCELLED" => Some(Self::Cancelled),
+            "UNKNOWN" => Some(Self::Unknown),
+            "INVALID_ARGUMENT" => Some(Self::InvalidArgument),
+            "DEADLINE_EXCEEDED" => Some(Self::DeadlineExceeded),
+            "NOT_FOUND" => Some(Self::NotFound),
+            "ALREADY_EXISTS" => Some(Self::AlreadyExists),
+            "PERMISSION_DENIED" => Some(Self::PermissionDenied),
+            "UNAUTHENTICATED" => Some(Self::Unauthenticated),
+            "RESOURCE_EXHAUSTED" => Some(Self::ResourceExhausted),
+            "FAILED_PRECONDITION" => Some(Self::FailedPrecondition),
+            "ABORTED" => Some(Self::Aborted),
+            "OUT_OF_RANGE" => Some(Self::OutOfRange),
+            "UNIMPLEMENTED" => Some(Self::Unimplemented),
+            "INTERNAL" => Some(Self::Internal),
+            "UNAVAILABLE" => Some(Self::Unavailable),
+            "DATA_LOSS" => Some(Self::DataLoss),
+            _ => None,
+        }
+    }
+}
+/// Describes the cause of the error with structured details.
+///
+/// Example of an error when contacting the "pubsub.googleapis.com" API when it
+/// is not enabled:
+///
+///      { "reason": "API_DISABLED"
+///        "domain": "googleapis.com"
+///        "metadata": {
+///          "resource": "projects/123",
+///          "service": "pubsub.googleapis.com"
+///        }
+///      }
+///
+/// This response indicates that the pubsub.googleapis.com API is not enabled.
+///
+/// Example of an error that is returned when attempting to create a Spanner
+/// instance in a region that is out of stock:
+///
+///      { "reason": "STOCKOUT"
+///        "domain": "spanner.googleapis.com",
+///        "metadata": {
+///          "availableRegions": "us-central1,us-east2"
+///        }
+///      }
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ErrorInfo {
+    /// The reason of the error. This is a constant value that identifies the
+    /// proximate cause of the error. Error reasons are unique within a particular
+    /// domain of errors. This should be at most 63 characters and match a
+    /// regular expression of `[A-Z][A-Z0-9_]+\[A-Z0-9\]`, which represents
+    /// UPPER_SNAKE_CASE.
+    #[prost(string, tag="1")]
+    pub reason: ::prost::alloc::string::String,
+    /// The logical grouping to which the "reason" belongs. The error domain
+    /// is typically the registered service name of the tool or product that
+    /// generates the error. Example: "pubsub.googleapis.com". If the error is
+    /// generated by some common infrastructure, the error domain must be a
+    /// globally unique value that identifies the infrastructure. For Google API
+    /// infrastructure, the error domain is "googleapis.com".
+    #[prost(string, tag="2")]
+    pub domain: ::prost::alloc::string::String,
+    /// Additional structured details about this error.
+    ///
+    /// Keys must match a regular expression of `[a-z][a-zA-Z0-9-_]+` but should
+    /// ideally be lowerCamelCase. Also, they must be limited to 64 characters in
+    /// length. When identifying the current value of an exceeded limit, the units
+    /// should be contained in the key, not the value.  For example, rather than
+    /// `{"instanceLimit": "100/request"}`, should be returned as,
+    /// `{"instanceLimitPerRequest": "100"}`, if the client exceeds the number of
+    /// instances that can be created in a single (batch) request.
+    #[prost(map="string, string", tag="3")]
+    pub metadata: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
+}
+/// Describes when the clients can retry a failed request. Clients could ignore
+/// the recommendation here or retry when this information is missing from error
+/// responses.
+///
+/// It's always recommended that clients should use exponential backoff when
+/// retrying.
+///
+/// Clients should wait until `retry_delay` amount of time has passed since
+/// receiving the error response before retrying.  If retrying requests also
+/// fail, clients should use an exponential backoff scheme to gradually increase
+/// the delay between retries based on `retry_delay`, until either a maximum
+/// number of retries have been reached or a maximum retry delay cap has been
+/// reached.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct RetryInfo {
+    /// Clients should wait at least this long between retrying the same request.
+    #[prost(message, optional, tag="1")]
+    pub retry_delay: ::core::option::Option<super::protobuf::Duration>,
+}
+/// Describes additional debugging info.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DebugInfo {
+    /// The stack trace entries indicating where the error occurred.
+    #[prost(string, repeated, tag="1")]
+    pub stack_entries: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    /// Additional debugging information provided by the server.
+    #[prost(string, tag="2")]
+    pub detail: ::prost::alloc::string::String,
+}
+/// Describes how a quota check failed.
+///
+/// For example if a daily limit was exceeded for the calling project,
+/// a service could respond with a QuotaFailure detail containing the project
+/// id and the description of the quota limit that was exceeded.  If the
+/// calling project hasn't enabled the service in the developer console, then
+/// a service could respond with the project id and set `service_disabled`
+/// to true.
+///
+/// Also see RetryInfo and Help types for other details about handling a
+/// quota failure.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QuotaFailure {
+    /// Describes all quota violations.
+    #[prost(message, repeated, tag="1")]
+    pub violations: ::prost::alloc::vec::Vec<quota_failure::Violation>,
+}
+/// Nested message and enum types in `QuotaFailure`.
+pub mod quota_failure {
+    /// A message type used to describe a single quota violation.  For example, a
+    /// daily quota or a custom quota that was exceeded.
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct Violation {
+        /// The subject on which the quota check failed.
+        /// For example, "clientip:<ip address of client>" or "project:<Google
+        /// developer project id>".
+        #[prost(string, tag="1")]
+        pub subject: ::prost::alloc::string::String,
+        /// A description of how the quota check failed. Clients can use this
+        /// description to find more about the quota configuration in the service's
+        /// public documentation, or find the relevant quota limit to adjust through
+        /// developer console.
+        ///
+        /// For example: "Service disabled" or "Daily Limit for read operations
+        /// exceeded".
+        #[prost(string, tag="2")]
+        pub description: ::prost::alloc::string::String,
+        /// The API Service from which the `QuotaFailure.Violation` orginates. In
+        /// some cases, Quota issues originate from an API Service other than the one
+        /// that was called. In other words, a dependency of the called API Service
+        /// could be the cause of the `QuotaFailure`, and this field would have the
+        /// dependency API service name.
+        ///
+        /// For example, if the called API is Kubernetes Engine API
+        /// (container.googleapis.com), and a quota violation occurs in the
+        /// Kubernetes Engine API itself, this field would be
+        /// "container.googleapis.com". On the other hand, if the quota violation
+        /// occurs when the Kubernetes Engine API creates VMs in the Compute Engine
+        /// API (compute.googleapis.com), this field would be
+        /// "compute.googleapis.com".
+        #[prost(string, tag="3")]
+        pub api_service: ::prost::alloc::string::String,
+        /// The metric of the violated quota. A quota metric is a named counter to
+        /// measure usage, such as API requests or CPUs. When an activity occurs in a
+        /// service, such as Virtual Machine allocation, one or more quota metrics
+        /// may be affected.
+        ///
+        /// For example, "compute.googleapis.com/cpus_per_vm_family",
+        /// "storage.googleapis.com/internet_egress_bandwidth".
+        #[prost(string, tag="4")]
+        pub quota_metric: ::prost::alloc::string::String,
+        /// The id of the violated quota. Also know as "limit name", this is the
+        /// unique identifier of a quota in the context of an API service.
+        ///
+        /// For example, "CPUS-PER-VM-FAMILY-per-project-region".
+        #[prost(string, tag="5")]
+        pub quota_id: ::prost::alloc::string::String,
+        /// The dimensions of the violated quota. Every non-global quota is enforced
+        /// on a set of dimensions. While quota metric defines what to count, the
+        /// dimensions specify for what aspects the counter should be increased.
+        ///
+        /// For example, the quota "CPUs per region per VM family" enforces a limit
+        /// on the metric "compute.googleapis.com/cpus_per_vm_family" on dimensions
+        /// "region" and "vm_family". And if the violation occurred in region
+        /// "us-central1" and for VM family "n1", the quota_dimensions would be,
+        ///
+        /// {
+        ///    "region": "us-central1",
+        ///    "vm_family": "n1",
+        /// }
+        ///
+        /// When a quota is enforced globally, the quota_dimensions would always be
+        /// empty.
+        #[prost(map="string, string", tag="6")]
+        pub quota_dimensions: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
+        /// The enforced quota value at the time of the `QuotaFailure`.
+        ///
+        /// For example, if the enforced quota value at the time of the
+        /// `QuotaFailure` on the number of CPUs is "10", then the value of this
+        /// field would reflect this quantity.
+        #[prost(int64, tag="7")]
+        pub quota_value: i64,
+        /// The new quota value being rolled out at the time of the violation. At the
+        /// completion of the rollout, this value will be enforced in place of
+        /// quota_value. If no rollout is in progress at the time of the violation,
+        /// this field is not set.
+        ///
+        /// For example, if at the time of the violation a rollout is in progress
+        /// changing the number of CPUs quota from 10 to 20, 20 would be the value of
+        /// this field.
+        #[prost(int64, optional, tag="8")]
+        pub future_quota_value: ::core::option::Option<i64>,
+    }
+}
+/// Describes what preconditions have failed.
+///
+/// For example, if an RPC failed because it required the Terms of Service to be
+/// acknowledged, it could list the terms of service violation in the
+/// PreconditionFailure message.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PreconditionFailure {
+    /// Describes all precondition violations.
+    #[prost(message, repeated, tag="1")]
+    pub violations: ::prost::alloc::vec::Vec<precondition_failure::Violation>,
+}
+/// Nested message and enum types in `PreconditionFailure`.
+pub mod precondition_failure {
+    /// A message type used to describe a single precondition failure.
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct Violation {
+        /// The type of PreconditionFailure. We recommend using a service-specific
+        /// enum type to define the supported precondition violation subjects. For
+        /// example, "TOS" for "Terms of Service violation".
+        #[prost(string, tag="1")]
+        pub r#type: ::prost::alloc::string::String,
+        /// The subject, relative to the type, that failed.
+        /// For example, "google.com/cloud" relative to the "TOS" type would indicate
+        /// which terms of service is being referenced.
+        #[prost(string, tag="2")]
+        pub subject: ::prost::alloc::string::String,
+        /// A description of how the precondition failed. Developers can use this
+        /// description to understand how to fix the failure.
+        ///
+        /// For example: "Terms of service not accepted".
+        #[prost(string, tag="3")]
+        pub description: ::prost::alloc::string::String,
+    }
+}
+/// Describes violations in a client request. This error type focuses on the
+/// syntactic aspects of the request.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct BadRequest {
+    /// Describes all violations in a client request.
+    #[prost(message, repeated, tag="1")]
+    pub field_violations: ::prost::alloc::vec::Vec<bad_request::FieldViolation>,
+}
+/// Nested message and enum types in `BadRequest`.
+pub mod bad_request {
+    /// A message type used to describe a single bad request field.
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct FieldViolation {
+        /// A path that leads to a field in the request body. The value will be a
+        /// sequence of dot-separated identifiers that identify a protocol buffer
+        /// field.
+        ///
+        /// Consider the following:
+        ///
+        ///      message CreateContactRequest {
+        ///        message EmailAddress {
+        ///          enum Type {
+        ///            TYPE_UNSPECIFIED = 0;
+        ///            HOME = 1;
+        ///            WORK = 2;
+        ///          }
+        ///
+        ///          optional string email = 1;
+        ///          repeated EmailType type = 2;
+        ///        }
+        ///
+        ///        string full_name = 1;
+        ///        repeated EmailAddress email_addresses = 2;
+        ///      }
+        ///
+        /// In this example, in proto `field` could take one of the following values:
+        ///
+        /// * `full_name` for a violation in the `full_name` value
+        /// * `email_addresses\[1\].email` for a violation in the `email` field of the
+        ///    first `email_addresses` message
+        /// * `email_addresses\[3\].type\[2\]` for a violation in the second `type`
+        ///    value in the third `email_addresses` message.
+        ///
+        /// In JSON, the same values are represented as:
+        ///
+        /// * `fullName` for a violation in the `fullName` value
+        /// * `emailAddresses\[1\].email` for a violation in the `email` field of the
+        ///    first `emailAddresses` message
+        /// * `emailAddresses\[3\].type\[2\]` for a violation in the second `type`
+        ///    value in the third `emailAddresses` message.
+        #[prost(string, tag="1")]
+        pub field: ::prost::alloc::string::String,
+        /// A description of why the request element is bad.
+        #[prost(string, tag="2")]
+        pub description: ::prost::alloc::string::String,
+        /// The reason of the field-level error. This is a constant value that
+        /// identifies the proximate cause of the field-level error. It should
+        /// uniquely identify the type of the FieldViolation within the scope of the
+        /// google.rpc.ErrorInfo.domain. This should be at most 63
+        /// characters and match a regular expression of `[A-Z][A-Z0-9_]+\[A-Z0-9\]`,
+        /// which represents UPPER_SNAKE_CASE.
+        #[prost(string, tag="3")]
+        pub reason: ::prost::alloc::string::String,
+        /// Provides a localized error message for field-level errors that is safe to
+        /// return to the API consumer.
+        #[prost(message, optional, tag="4")]
+        pub localized_message: ::core::option::Option<super::LocalizedMessage>,
+    }
+}
+/// Contains metadata about the request that clients can attach when filing a bug
+/// or providing other forms of feedback.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RequestInfo {
+    /// An opaque string that should only be interpreted by the service generating
+    /// it. For example, it can be used to identify requests in the service's logs.
+    #[prost(string, tag="1")]
+    pub request_id: ::prost::alloc::string::String,
+    /// Any data that was used to serve this request. For example, an encrypted
+    /// stack trace that can be sent back to the service provider for debugging.
+    #[prost(string, tag="2")]
+    pub serving_data: ::prost::alloc::string::String,
+}
+/// Describes the resource that is being accessed.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ResourceInfo {
+    /// A name for the type of resource being accessed, e.g. "sql table",
+    /// "cloud storage bucket", "file", "Google calendar"; or the type URL
+    /// of the resource: e.g. "type.googleapis.com/google.pubsub.v1.Topic".
+    #[prost(string, tag="1")]
+    pub resource_type: ::prost::alloc::string::String,
+    /// The name of the resource being accessed.  For example, a shared calendar
+    /// name: "example.com_4fghdhgsrgh@group.calendar.google.com", if the current
+    /// error is
+    /// [google.rpc.Code.PERMISSION_DENIED][google.rpc.Code.PERMISSION_DENIED].
+    #[prost(string, tag="2")]
+    pub resource_name: ::prost::alloc::string::String,
+    /// The owner of the resource (optional).
+    /// For example, "user:<owner email>" or "project:<Google developer project
+    /// id>".
+    #[prost(string, tag="3")]
+    pub owner: ::prost::alloc::string::String,
+    /// Describes what error is encountered when accessing this resource.
+    /// For example, updating a cloud project may require the `writer` permission
+    /// on the developer console project.
+    #[prost(string, tag="4")]
+    pub description: ::prost::alloc::string::String,
+}
+/// Provides links to documentation or for performing an out of band action.
+///
+/// For example, if a quota check failed with an error indicating the calling
+/// project hasn't enabled the accessed service, this can contain a URL pointing
+/// directly to the right place in the developer console to flip the bit.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Help {
+    /// URL(s) pointing to additional information on handling the current error.
+    #[prost(message, repeated, tag="1")]
+    pub links: ::prost::alloc::vec::Vec<help::Link>,
+}
+/// Nested message and enum types in `Help`.
+pub mod help {
+    /// Describes a URL link.
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct Link {
+        /// Describes what the link offers.
+        #[prost(string, tag="1")]
+        pub description: ::prost::alloc::string::String,
+        /// The URL of the link.
+        #[prost(string, tag="2")]
+        pub url: ::prost::alloc::string::String,
+    }
+}
+/// Provides a localized error message that is safe to return to the user
+/// which can be attached to an RPC error.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LocalizedMessage {
+    /// The locale used following the specification defined at
+    /// <https://www.rfc-editor.org/rfc/bcp/bcp47.txt.>
+    /// Examples are: "en-US", "fr-CH", "es-MX"
+    #[prost(string, tag="1")]
+    pub locale: ::prost::alloc::string::String,
+    /// The localized error message in the above locale.
+    #[prost(string, tag="2")]
+    pub message: ::prost::alloc::string::String,
+}
+// @@protoc_insertion_point(module)