/// 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\](). 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](). #[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<::prost_types::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 whitelist, /// `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 /// (e.g., 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. E.g., 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, } /// 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, 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<::prost_types::Duration>, } /// Describes additional debugging info. #[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. #[derive(Clone, PartialEq, ::prost::Message)] pub struct QuotaFailure { /// Describes all quota violations. #[prost(message, repeated, tag = "1")] pub violations: ::prost::alloc::vec::Vec, } /// 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)] pub struct Violation { /// The subject on which the quota check failed. /// For example, "clientip:" or "project:". #[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, } } /// 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)] 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-Z0-9_\]+/. #[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 should match /\[a-zA-Z0-9-_\]/ and 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 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)] pub struct PreconditionFailure { /// Describes all precondition violations. #[prost(message, repeated, tag = "1")] pub violations: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `PreconditionFailure`. pub mod precondition_failure { /// A message type used to describe a single precondition failure. #[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. #[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, } /// 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, ::prost::Message)] pub struct FieldViolation { /// A path leading to a field in the request body. The value will be a /// sequence of dot-separated identifiers that identify a protocol buffer /// field. E.g., "field_violations.field" would identify this field. #[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, } } /// Contains metadata about the request that clients can attach when filing a bug /// or providing other forms of feedback. #[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. #[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:" or "project:". #[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)] 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, } /// Nested message and enum types in `Help`. pub mod help { /// Describes a URL link. #[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. #[derive(Clone, PartialEq, ::prost::Message)] pub struct LocalizedMessage { /// The locale used following the specification defined at /// /// 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, }