#![allow(clippy::all)]
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Condition {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub r#type: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<ConditionStatus>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "observedGeneration"
)]
pub observed_generation: i64,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub reason: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub message: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub severity: Option<Severity>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "transitionTime"
)]
pub transition_time: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct EntitlementDenial {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub meter: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64"
)]
pub limit: i64,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub plan: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "upgradeUrl"
)]
pub upgrade_url: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Operation {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub target: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "targetGeneration"
)]
pub target_generation: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub verb: Option<OperationVerb>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "customVerb"
)]
pub custom_verb: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub done: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "createTime"
)]
pub create_time: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "endTime"
)]
pub end_time: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub response: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<ProblemDetails>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub progress: Option<OperationProgress>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct OperationProgress {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub percent: Option<i32>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub message: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub conditions: Vec<Condition>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct PreconditionFailure {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "currentEtag"
)]
pub current_etag: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ProblemDetails {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub r#type: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub title: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub status: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub detail: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub instance: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub code: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "grpcStatus"
)]
pub grpc_status: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub retryable: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub effect: Option<ErrorEffect>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
with = "crate::runtime::opt_int64",
alias = "retryAfterMs"
)]
pub retry_after_ms: Option<i64>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub details: Vec<serde_json::Value>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ResourceMeta {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64"
)]
pub generation: i64,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "createTime"
)]
pub create_time: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "updateTime"
)]
pub update_time: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "deleteTime"
)]
pub delete_time: String,
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
pub labels: std::collections::BTreeMap<String, String>,
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
pub annotations: std::collections::BTreeMap<String, String>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "displayName"
)]
pub display_name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub creator: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ConditionStatus {
True,
False,
UnknownValue,
Unknown(String),
}
impl ConditionStatus {
pub fn as_str(&self) -> &str {
match self {
Self::True => "true",
Self::False => "false",
Self::UnknownValue => "unknown",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"true" => Self::True,
"false" => Self::False,
"unknown" => Self::UnknownValue,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for ConditionStatus {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for ConditionStatus {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for ConditionStatus {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ErrorCode {
UnknownField,
InvalidField,
PageTokenMismatch,
IdempotencyKeyReused,
IdempotencyInProgress,
EtagMismatch,
ResourceNotFound,
ResourceAlreadyExists,
Unauthenticated,
PermissionDenied,
DeletionProtected,
ReconcileFailed,
PlanLimitReached,
SpendLimitReached,
RateLimited,
InvalidState,
Internal,
Unavailable,
Unimplemented,
NotYetPropagated,
DeadlineExceeded,
NotFound,
ContractSkew,
NoCapacity,
ShapeNotOffered,
StaleGeneration,
ResourceInUse,
ControlHeld,
ControlHeldByHuman,
InvalidId,
EtagConflict,
ValidateOnlyNotSupported,
IdMoved,
Unknown(String),
}
impl ErrorCode {
pub fn as_str(&self) -> &str {
match self {
Self::UnknownField => "UNKNOWN_FIELD",
Self::InvalidField => "INVALID_FIELD",
Self::PageTokenMismatch => "PAGE_TOKEN_MISMATCH",
Self::IdempotencyKeyReused => "IDEMPOTENCY_KEY_REUSED",
Self::IdempotencyInProgress => "IDEMPOTENCY_IN_PROGRESS",
Self::EtagMismatch => "ETAG_MISMATCH",
Self::ResourceNotFound => "RESOURCE_NOT_FOUND",
Self::ResourceAlreadyExists => "RESOURCE_ALREADY_EXISTS",
Self::Unauthenticated => "UNAUTHENTICATED",
Self::PermissionDenied => "PERMISSION_DENIED",
Self::DeletionProtected => "DELETION_PROTECTED",
Self::ReconcileFailed => "RECONCILE_FAILED",
Self::PlanLimitReached => "PLAN_LIMIT_REACHED",
Self::SpendLimitReached => "SPEND_LIMIT_REACHED",
Self::RateLimited => "RATE_LIMITED",
Self::InvalidState => "INVALID_STATE",
Self::Internal => "INTERNAL",
Self::Unavailable => "UNAVAILABLE",
Self::Unimplemented => "UNIMPLEMENTED",
Self::NotYetPropagated => "NOT_YET_PROPAGATED",
Self::DeadlineExceeded => "DEADLINE_EXCEEDED",
Self::NotFound => "NOT_FOUND",
Self::ContractSkew => "CONTRACT_SKEW",
Self::NoCapacity => "NO_CAPACITY",
Self::ShapeNotOffered => "SHAPE_NOT_OFFERED",
Self::StaleGeneration => "STALE_GENERATION",
Self::ResourceInUse => "RESOURCE_IN_USE",
Self::ControlHeld => "CONTROL_HELD",
Self::ControlHeldByHuman => "CONTROL_HELD_BY_HUMAN",
Self::InvalidId => "INVALID_ID",
Self::EtagConflict => "ETAG_CONFLICT",
Self::ValidateOnlyNotSupported => "VALIDATE_ONLY_NOT_SUPPORTED",
Self::IdMoved => "ID_MOVED",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"UNKNOWN_FIELD" => Self::UnknownField,
"INVALID_FIELD" => Self::InvalidField,
"PAGE_TOKEN_MISMATCH" => Self::PageTokenMismatch,
"IDEMPOTENCY_KEY_REUSED" => Self::IdempotencyKeyReused,
"IDEMPOTENCY_IN_PROGRESS" => Self::IdempotencyInProgress,
"ETAG_MISMATCH" => Self::EtagMismatch,
"RESOURCE_NOT_FOUND" => Self::ResourceNotFound,
"RESOURCE_ALREADY_EXISTS" => Self::ResourceAlreadyExists,
"UNAUTHENTICATED" => Self::Unauthenticated,
"PERMISSION_DENIED" => Self::PermissionDenied,
"DELETION_PROTECTED" => Self::DeletionProtected,
"RECONCILE_FAILED" => Self::ReconcileFailed,
"PLAN_LIMIT_REACHED" => Self::PlanLimitReached,
"SPEND_LIMIT_REACHED" => Self::SpendLimitReached,
"RATE_LIMITED" => Self::RateLimited,
"INVALID_STATE" => Self::InvalidState,
"INTERNAL" => Self::Internal,
"UNAVAILABLE" => Self::Unavailable,
"UNIMPLEMENTED" => Self::Unimplemented,
"NOT_YET_PROPAGATED" => Self::NotYetPropagated,
"DEADLINE_EXCEEDED" => Self::DeadlineExceeded,
"NOT_FOUND" => Self::NotFound,
"CONTRACT_SKEW" => Self::ContractSkew,
"NO_CAPACITY" => Self::NoCapacity,
"SHAPE_NOT_OFFERED" => Self::ShapeNotOffered,
"STALE_GENERATION" => Self::StaleGeneration,
"RESOURCE_IN_USE" => Self::ResourceInUse,
"CONTROL_HELD" => Self::ControlHeld,
"CONTROL_HELD_BY_HUMAN" => Self::ControlHeldByHuman,
"INVALID_ID" => Self::InvalidId,
"ETAG_CONFLICT" => Self::EtagConflict,
"VALIDATE_ONLY_NOT_SUPPORTED" => Self::ValidateOnlyNotSupported,
"ID_MOVED" => Self::IdMoved,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for ErrorCode {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for ErrorCode {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for ErrorCode {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ErrorEffect {
None,
Applied,
UnknownValue,
Unknown(String),
}
impl ErrorEffect {
pub fn as_str(&self) -> &str {
match self {
Self::None => "none",
Self::Applied => "applied",
Self::UnknownValue => "unknown",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"none" => Self::None,
"applied" => Self::Applied,
"unknown" => Self::UnknownValue,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for ErrorEffect {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for ErrorEffect {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for ErrorEffect {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum OperationVerb {
Create,
Update,
Delete,
Custom,
Unknown(String),
}
impl OperationVerb {
pub fn as_str(&self) -> &str {
match self {
Self::Create => "create",
Self::Update => "update",
Self::Delete => "delete",
Self::Custom => "custom",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"create" => Self::Create,
"update" => Self::Update,
"delete" => Self::Delete,
"custom" => Self::Custom,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for OperationVerb {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for OperationVerb {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for OperationVerb {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Severity {
Info,
Warning,
Error,
Unknown(String),
}
impl Severity {
pub fn as_str(&self) -> &str {
match self {
Self::Info => "info",
Self::Warning => "warning",
Self::Error => "error",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"info" => Self::Info,
"warning" => Self::Warning,
"error" => Self::Error,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for Severity {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for Severity {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for Severity {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}