grpc-swift/Tests/GRPCCoreTests/Configuration/Generated/code.pb.swift

// DO NOT EDIT.
// swift-format-ignore-file
//
// Generated by the Swift generator plugin for the protocol buffer compiler.
// Source: google/rpc/code.proto
//
// For information on using the generated types, please see the documentation:
//   https://github.com/apple/swift-protobuf/

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

import Foundation
import SwiftProtobuf

// If the compiler emits an error on this type, it is because this file
// was generated by a version of the `protoc` Swift plug-in that is
// incompatible with the version of SwiftProtobuf to which you are linking.
// Please ensure that you are building against the same version of the API
// that was used to generate this file.
fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
  struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
  typealias Version = _2
}

/// 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`.
enum Google_Rpc_Code: SwiftProtobuf.Enum {
  typealias RawValue = Int

  /// Not an error; returned on success.
  ///
  /// HTTP Mapping: 200 OK
  case ok // = 0

  /// The operation was cancelled, typically by the caller.
  ///
  /// HTTP Mapping: 499 Client Closed Request
  case 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
  case 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
  case 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
  case 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
  case notFound // = 5

  /// The entity that a client attempted to create (e.g., file or directory)
  /// already exists.
  ///
  /// HTTP Mapping: 409 Conflict
  case 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
  case permissionDenied // = 7

  /// The request does not have valid authentication credentials for the
  /// operation.
  ///
  /// HTTP Mapping: 401 Unauthorized
  case 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
  case 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
  case 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
  case 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
  case outOfRange // = 11

  /// The operation is not implemented or is not supported/enabled in this
  /// service.
  ///
  /// HTTP Mapping: 501 Not Implemented
  case 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
  case `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
  case unavailable // = 14

  /// Unrecoverable data loss or corruption.
  ///
  /// HTTP Mapping: 500 Internal Server Error
  case dataLoss // = 15
  case UNRECOGNIZED(Int)

  init() {
    self = .ok
  }

  init?(rawValue: Int) {
    switch rawValue {
    case 0: self = .ok
    case 1: self = .cancelled
    case 2: self = .unknown
    case 3: self = .invalidArgument
    case 4: self = .deadlineExceeded
    case 5: self = .notFound
    case 6: self = .alreadyExists
    case 7: self = .permissionDenied
    case 8: self = .resourceExhausted
    case 9: self = .failedPrecondition
    case 10: self = .aborted
    case 11: self = .outOfRange
    case 12: self = .unimplemented
    case 13: self = .internal
    case 14: self = .unavailable
    case 15: self = .dataLoss
    case 16: self = .unauthenticated
    default: self = .UNRECOGNIZED(rawValue)
    }
  }

  var rawValue: Int {
    switch self {
    case .ok: return 0
    case .cancelled: return 1
    case .unknown: return 2
    case .invalidArgument: return 3
    case .deadlineExceeded: return 4
    case .notFound: return 5
    case .alreadyExists: return 6
    case .permissionDenied: return 7
    case .resourceExhausted: return 8
    case .failedPrecondition: return 9
    case .aborted: return 10
    case .outOfRange: return 11
    case .unimplemented: return 12
    case .internal: return 13
    case .unavailable: return 14
    case .dataLoss: return 15
    case .unauthenticated: return 16
    case .UNRECOGNIZED(let i): return i
    }
  }

}

#if swift(>=4.2)

extension Google_Rpc_Code: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static let allCases: [Google_Rpc_Code] = [
    .ok,
    .cancelled,
    .unknown,
    .invalidArgument,
    .deadlineExceeded,
    .notFound,
    .alreadyExists,
    .permissionDenied,
    .unauthenticated,
    .resourceExhausted,
    .failedPrecondition,
    .aborted,
    .outOfRange,
    .unimplemented,
    .internal,
    .unavailable,
    .dataLoss,
  ]
}

#endif  // swift(>=4.2)

#if swift(>=5.5) && canImport(_Concurrency)
extension Google_Rpc_Code: @unchecked Sendable {}
#endif  // swift(>=5.5) && canImport(_Concurrency)

// MARK: - Code below here is support for the SwiftProtobuf runtime.

extension Google_Rpc_Code: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "OK"),
    1: .same(proto: "CANCELLED"),
    2: .same(proto: "UNKNOWN"),
    3: .same(proto: "INVALID_ARGUMENT"),
    4: .same(proto: "DEADLINE_EXCEEDED"),
    5: .same(proto: "NOT_FOUND"),
    6: .same(proto: "ALREADY_EXISTS"),
    7: .same(proto: "PERMISSION_DENIED"),
    8: .same(proto: "RESOURCE_EXHAUSTED"),
    9: .same(proto: "FAILED_PRECONDITION"),
    10: .same(proto: "ABORTED"),
    11: .same(proto: "OUT_OF_RANGE"),
    12: .same(proto: "UNIMPLEMENTED"),
    13: .same(proto: "INTERNAL"),
    14: .same(proto: "UNAVAILABLE"),
    15: .same(proto: "DATA_LOSS"),
    16: .same(proto: "UNAUTHENTICATED"),
  ]
}