proto_types/rpc/

google.rpc.rs

// This file is @generated by prost-build.
/// 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"
///        }
///      }
#[derive(Clone, PartialEq, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
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.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
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<crate::protobuf::Duration>,
}
/// Describes additional debugging info.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
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.
#[derive(Clone, PartialEq, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
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.
  #[derive(Clone, PartialEq, ::prost::Message)]
  #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
  #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
  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.
#[derive(Clone, PartialEq, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
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.
  #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
  #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
  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.
#[derive(Clone, PartialEq, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
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.
  #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
  #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
  #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
  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.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
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.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
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.
#[derive(Clone, PartialEq, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
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.
  #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
  #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
  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.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
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,
}
/// Represents an HTTP request.
#[derive(Clone, PartialEq, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct HttpRequest {
  /// The HTTP request method.
  #[prost(string, tag = "1")]
  pub method: ::prost::alloc::string::String,
  /// The HTTP request URI.
  #[prost(string, tag = "2")]
  pub uri: ::prost::alloc::string::String,
  /// The HTTP request headers. The ordering of the headers is significant.
  /// Multiple headers with the same key may present for the request.
  #[prost(message, repeated, tag = "3")]
  pub headers: ::prost::alloc::vec::Vec<HttpHeader>,
  /// The HTTP request body. If the body is not expected, it should be empty.
  #[prost(bytes = "bytes", tag = "4")]
  pub body: ::prost::bytes::Bytes,
}

/// Represents an HTTP response.
#[derive(Clone, PartialEq, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct HttpResponse {
  /// The HTTP status code, such as 200 or 404.
  #[prost(int32, tag = "1")]
  pub status: i32,
  /// The HTTP reason phrase, such as "OK" or "Not Found".
  #[prost(string, tag = "2")]
  pub reason: ::prost::alloc::string::String,
  /// The HTTP response headers. The ordering of the headers is significant.
  /// Multiple headers with the same key may present for the response.
  #[prost(message, repeated, tag = "3")]
  pub headers: ::prost::alloc::vec::Vec<HttpHeader>,
  /// The HTTP response body. If the body is not expected, it should be empty.
  #[prost(bytes = "bytes", tag = "4")]
  pub body: ::prost::bytes::Bytes,
}

/// Represents an HTTP header.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct HttpHeader {
  /// The HTTP header key. It is case insensitive.
  #[prost(string, tag = "1")]
  pub key: ::prost::alloc::string::String,
  /// The HTTP header value.
  #[prost(string, tag = "2")]
  pub value: ::prost::alloc::string::String,
}

/// 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 {
      Self::Ok => "OK",
      Self::Cancelled => "CANCELLED",
      Self::Unknown => "UNKNOWN",
      Self::InvalidArgument => "INVALID_ARGUMENT",
      Self::DeadlineExceeded => "DEADLINE_EXCEEDED",
      Self::NotFound => "NOT_FOUND",
      Self::AlreadyExists => "ALREADY_EXISTS",
      Self::PermissionDenied => "PERMISSION_DENIED",
      Self::Unauthenticated => "UNAUTHENTICATED",
      Self::ResourceExhausted => "RESOURCE_EXHAUSTED",
      Self::FailedPrecondition => "FAILED_PRECONDITION",
      Self::Aborted => "ABORTED",
      Self::OutOfRange => "OUT_OF_RANGE",
      Self::Unimplemented => "UNIMPLEMENTED",
      Self::Internal => "INTERNAL",
      Self::Unavailable => "UNAVAILABLE",
      Self::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,
    }
  }
}
/// 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>).
#[derive(Clone, PartialEq, ::prost::Message)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
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<crate::protobuf::Any>,
}