spiral/api/tasks/

objects.rs

// Generated by tools/service-contracts/rust.py. Do not edit.
#![doc = "Generated transport-independent contract objects."]

use std::collections::BTreeMap;
use std::error::Error as StdError;
use std::fmt::{self, Display, Formatter};

use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::Value;
use spiral_contract::error::{ErrorEnvelope, ServiceError};
use spiral_contract::safelong::{SafeLong, SafeUnsignedLong};
use spiral_contract::strict::{DeserializeStrict, Strict};
use uuid::Uuid;

/// AttemptLease contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AttemptLease {
    /// Contract field attemptId.
    #[serde(rename = "attemptId")]
    pub attempt_id: Uuid,
    /// Contract field leaseExpiresAtMicros.
    #[serde(rename = "leaseExpiresAtMicros")]
    pub lease_expires_at_micros: SafeLong,
    /// Contract field stopReason.
    #[serde(rename = "stopReason")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stop_reason: Option<TaskStopReason>,
    /// Contract field taskId.
    #[serde(rename = "taskId")]
    pub task_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for AttemptLease {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attemptId")]
            attempt_id: Strict<Uuid>,
            #[serde(rename = "leaseExpiresAtMicros")]
            lease_expires_at_micros: Strict<SafeLong>,
            #[serde(rename = "stopReason")]
            #[serde(default)]
            stop_reason: Strict<Option<TaskStopReason>>,
            #[serde(rename = "taskId")]
            task_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt_id: wire.attempt_id.0,
            lease_expires_at_micros: wire.lease_expires_at_micros.0,
            stop_reason: wire.stop_reason.0,
            task_id: wire.task_id.0,
        })
    }
}

/// AttemptStatus contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum AttemptStatus {
    /// A known contract value.
    Running,
    /// A known contract value.
    Succeeded,
    /// A known contract value.
    Failed,
    /// A known contract value.
    Cancelled,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for AttemptStatus {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Running => "running",
            Self::Succeeded => "succeeded",
            Self::Failed => "failed",
            Self::Cancelled => "cancelled",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for AttemptStatus {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "running" => Self::Running,
            "succeeded" => Self::Succeeded,
            "failed" => Self::Failed,
            "cancelled" => Self::Cancelled,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for AttemptStatus {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "running")]
            Running,
            #[serde(rename = "succeeded")]
            Succeeded,
            #[serde(rename = "failed")]
            Failed,
            #[serde(rename = "cancelled")]
            Cancelled,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Running => Self::Running,
            __Known::Succeeded => Self::Succeeded,
            __Known::Failed => Self::Failed,
            __Known::Cancelled => Self::Cancelled,
        })
    }
}

/// Caller contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Caller {
    /// A known union arm.
    Application(CallerApplication),
    /// A known union arm.
    Installation(CallerInstallation),
    /// A known union arm.
    Resource(CallerResource),
    /// A known union arm.
    Service(CallerService),
    /// A known union arm.
    User(CallerUser),
    /// A known union arm.
    Workload(CallerWorkload),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for Caller {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Application(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("application".into()));
                object.insert(
                    "application".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Installation(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("installation".into()));
                object.insert(
                    "installation".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Resource(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("resource".into()));
                object.insert(
                    "resource".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Service(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("service".into()));
                object.insert(
                    "service".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::User(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("user".into()));
                object.insert(
                    "user".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Workload(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("workload".into()));
                object.insert(
                    "workload".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Unknown { tag, value } => {
                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
                    return Err(serde::ser::Error::custom(
                        "unknown union discriminator mismatch",
                    ));
                }
                value.serialize(serializer)
            }
        }
    }
}
impl<'de> Deserialize<'de> for Caller {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(Value::as_str)
            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
        match tag {
            "application" => Ok(Self::Application(
                serde_json::from_value(
                    value
                        .get("application")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "installation" => Ok(Self::Installation(
                serde_json::from_value(
                    value
                        .get("installation")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "resource" => Ok(Self::Resource(
                serde_json::from_value(
                    value
                        .get("resource")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "service" => Ok(Self::Service(
                serde_json::from_value(
                    value
                        .get("service")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "user" => Ok(Self::User(
                serde_json::from_value(
                    value
                        .get("user")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "workload" => Ok(Self::Workload(
                serde_json::from_value(
                    value
                        .get("workload")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            tag => Ok(Self::Unknown {
                tag: tag.to_owned(),
                value,
            }),
        }
    }
}
impl<'de> DeserializeStrict<'de> for Caller {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "application")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "application")]
            value: Strict<CallerApplication>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "installation")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "installation")]
            value: Strict<CallerInstallation>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "resource")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "resource")]
            value: Strict<CallerResource>,
        }
        #[derive(Deserialize)]
        enum __Tag3 {
            #[serde(rename = "service")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm3 {
            #[serde(rename = "type")]
            _tag: __Tag3,
            #[serde(rename = "service")]
            value: Strict<CallerService>,
        }
        #[derive(Deserialize)]
        enum __Tag4 {
            #[serde(rename = "user")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm4 {
            #[serde(rename = "type")]
            _tag: __Tag4,
            #[serde(rename = "user")]
            value: Strict<CallerUser>,
        }
        #[derive(Deserialize)]
        enum __Tag5 {
            #[serde(rename = "workload")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm5 {
            #[serde(rename = "type")]
            _tag: __Tag5,
            #[serde(rename = "workload")]
            value: Strict<CallerWorkload>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Application(Box<__Arm0>),
            Installation(Box<__Arm1>),
            Resource(Box<__Arm2>),
            Service(Box<__Arm3>),
            User(Box<__Arm4>),
            Workload(Box<__Arm5>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Application(arm) => Self::Application(arm.value.0),
            __Known::Installation(arm) => Self::Installation(arm.value.0),
            __Known::Resource(arm) => Self::Resource(arm.value.0),
            __Known::Service(arm) => Self::Service(arm.value.0),
            __Known::User(arm) => Self::User(arm.value.0),
            __Known::Workload(arm) => Self::Workload(arm.value.0),
        })
    }
}

/// CallerApplication contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CallerApplication {
    /// Contract field applicationId.
    #[serde(rename = "applicationId")]
    pub application_id: String,
}
impl<'de> DeserializeStrict<'de> for CallerApplication {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "applicationId")]
            application_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            application_id: wire.application_id.0,
        })
    }
}

/// CallerInstallation contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CallerInstallation {
    /// Contract field installationId.
    #[serde(rename = "installationId")]
    pub installation_id: String,
}
impl<'de> DeserializeStrict<'de> for CallerInstallation {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "installationId")]
            installation_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            installation_id: wire.installation_id.0,
        })
    }
}

/// CallerResource contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CallerResource {
    /// Contract field spid.
    #[serde(rename = "spid")]
    pub spid: String,
}
impl<'de> DeserializeStrict<'de> for CallerResource {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "spid")]
            spid: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self { spid: wire.spid.0 })
    }
}

/// CallerService contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CallerService {
    /// Contract field serviceId.
    #[serde(rename = "serviceId")]
    pub service_id: String,
}
impl<'de> DeserializeStrict<'de> for CallerService {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "serviceId")]
            service_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            service_id: wire.service_id.0,
        })
    }
}

/// CallerUser contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CallerUser {
    /// Contract field orgId.
    #[serde(rename = "orgId")]
    pub org_id: String,
    /// Contract field userId.
    #[serde(rename = "userId")]
    pub user_id: String,
}
impl<'de> DeserializeStrict<'de> for CallerUser {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "orgId")]
            org_id: Strict<String>,
            #[serde(rename = "userId")]
            user_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            org_id: wire.org_id.0,
            user_id: wire.user_id.0,
        })
    }
}

/// CallerWorkload contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CallerWorkload {
    /// Contract field workloadId.
    #[serde(rename = "workloadId")]
    pub workload_id: String,
}
impl<'de> DeserializeStrict<'de> for CallerWorkload {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "workloadId")]
            workload_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            workload_id: wire.workload_id.0,
        })
    }
}

/// ColumnGroupCompactionCommit contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ColumnGroupCompactionCommit {
    /// Contract field columnGroup.
    #[serde(rename = "columnGroup")]
    pub column_group: String,
    /// Contract field committedAtMicros.
    #[serde(rename = "committedAtMicros")]
    pub committed_at_micros: SafeUnsignedLong,
}
impl<'de> DeserializeStrict<'de> for ColumnGroupCompactionCommit {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "columnGroup")]
            column_group: Strict<String>,
            #[serde(rename = "committedAtMicros")]
            committed_at_micros: Strict<SafeUnsignedLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            column_group: wire.column_group.0,
            committed_at_micros: wire.committed_at_micros.0,
        })
    }
}

/// ColumnGroupCompactionProgress contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ColumnGroupCompactionProgress {
    /// Contract field columnGroup.
    #[serde(rename = "columnGroup")]
    pub column_group: String,
    /// Contract field groupCount.
    #[serde(rename = "groupCount")]
    pub group_count: SafeUnsignedLong,
    /// Contract field groupIndex.
    #[serde(rename = "groupIndex")]
    pub group_index: SafeUnsignedLong,
    /// Contract field step.
    #[serde(rename = "step")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub step: Option<ColumnGroupCompactionStep>,
}
impl<'de> DeserializeStrict<'de> for ColumnGroupCompactionProgress {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "columnGroup")]
            column_group: Strict<String>,
            #[serde(rename = "groupCount")]
            group_count: Strict<SafeUnsignedLong>,
            #[serde(rename = "groupIndex")]
            group_index: Strict<SafeUnsignedLong>,
            #[serde(rename = "step")]
            #[serde(default)]
            step: Strict<Option<ColumnGroupCompactionStep>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            column_group: wire.column_group.0,
            group_count: wire.group_count.0,
            group_index: wire.group_index.0,
            step: wire.step.0,
        })
    }
}

/// ColumnGroupCompactionStep contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ColumnGroupCompactionStep {
    /// A known contract value.
    Split,
    /// A known contract value.
    SizeBased,
    /// A known contract value.
    Overlaps,
    /// A known contract value.
    Committing,
    /// A known contract value.
    Committed,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for ColumnGroupCompactionStep {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Split => "split",
            Self::SizeBased => "size_based",
            Self::Overlaps => "overlaps",
            Self::Committing => "committing",
            Self::Committed => "committed",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for ColumnGroupCompactionStep {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "split" => Self::Split,
            "size_based" => Self::SizeBased,
            "overlaps" => Self::Overlaps,
            "committing" => Self::Committing,
            "committed" => Self::Committed,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for ColumnGroupCompactionStep {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "split")]
            Split,
            #[serde(rename = "size_based")]
            SizeBased,
            #[serde(rename = "overlaps")]
            Overlaps,
            #[serde(rename = "committing")]
            Committing,
            #[serde(rename = "committed")]
            Committed,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Split => Self::Split,
            __Known::SizeBased => Self::SizeBased,
            __Known::Overlaps => Self::Overlaps,
            __Known::Committing => Self::Committing,
            __Known::Committed => Self::Committed,
        })
    }
}

/// ComputeClass contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ComputeClass {
    /// A known union arm.
    Cpu(ComputeClassCpu),
    /// A known union arm.
    Gpu(ComputeClassGpu),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for ComputeClass {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Cpu(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("cpu".into()));
                object.insert(
                    "cpu".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Gpu(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("gpu".into()));
                object.insert(
                    "gpu".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Unknown { tag, value } => {
                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
                    return Err(serde::ser::Error::custom(
                        "unknown union discriminator mismatch",
                    ));
                }
                value.serialize(serializer)
            }
        }
    }
}
impl<'de> Deserialize<'de> for ComputeClass {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(Value::as_str)
            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
        match tag {
            "cpu" => Ok(Self::Cpu(
                serde_json::from_value(
                    value
                        .get("cpu")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "gpu" => Ok(Self::Gpu(
                serde_json::from_value(
                    value
                        .get("gpu")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            tag => Ok(Self::Unknown {
                tag: tag.to_owned(),
                value,
            }),
        }
    }
}
impl<'de> DeserializeStrict<'de> for ComputeClass {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "cpu")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "cpu")]
            value: Strict<ComputeClassCpu>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "gpu")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "gpu")]
            value: Strict<ComputeClassGpu>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Cpu(Box<__Arm0>),
            Gpu(Box<__Arm1>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Cpu(arm) => Self::Cpu(arm.value.0),
            __Known::Gpu(arm) => Self::Gpu(arm.value.0),
        })
    }
}

/// ComputeClassCpu contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ComputeClassCpu {}
impl<'de> DeserializeStrict<'de> for ComputeClassCpu {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {}
        __Wire::deserialize(deserializer)?;
        Ok(Self {})
    }
}

/// ComputeClassGpu contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ComputeClassGpu {
    /// Contract field count.
    #[serde(rename = "count")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub count: Option<u32>,
    /// Contract field memoryBytes.
    #[serde(rename = "memoryBytes")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory_bytes: Option<SafeUnsignedLong>,
    /// Contract field runtime.
    #[serde(rename = "runtime")]
    pub runtime: GpuRuntime,
}
impl<'de> DeserializeStrict<'de> for ComputeClassGpu {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "count")]
            #[serde(default)]
            count: Strict<Option<u32>>,
            #[serde(rename = "memoryBytes")]
            #[serde(default)]
            memory_bytes: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "runtime")]
            runtime: Strict<GpuRuntime>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            count: wire.count.0,
            memory_bytes: wire.memory_bytes.0,
            runtime: wire.runtime.0,
        })
    }
}

/// CreateTaskRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateTaskRequest {
    /// Contract field idempotencyKey.
    #[serde(rename = "idempotencyKey")]
    pub idempotency_key: String,
    /// Contract field input.
    #[serde(rename = "input")]
    pub input: Value,
    /// Contract field options.
    #[serde(rename = "options")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<TaskOptions>,
    /// Contract field parentTaskId.
    #[serde(rename = "parentTaskId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_task_id: Option<Uuid>,
    /// Contract field taskSpecId.
    #[serde(rename = "taskSpecId")]
    pub task_spec_id: TaskSpecId,
}
impl<'de> DeserializeStrict<'de> for CreateTaskRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "idempotencyKey")]
            idempotency_key: Strict<String>,
            #[serde(rename = "input")]
            input: Strict<Value>,
            #[serde(rename = "options")]
            #[serde(default)]
            options: Strict<Option<TaskOptions>>,
            #[serde(rename = "parentTaskId")]
            #[serde(default)]
            parent_task_id: Strict<Option<Uuid>>,
            #[serde(rename = "taskSpecId")]
            task_spec_id: Strict<TaskSpecId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            idempotency_key: wire.idempotency_key.0,
            input: wire.input.0,
            options: wire.options.0,
            parent_task_id: wire.parent_task_id.0,
            task_spec_id: wire.task_spec_id.0,
        })
    }
}

/// CreateTaskResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CreateTaskResponse {
    /// A known union arm.
    Accepted(Box<CreateTaskResponseAccepted>),
    /// A known union arm.
    Skipped(CreateTaskResponseSkipped),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for CreateTaskResponse {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Accepted(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("accepted".into()));
                object.insert(
                    "accepted".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Skipped(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("skipped".into()));
                object.insert(
                    "skipped".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Unknown { tag, value } => {
                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
                    return Err(serde::ser::Error::custom(
                        "unknown union discriminator mismatch",
                    ));
                }
                value.serialize(serializer)
            }
        }
    }
}
impl<'de> Deserialize<'de> for CreateTaskResponse {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(Value::as_str)
            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
        match tag {
            "accepted" => Ok(Self::Accepted(
                serde_json::from_value(
                    value
                        .get("accepted")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "skipped" => Ok(Self::Skipped(
                serde_json::from_value(
                    value
                        .get("skipped")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            tag => Ok(Self::Unknown {
                tag: tag.to_owned(),
                value,
            }),
        }
    }
}
impl<'de> DeserializeStrict<'de> for CreateTaskResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "accepted")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "accepted")]
            value: Strict<CreateTaskResponseAccepted>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "skipped")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "skipped")]
            value: Strict<CreateTaskResponseSkipped>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Accepted(Box<__Arm0>),
            Skipped(Box<__Arm1>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Accepted(arm) => Self::Accepted(Box::new(arm.value.0)),
            __Known::Skipped(arm) => Self::Skipped(arm.value.0),
        })
    }
}

/// CreateTaskResponseAccepted contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateTaskResponseAccepted {
    /// Contract field task.
    #[serde(rename = "task")]
    pub task: Task,
}
impl<'de> DeserializeStrict<'de> for CreateTaskResponseAccepted {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "task")]
            task: Strict<Task>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self { task: wire.task.0 })
    }
}

/// CreateTaskResponseSkipped contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateTaskResponseSkipped {}
impl<'de> DeserializeStrict<'de> for CreateTaskResponseSkipped {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {}
        __Wire::deserialize(deserializer)?;
        Ok(Self {})
    }
}

/// CreateWorkerPoolRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateWorkerPoolRequest {
    /// Contract field capabilities.
    #[serde(rename = "capabilities")]
    pub capabilities: WorkerCapabilities,
    /// Contract field maxWorkers.
    #[serde(rename = "maxWorkers")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_workers: Option<u32>,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
}
impl<'de> DeserializeStrict<'de> for CreateWorkerPoolRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "capabilities")]
            capabilities: Strict<WorkerCapabilities>,
            #[serde(rename = "maxWorkers")]
            #[serde(default)]
            max_workers: Strict<Option<u32>>,
            #[serde(rename = "name")]
            name: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            capabilities: wire.capabilities.0,
            max_workers: wire.max_workers.0,
            name: wire.name.0,
        })
    }
}

/// DeletionApplicationProgress contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct DeletionApplicationProgress {
    /// Contract field checked.
    #[serde(rename = "checked")]
    pub checked: SafeUnsignedLong,
    /// Contract field columnGroup.
    #[serde(rename = "columnGroup")]
    pub column_group: String,
    /// Contract field groupCount.
    #[serde(rename = "groupCount")]
    pub group_count: SafeUnsignedLong,
    /// Contract field groupIndex.
    #[serde(rename = "groupIndex")]
    pub group_index: SafeUnsignedLong,
    /// Contract field rewritten.
    #[serde(rename = "rewritten")]
    pub rewritten: SafeUnsignedLong,
    /// Contract field skipped.
    #[serde(rename = "skipped")]
    pub skipped: SafeUnsignedLong,
    /// Contract field total.
    #[serde(rename = "total")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<SafeUnsignedLong>,
}
impl<'de> DeserializeStrict<'de> for DeletionApplicationProgress {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "checked")]
            checked: Strict<SafeUnsignedLong>,
            #[serde(rename = "columnGroup")]
            column_group: Strict<String>,
            #[serde(rename = "groupCount")]
            group_count: Strict<SafeUnsignedLong>,
            #[serde(rename = "groupIndex")]
            group_index: Strict<SafeUnsignedLong>,
            #[serde(rename = "rewritten")]
            rewritten: Strict<SafeUnsignedLong>,
            #[serde(rename = "skipped")]
            skipped: Strict<SafeUnsignedLong>,
            #[serde(rename = "total")]
            #[serde(default)]
            total: Strict<Option<SafeUnsignedLong>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            checked: wire.checked.0,
            column_group: wire.column_group.0,
            group_count: wire.group_count.0,
            group_index: wire.group_index.0,
            rewritten: wire.rewritten.0,
            skipped: wire.skipped.0,
            total: wire.total.0,
        })
    }
}

/// DrainWorkerResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct DrainWorkerResponse {
    /// Contract field workerSession.
    #[serde(rename = "workerSession")]
    pub worker_session: WorkerSession,
}
impl<'de> DeserializeStrict<'de> for DrainWorkerResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "workerSession")]
            worker_session: Strict<WorkerSession>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            worker_session: wire.worker_session.0,
        })
    }
}

/// One child of an Enrichment refresh, writing the values of its assigned source files. Its parent
/// is the refresh.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct EnrichmentComputeDefinition {
    /// Contract field enrichmentResourceId.
    #[serde(rename = "enrichmentResourceId")]
    pub enrichment_resource_id: Uuid,
    /// Contract field fragmentIds.
    #[serde(rename = "fragmentIds")]
    pub fragment_ids: Vec<Uuid>,
    /// Contract field readTarget.
    #[serde(rename = "readTarget")]
    pub read_target: TaskReadTarget,
}
impl<'de> DeserializeStrict<'de> for EnrichmentComputeDefinition {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "enrichmentResourceId")]
            enrichment_resource_id: Strict<Uuid>,
            #[serde(rename = "fragmentIds")]
            fragment_ids: Strict<Vec<Uuid>>,
            #[serde(rename = "readTarget")]
            read_target: Strict<TaskReadTarget>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            enrichment_resource_id: wire.enrichment_resource_id.0,
            fragment_ids: wire.fragment_ids.0,
            read_target: wire.read_target.0,
        })
    }
}

/// Refresh one Enrichment against its source Table's version at an exact Project commit, computing
/// only the rows whose inputs changed since the version its values are current for, and publish one
/// Enrichment version.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct EnrichmentRefreshDefinition {
    /// Contract field enrichmentResourceId.
    #[serde(rename = "enrichmentResourceId")]
    pub enrichment_resource_id: Uuid,
    /// Contract field readTarget.
    #[serde(rename = "readTarget")]
    pub read_target: TaskReadTarget,
}
impl<'de> DeserializeStrict<'de> for EnrichmentRefreshDefinition {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "enrichmentResourceId")]
            enrichment_resource_id: Strict<Uuid>,
            #[serde(rename = "readTarget")]
            read_target: Strict<TaskReadTarget>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            enrichment_resource_id: wire.enrichment_resource_id.0,
            read_target: wire.read_target.0,
        })
    }
}

/// FinishAttemptOutcome contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum FinishAttemptOutcome {
    /// A known union arm.
    Cancelled(FinishAttemptOutcomeCancelled),
    /// A known union arm.
    Failed(FinishAttemptOutcomeFailed),
    /// A known union arm.
    Succeeded(FinishAttemptOutcomeSucceeded),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for FinishAttemptOutcome {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Cancelled(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("cancelled".into()));
                object.insert(
                    "cancelled".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Failed(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("failed".into()));
                object.insert(
                    "failed".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Succeeded(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("succeeded".into()));
                object.insert(
                    "succeeded".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Unknown { tag, value } => {
                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
                    return Err(serde::ser::Error::custom(
                        "unknown union discriminator mismatch",
                    ));
                }
                value.serialize(serializer)
            }
        }
    }
}
impl<'de> Deserialize<'de> for FinishAttemptOutcome {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(Value::as_str)
            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
        match tag {
            "cancelled" => Ok(Self::Cancelled(
                serde_json::from_value(
                    value
                        .get("cancelled")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "failed" => Ok(Self::Failed(
                serde_json::from_value(
                    value
                        .get("failed")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "succeeded" => Ok(Self::Succeeded(
                serde_json::from_value(
                    value
                        .get("succeeded")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            tag => Ok(Self::Unknown {
                tag: tag.to_owned(),
                value,
            }),
        }
    }
}
impl<'de> DeserializeStrict<'de> for FinishAttemptOutcome {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "cancelled")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "cancelled")]
            value: Strict<FinishAttemptOutcomeCancelled>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "failed")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "failed")]
            value: Strict<FinishAttemptOutcomeFailed>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "succeeded")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "succeeded")]
            value: Strict<FinishAttemptOutcomeSucceeded>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Cancelled(Box<__Arm0>),
            Failed(Box<__Arm1>),
            Succeeded(Box<__Arm2>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Cancelled(arm) => Self::Cancelled(arm.value.0),
            __Known::Failed(arm) => Self::Failed(arm.value.0),
            __Known::Succeeded(arm) => Self::Succeeded(arm.value.0),
        })
    }
}

/// FinishAttemptOutcomeCancelled contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FinishAttemptOutcomeCancelled {}
impl<'de> DeserializeStrict<'de> for FinishAttemptOutcomeCancelled {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {}
        __Wire::deserialize(deserializer)?;
        Ok(Self {})
    }
}

/// FinishAttemptOutcomeFailed contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FinishAttemptOutcomeFailed {
    /// Contract field failure.
    #[serde(rename = "failure")]
    pub failure: TaskFailure,
}
impl<'de> DeserializeStrict<'de> for FinishAttemptOutcomeFailed {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "failure")]
            failure: Strict<TaskFailure>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            failure: wire.failure.0,
        })
    }
}

/// FinishAttemptOutcomeSucceeded contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FinishAttemptOutcomeSucceeded {
    /// Contract field result.
    #[serde(rename = "result")]
    pub result: Value,
}
impl<'de> DeserializeStrict<'de> for FinishAttemptOutcomeSucceeded {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "result")]
            result: Strict<Value>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            result: wire.result.0,
        })
    }
}

/// FinishAttemptRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FinishAttemptRequest {
    /// Contract field outcome.
    #[serde(rename = "outcome")]
    pub outcome: FinishAttemptOutcome,
}
impl<'de> DeserializeStrict<'de> for FinishAttemptRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "outcome")]
            outcome: Strict<FinishAttemptOutcome>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            outcome: wire.outcome.0,
        })
    }
}

/// FinishAttemptResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FinishAttemptResponse {
    /// Contract field attempt.
    #[serde(rename = "attempt")]
    pub attempt: TaskAttempt,
    /// Contract field task.
    #[serde(rename = "task")]
    pub task: Task,
}
impl<'de> DeserializeStrict<'de> for FinishAttemptResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attempt")]
            attempt: Strict<TaskAttempt>,
            #[serde(rename = "task")]
            task: Strict<Task>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt: wire.attempt.0,
            task: wire.task.0,
        })
    }
}

/// GpuRuntime contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum GpuRuntime {
    /// A known contract value.
    Cuda,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for GpuRuntime {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Cuda => "cuda",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for GpuRuntime {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "cuda" => Self::Cuda,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for GpuRuntime {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "cuda")]
            Cuda,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Cuda => Self::Cuda,
        })
    }
}

/// HeartbeatWorkerRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct HeartbeatWorkerRequest {
    /// Contract field capabilities.
    #[serde(rename = "capabilities")]
    pub capabilities: WorkerCapabilities,
    /// Contract field currentAttemptId.
    #[serde(rename = "currentAttemptId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub current_attempt_id: Option<Uuid>,
    /// Contract field metrics.
    #[serde(rename = "metrics")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<Value>,
    /// Contract field progress.
    #[serde(rename = "progress")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub progress: Option<TaskProgress>,
    /// Contract field resourceUsage.
    #[serde(rename = "resourceUsage")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_usage: Option<ResourceUsage>,
}
impl<'de> DeserializeStrict<'de> for HeartbeatWorkerRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "capabilities")]
            capabilities: Strict<WorkerCapabilities>,
            #[serde(rename = "currentAttemptId")]
            #[serde(default)]
            current_attempt_id: Strict<Option<Uuid>>,
            #[serde(rename = "metrics")]
            #[serde(default)]
            metrics: Strict<Option<Value>>,
            #[serde(rename = "progress")]
            #[serde(default)]
            progress: Strict<Option<TaskProgress>>,
            #[serde(rename = "resourceUsage")]
            #[serde(default)]
            resource_usage: Strict<Option<ResourceUsage>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            capabilities: wire.capabilities.0,
            current_attempt_id: wire.current_attempt_id.0,
            metrics: wire.metrics.0,
            progress: wire.progress.0,
            resource_usage: wire.resource_usage.0,
        })
    }
}

/// HeartbeatWorkerResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct HeartbeatWorkerResponse {
    /// Contract field lease.
    #[serde(rename = "lease")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub lease: Option<AttemptLease>,
    /// Contract field workerSession.
    #[serde(rename = "workerSession")]
    pub worker_session: WorkerSession,
}
impl<'de> DeserializeStrict<'de> for HeartbeatWorkerResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "lease")]
            #[serde(default)]
            lease: Strict<Option<AttemptLease>>,
            #[serde(rename = "workerSession")]
            worker_session: Strict<WorkerSession>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            lease: wire.lease.0,
            worker_session: wire.worker_session.0,
        })
    }
}

/// InvocationPage contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InvocationPage {
    /// Contract field items.
    #[serde(rename = "items")]
    pub items: Vec<TriggerInvocation>,
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<String>,
}
impl<'de> DeserializeStrict<'de> for InvocationPage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "items")]
            items: Strict<Vec<TriggerInvocation>>,
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            items: wire.items.0,
            next_page_token: wire.next_page_token.0,
        })
    }
}

/// InvocationPageRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct InvocationPageRequest {
    /// Contract field pageToken.
    #[serde(rename = "pageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_token: Option<String>,
}
impl<'de> DeserializeStrict<'de> for InvocationPageRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "pageToken")]
            #[serde(default)]
            page_token: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            page_token: wire.page_token.0,
        })
    }
}

/// InvocationStatus contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum InvocationStatus {
    /// A known contract value.
    Accepted,
    /// A known contract value.
    Skipped,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for InvocationStatus {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Accepted => "accepted",
            Self::Skipped => "skipped",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for InvocationStatus {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "accepted" => Self::Accepted,
            "skipped" => Self::Skipped,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for InvocationStatus {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "accepted")]
            Accepted,
            #[serde(rename = "skipped")]
            Skipped,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Accepted => Self::Accepted,
            __Known::Skipped => Self::Skipped,
        })
    }
}

/// Planning parameters that a coordinator pins, so that every worker plans the same way.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct LegacyCompactionParameters {
    /// Contract field maxScopeFragments.
    #[serde(rename = "maxScopeFragments")]
    pub max_scope_fragments: SafeUnsignedLong,
    /// Contract field memoryBudgetBytes.
    #[serde(rename = "memoryBudgetBytes")]
    pub memory_budget_bytes: SafeUnsignedLong,
    /// Contract field sizeThresholdBytes.
    #[serde(rename = "sizeThresholdBytes")]
    pub size_threshold_bytes: SafeUnsignedLong,
}
impl<'de> DeserializeStrict<'de> for LegacyCompactionParameters {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "maxScopeFragments")]
            max_scope_fragments: Strict<SafeUnsignedLong>,
            #[serde(rename = "memoryBudgetBytes")]
            memory_budget_bytes: Strict<SafeUnsignedLong>,
            #[serde(rename = "sizeThresholdBytes")]
            size_threshold_bytes: Strict<SafeUnsignedLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            max_scope_fragments: wire.max_scope_fragments.0,
            memory_budget_bytes: wire.memory_budget_bytes.0,
            size_threshold_bytes: wire.size_threshold_bytes.0,
        })
    }
}

/// LegacyCompactionStrategy contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum LegacyCompactionStrategy {
    /// A known contract value.
    SizeBased,
    /// A known contract value.
    Overlaps,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for LegacyCompactionStrategy {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::SizeBased => "size_based",
            Self::Overlaps => "overlaps",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for LegacyCompactionStrategy {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "size_based" => Self::SizeBased,
            "overlaps" => Self::Overlaps,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for LegacyCompactionStrategy {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "size_based")]
            SizeBased,
            #[serde(rename = "overlaps")]
            Overlaps,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::SizeBased => Self::SizeBased,
            __Known::Overlaps => Self::Overlaps,
        })
    }
}

/// One child of a legacy table maintenance Task. It compacts one column group at the coordinator's
/// snapshot and returns the operations for the coordinator to commit.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct LegacyTableCompactionWorkerDefinition {
    /// Contract field asofMicros.
    #[serde(rename = "asofMicros")]
    pub asof_micros: SafeUnsignedLong,
    /// Contract field columnGroup.
    #[serde(rename = "columnGroup")]
    pub column_group: Vec<String>,
    /// Contract field coordinatorTaskId.
    #[serde(rename = "coordinatorTaskId")]
    pub coordinator_task_id: Uuid,
    /// Contract field parameters.
    #[serde(rename = "parameters")]
    pub parameters: LegacyCompactionParameters,
    /// Contract field runId.
    #[serde(rename = "runId")]
    pub run_id: String,
    /// Contract field strategies.
    #[serde(rename = "strategies")]
    pub strategies: Vec<LegacyCompactionStrategy>,
    /// Contract field tableId.
    #[serde(rename = "tableId")]
    pub table_id: String,
}
impl<'de> DeserializeStrict<'de> for LegacyTableCompactionWorkerDefinition {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "asofMicros")]
            asof_micros: Strict<SafeUnsignedLong>,
            #[serde(rename = "columnGroup")]
            column_group: Strict<Vec<String>>,
            #[serde(rename = "coordinatorTaskId")]
            coordinator_task_id: Strict<Uuid>,
            #[serde(rename = "parameters")]
            parameters: Strict<LegacyCompactionParameters>,
            #[serde(rename = "runId")]
            run_id: Strict<String>,
            #[serde(rename = "strategies")]
            strategies: Strict<Vec<LegacyCompactionStrategy>>,
            #[serde(rename = "tableId")]
            table_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            asof_micros: wire.asof_micros.0,
            column_group: wire.column_group.0,
            coordinator_task_id: wire.coordinator_task_id.0,
            parameters: wire.parameters.0,
            run_id: wire.run_id.0,
            strategies: wire.strategies.0,
            table_id: wire.table_id.0,
        })
    }
}

/// One legacy keyed table, and whether to strip manifest metadata it no longer needs.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct LegacyTableDefinition {
    /// Contract field strip.
    #[serde(rename = "strip")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strip: Option<bool>,
    /// Contract field tableId.
    #[serde(rename = "tableId")]
    pub table_id: String,
}
impl<'de> DeserializeStrict<'de> for LegacyTableDefinition {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "strip")]
            #[serde(default)]
            strip: Strict<Option<bool>>,
            #[serde(rename = "tableId")]
            table_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            strip: wire.strip.0,
            table_id: wire.table_id.0,
        })
    }
}

/// One legacy keyed table to flush and compact, whether to strip manifest metadata it no longer
/// needs, and whether to compact its column groups in parallel child Tasks that this Task commits
/// as one transaction.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct LegacyTableMaintenanceDefinition {
    /// Contract field fanOut.
    #[serde(rename = "fanOut")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fan_out: Option<bool>,
    /// Contract field strip.
    #[serde(rename = "strip")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strip: Option<bool>,
    /// Contract field tableId.
    #[serde(rename = "tableId")]
    pub table_id: String,
}
impl<'de> DeserializeStrict<'de> for LegacyTableMaintenanceDefinition {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "fanOut")]
            #[serde(default)]
            fan_out: Strict<Option<bool>>,
            #[serde(rename = "strip")]
            #[serde(default)]
            strip: Strict<Option<bool>>,
            #[serde(rename = "tableId")]
            table_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            fan_out: wire.fan_out.0,
            strip: wire.strip.0,
            table_id: wire.table_id.0,
        })
    }
}

/// ListTaskSpecsResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListTaskSpecsResponse {
    /// Contract field taskSpecs.
    #[serde(rename = "taskSpecs")]
    pub task_specs: Vec<TaskSpecDefaults>,
}
impl<'de> DeserializeStrict<'de> for ListTaskSpecsResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "taskSpecs")]
            task_specs: Strict<Vec<TaskSpecDefaults>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            task_specs: wire.task_specs.0,
        })
    }
}

/// ListTasksRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListTasksRequest {
    /// Contract field legacyTableId.
    #[serde(rename = "legacyTableId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub legacy_table_id: Option<String>,
    /// Contract field origin.
    #[serde(rename = "origin")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub origin: Option<TaskOrigin>,
    /// Contract field pageSize.
    #[serde(rename = "pageSize")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_size: Option<u32>,
    /// Contract field pageToken.
    #[serde(rename = "pageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_token: Option<String>,
    /// Contract field parentTaskId.
    #[serde(rename = "parentTaskId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_task_id: Option<Uuid>,
    /// Contract field query.
    #[serde(rename = "query")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_id: Option<Uuid>,
    /// Contract field resourceRole.
    #[serde(rename = "resourceRole")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_role: Option<TaskResourceRole>,
    /// Contract field status.
    #[serde(rename = "status")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<TaskStatus>,
    /// Contract field taskSpecName.
    #[serde(rename = "taskSpecName")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub task_spec_name: Option<String>,
    /// Contract field workerPoolId.
    #[serde(rename = "workerPoolId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub worker_pool_id: Option<Uuid>,
    /// Contract field workerSessionId.
    #[serde(rename = "workerSessionId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub worker_session_id: Option<Uuid>,
}
impl<'de> DeserializeStrict<'de> for ListTasksRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "legacyTableId")]
            #[serde(default)]
            legacy_table_id: Strict<Option<String>>,
            #[serde(rename = "origin")]
            #[serde(default)]
            origin: Strict<Option<TaskOrigin>>,
            #[serde(rename = "pageSize")]
            #[serde(default)]
            page_size: Strict<Option<u32>>,
            #[serde(rename = "pageToken")]
            #[serde(default)]
            page_token: Strict<Option<String>>,
            #[serde(rename = "parentTaskId")]
            #[serde(default)]
            parent_task_id: Strict<Option<Uuid>>,
            #[serde(rename = "query")]
            #[serde(default)]
            query: Strict<Option<String>>,
            #[serde(rename = "resourceId")]
            #[serde(default)]
            resource_id: Strict<Option<Uuid>>,
            #[serde(rename = "resourceRole")]
            #[serde(default)]
            resource_role: Strict<Option<TaskResourceRole>>,
            #[serde(rename = "status")]
            #[serde(default)]
            status: Strict<Option<TaskStatus>>,
            #[serde(rename = "taskSpecName")]
            #[serde(default)]
            task_spec_name: Strict<Option<String>>,
            #[serde(rename = "workerPoolId")]
            #[serde(default)]
            worker_pool_id: Strict<Option<Uuid>>,
            #[serde(rename = "workerSessionId")]
            #[serde(default)]
            worker_session_id: Strict<Option<Uuid>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            legacy_table_id: wire.legacy_table_id.0,
            origin: wire.origin.0,
            page_size: wire.page_size.0,
            page_token: wire.page_token.0,
            parent_task_id: wire.parent_task_id.0,
            query: wire.query.0,
            resource_id: wire.resource_id.0,
            resource_role: wire.resource_role.0,
            status: wire.status.0,
            task_spec_name: wire.task_spec_name.0,
            worker_pool_id: wire.worker_pool_id.0,
            worker_session_id: wire.worker_session_id.0,
        })
    }
}

/// ListTasksResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListTasksResponse {
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<String>,
    /// Contract field targetResources.
    #[serde(rename = "targetResources")]
    pub target_resources: BTreeMap<String, Vec<TaskResourceReference>>,
    /// Contract field tasks.
    #[serde(rename = "tasks")]
    pub tasks: Vec<Task>,
}
impl<'de> DeserializeStrict<'de> for ListTasksResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<String>>,
            #[serde(rename = "targetResources")]
            target_resources: Strict<BTreeMap<String, Vec<TaskResourceReference>>>,
            #[serde(rename = "tasks")]
            tasks: Strict<Vec<Task>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            next_page_token: wire.next_page_token.0,
            target_resources: wire.target_resources.0,
            tasks: wire.tasks.0,
        })
    }
}

/// ListWorkerAttemptsRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListWorkerAttemptsRequest {
    /// Contract field pageSize.
    #[serde(rename = "pageSize")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_size: Option<u32>,
    /// Contract field pageToken.
    #[serde(rename = "pageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_token: Option<String>,
}
impl<'de> DeserializeStrict<'de> for ListWorkerAttemptsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "pageSize")]
            #[serde(default)]
            page_size: Strict<Option<u32>>,
            #[serde(rename = "pageToken")]
            #[serde(default)]
            page_token: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            page_size: wire.page_size.0,
            page_token: wire.page_token.0,
        })
    }
}

/// ListWorkerAttemptsResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListWorkerAttemptsResponse {
    /// Contract field attempts.
    #[serde(rename = "attempts")]
    pub attempts: Vec<WorkerAttempt>,
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<String>,
}
impl<'de> DeserializeStrict<'de> for ListWorkerAttemptsResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attempts")]
            attempts: Strict<Vec<WorkerAttempt>>,
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempts: wire.attempts.0,
            next_page_token: wire.next_page_token.0,
        })
    }
}

/// ListWorkerPoolsRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListWorkerPoolsRequest {
    /// Contract field pageSize.
    #[serde(rename = "pageSize")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_size: Option<u32>,
    /// Contract field pageToken.
    #[serde(rename = "pageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_token: Option<String>,
    /// Contract field workerPoolId.
    #[serde(rename = "workerPoolId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub worker_pool_id: Option<Uuid>,
}
impl<'de> DeserializeStrict<'de> for ListWorkerPoolsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "pageSize")]
            #[serde(default)]
            page_size: Strict<Option<u32>>,
            #[serde(rename = "pageToken")]
            #[serde(default)]
            page_token: Strict<Option<String>>,
            #[serde(rename = "workerPoolId")]
            #[serde(default)]
            worker_pool_id: Strict<Option<Uuid>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            page_size: wire.page_size.0,
            page_token: wire.page_token.0,
            worker_pool_id: wire.worker_pool_id.0,
        })
    }
}

/// ListWorkerPoolsResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListWorkerPoolsResponse {
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<String>,
    /// Contract field stats.
    #[serde(rename = "stats")]
    pub stats: Vec<WorkerPoolStats>,
    /// Contract field workerPools.
    #[serde(rename = "workerPools")]
    pub worker_pools: Vec<WorkerPool>,
}
impl<'de> DeserializeStrict<'de> for ListWorkerPoolsResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<String>>,
            #[serde(rename = "stats")]
            stats: Strict<Vec<WorkerPoolStats>>,
            #[serde(rename = "workerPools")]
            worker_pools: Strict<Vec<WorkerPool>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            next_page_token: wire.next_page_token.0,
            stats: wire.stats.0,
            worker_pools: wire.worker_pools.0,
        })
    }
}

/// ListWorkerSessionsRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListWorkerSessionsRequest {
    /// Contract field pageSize.
    #[serde(rename = "pageSize")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_size: Option<u32>,
    /// Contract field pageToken.
    #[serde(rename = "pageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_token: Option<String>,
    /// Contract field status.
    #[serde(rename = "status")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<WorkerSessionStatus>,
    /// Contract field workerPoolId.
    #[serde(rename = "workerPoolId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub worker_pool_id: Option<Uuid>,
}
impl<'de> DeserializeStrict<'de> for ListWorkerSessionsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "pageSize")]
            #[serde(default)]
            page_size: Strict<Option<u32>>,
            #[serde(rename = "pageToken")]
            #[serde(default)]
            page_token: Strict<Option<String>>,
            #[serde(rename = "status")]
            #[serde(default)]
            status: Strict<Option<WorkerSessionStatus>>,
            #[serde(rename = "workerPoolId")]
            #[serde(default)]
            worker_pool_id: Strict<Option<Uuid>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            page_size: wire.page_size.0,
            page_token: wire.page_token.0,
            status: wire.status.0,
            worker_pool_id: wire.worker_pool_id.0,
        })
    }
}

/// ListWorkerSessionsResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListWorkerSessionsResponse {
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<String>,
    /// Contract field workerSessions.
    #[serde(rename = "workerSessions")]
    pub worker_sessions: Vec<WorkerSession>,
}
impl<'de> DeserializeStrict<'de> for ListWorkerSessionsResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<String>>,
            #[serde(rename = "workerSessions")]
            worker_sessions: Strict<Vec<WorkerSession>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            next_page_token: wire.next_page_token.0,
            worker_sessions: wire.worker_sessions.0,
        })
    }
}

/// List a Location's root, reconcile its inventory by path, and publish the inventory and a refresh
/// Location version in one commit. The read target must be latestOnBranch.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct LocationRefreshDefinition {
    /// Contract field locationResourceId.
    #[serde(rename = "locationResourceId")]
    pub location_resource_id: Uuid,
    /// Contract field readTarget.
    #[serde(rename = "readTarget")]
    pub read_target: TaskReadTarget,
}
impl<'de> DeserializeStrict<'de> for LocationRefreshDefinition {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "locationResourceId")]
            location_resource_id: Strict<Uuid>,
            #[serde(rename = "readTarget")]
            read_target: Strict<TaskReadTarget>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            location_resource_id: wire.location_resource_id.0,
            read_target: wire.read_target.0,
        })
    }
}

/// MaintenanceTaskProgress contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct MaintenanceTaskProgress {
    /// Contract field compaction.
    #[serde(rename = "compaction")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compaction: Option<ColumnGroupCompactionProgress>,
    /// Contract field completed.
    #[serde(rename = "completed")]
    pub completed: SafeUnsignedLong,
    /// Contract field deletionApplication.
    #[serde(rename = "deletionApplication")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deletion_application: Option<DeletionApplicationProgress>,
    /// Contract field lastCompactionCommit.
    #[serde(rename = "lastCompactionCommit")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_compaction_commit: Option<ColumnGroupCompactionCommit>,
    /// Contract field pass.
    #[serde(rename = "pass")]
    pub pass: u32,
    /// Contract field stage.
    #[serde(rename = "stage")]
    pub stage: MaintenanceTaskStage,
    /// Contract field total.
    #[serde(rename = "total")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<SafeUnsignedLong>,
}
impl<'de> DeserializeStrict<'de> for MaintenanceTaskProgress {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "compaction")]
            #[serde(default)]
            compaction: Strict<Option<ColumnGroupCompactionProgress>>,
            #[serde(rename = "completed")]
            completed: Strict<SafeUnsignedLong>,
            #[serde(rename = "deletionApplication")]
            #[serde(default)]
            deletion_application: Strict<Option<DeletionApplicationProgress>>,
            #[serde(rename = "lastCompactionCommit")]
            #[serde(default)]
            last_compaction_commit: Strict<Option<ColumnGroupCompactionCommit>>,
            #[serde(rename = "pass")]
            pass: Strict<u32>,
            #[serde(rename = "stage")]
            stage: Strict<MaintenanceTaskStage>,
            #[serde(rename = "total")]
            #[serde(default)]
            total: Strict<Option<SafeUnsignedLong>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            compaction: wire.compaction.0,
            completed: wire.completed.0,
            deletion_application: wire.deletion_application.0,
            last_compaction_commit: wire.last_compaction_commit.0,
            pass: wire.pass.0,
            stage: wire.stage.0,
            total: wire.total.0,
        })
    }
}

/// MaintenanceTaskStage contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum MaintenanceTaskStage {
    /// A known contract value.
    ReadingSnapshot,
    /// A known contract value.
    FlushingWal,
    /// A known contract value.
    Planning,
    /// A known contract value.
    PreparingCompaction,
    /// A known contract value.
    Compacting,
    /// A known contract value.
    CompactingKeySpaces,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for MaintenanceTaskStage {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::ReadingSnapshot => "reading_snapshot",
            Self::FlushingWal => "flushing_wal",
            Self::Planning => "planning",
            Self::PreparingCompaction => "preparing_compaction",
            Self::Compacting => "compacting",
            Self::CompactingKeySpaces => "compacting_key_spaces",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for MaintenanceTaskStage {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "reading_snapshot" => Self::ReadingSnapshot,
            "flushing_wal" => Self::FlushingWal,
            "planning" => Self::Planning,
            "preparing_compaction" => Self::PreparingCompaction,
            "compacting" => Self::Compacting,
            "compacting_key_spaces" => Self::CompactingKeySpaces,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for MaintenanceTaskStage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "reading_snapshot")]
            ReadingSnapshot,
            #[serde(rename = "flushing_wal")]
            FlushingWal,
            #[serde(rename = "planning")]
            Planning,
            #[serde(rename = "preparing_compaction")]
            PreparingCompaction,
            #[serde(rename = "compacting")]
            Compacting,
            #[serde(rename = "compacting_key_spaces")]
            CompactingKeySpaces,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::ReadingSnapshot => Self::ReadingSnapshot,
            __Known::FlushingWal => Self::FlushingWal,
            __Known::Planning => Self::Planning,
            __Known::PreparingCompaction => Self::PreparingCompaction,
            __Known::Compacting => Self::Compacting,
            __Known::CompactingKeySpaces => Self::CompactingKeySpaces,
        })
    }
}

/// PollTaskResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PollTaskResponse {
    /// Contract field task.
    #[serde(rename = "task")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub task: Option<WorkerTask>,
}
impl<'de> DeserializeStrict<'de> for PollTaskResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "task")]
            #[serde(default)]
            task: Strict<Option<WorkerTask>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self { task: wire.task.0 })
    }
}

/// PublishedVersion contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PublishedVersion {
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    pub resource_id: Uuid,
    /// Contract field versionId.
    #[serde(rename = "versionId")]
    pub version_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for PublishedVersion {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "resourceId")]
            resource_id: Strict<Uuid>,
            #[serde(rename = "versionId")]
            version_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            resource_id: wire.resource_id.0,
            version_id: wire.version_id.0,
        })
    }
}

/// RegisterWorkerRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RegisterWorkerRequest {
    /// Contract field capabilities.
    #[serde(rename = "capabilities")]
    pub capabilities: WorkerCapabilities,
    /// Contract field processInstanceId.
    #[serde(rename = "processInstanceId")]
    pub process_instance_id: Uuid,
    /// Contract field projectId.
    #[serde(rename = "projectId")]
    pub project_id: String,
    /// Contract field releaseVersion.
    #[serde(rename = "releaseVersion")]
    pub release_version: String,
    /// Contract field tags.
    #[serde(rename = "tags")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<WorkerSessionTags>,
    /// Contract field workerPoolId.
    #[serde(rename = "workerPoolId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub worker_pool_id: Option<Uuid>,
}
impl<'de> DeserializeStrict<'de> for RegisterWorkerRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "capabilities")]
            capabilities: Strict<WorkerCapabilities>,
            #[serde(rename = "processInstanceId")]
            process_instance_id: Strict<Uuid>,
            #[serde(rename = "projectId")]
            project_id: Strict<String>,
            #[serde(rename = "releaseVersion")]
            release_version: Strict<String>,
            #[serde(rename = "tags")]
            #[serde(default)]
            tags: Strict<Option<WorkerSessionTags>>,
            #[serde(rename = "workerPoolId")]
            #[serde(default)]
            worker_pool_id: Strict<Option<Uuid>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            capabilities: wire.capabilities.0,
            process_instance_id: wire.process_instance_id.0,
            project_id: wire.project_id.0,
            release_version: wire.release_version.0,
            tags: wire.tags.0,
            worker_pool_id: wire.worker_pool_id.0,
        })
    }
}

/// RegisterWorkerResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RegisterWorkerResponse {
    /// Contract field workerSession.
    #[serde(rename = "workerSession")]
    pub worker_session: WorkerSession,
}
impl<'de> DeserializeStrict<'de> for RegisterWorkerResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "workerSession")]
            worker_session: Strict<WorkerSession>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            worker_session: wire.worker_session.0,
        })
    }
}

/// ResourceEventType contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ResourceEventType {
    /// A known contract value.
    ResourceUpdated,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for ResourceEventType {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::ResourceUpdated => "resource_updated",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for ResourceEventType {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "resource_updated" => Self::ResourceUpdated,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for ResourceEventType {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "resource_updated")]
            ResourceUpdated,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::ResourceUpdated => Self::ResourceUpdated,
        })
    }
}

/// ResourceProfile contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ResourceProfile {
    /// A known contract value.
    Cpu1,
    /// A known contract value.
    Cpu2,
    /// A known contract value.
    Cpu4,
    /// A known contract value.
    Cpu8,
    /// A known contract value.
    Cpu16,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for ResourceProfile {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Cpu1 => "cpu_1",
            Self::Cpu2 => "cpu_2",
            Self::Cpu4 => "cpu_4",
            Self::Cpu8 => "cpu_8",
            Self::Cpu16 => "cpu_16",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for ResourceProfile {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "cpu_1" => Self::Cpu1,
            "cpu_2" => Self::Cpu2,
            "cpu_4" => Self::Cpu4,
            "cpu_8" => Self::Cpu8,
            "cpu_16" => Self::Cpu16,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for ResourceProfile {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "cpu_1")]
            Cpu1,
            #[serde(rename = "cpu_2")]
            Cpu2,
            #[serde(rename = "cpu_4")]
            Cpu4,
            #[serde(rename = "cpu_8")]
            Cpu8,
            #[serde(rename = "cpu_16")]
            Cpu16,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Cpu1 => Self::Cpu1,
            __Known::Cpu2 => Self::Cpu2,
            __Known::Cpu4 => Self::Cpu4,
            __Known::Cpu8 => Self::Cpu8,
            __Known::Cpu16 => Self::Cpu16,
        })
    }
}

/// ResourceProfileDetails contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResourceProfileDetails {
    /// Contract field cpu.
    #[serde(rename = "cpu")]
    pub cpu: u32,
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: ResourceProfile,
    /// Contract field memoryGib.
    #[serde(rename = "memoryGib")]
    pub memory_gib: SafeUnsignedLong,
}
impl<'de> DeserializeStrict<'de> for ResourceProfileDetails {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "cpu")]
            cpu: Strict<u32>,
            #[serde(rename = "id")]
            id: Strict<ResourceProfile>,
            #[serde(rename = "memoryGib")]
            memory_gib: Strict<SafeUnsignedLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            cpu: wire.cpu.0,
            id: wire.id.0,
            memory_gib: wire.memory_gib.0,
        })
    }
}

/// ResourceUsage contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResourceUsage {
    /// Contract field cpuLimitMillicores.
    #[serde(rename = "cpuLimitMillicores")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu_limit_millicores: Option<SafeUnsignedLong>,
    /// Contract field cpuTimeMicros.
    #[serde(rename = "cpuTimeMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu_time_micros: Option<SafeUnsignedLong>,
    /// Contract field durationMicros.
    #[serde(rename = "durationMicros")]
    pub duration_micros: SafeUnsignedLong,
    /// Contract field memoryBytes.
    #[serde(rename = "memoryBytes")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory_bytes: Option<SafeUnsignedLong>,
    /// Contract field memoryLimitBytes.
    #[serde(rename = "memoryLimitBytes")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory_limit_bytes: Option<SafeUnsignedLong>,
    /// Contract field observedAtMicros.
    #[serde(rename = "observedAtMicros")]
    pub observed_at_micros: SafeLong,
    /// Contract field peakMemoryBytes.
    #[serde(rename = "peakMemoryBytes")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub peak_memory_bytes: Option<SafeUnsignedLong>,
    /// Contract field sequence.
    #[serde(rename = "sequence")]
    pub sequence: SafeUnsignedLong,
    /// Contract field source.
    #[serde(rename = "source")]
    pub source: ResourceUsageSource,
}
impl<'de> DeserializeStrict<'de> for ResourceUsage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "cpuLimitMillicores")]
            #[serde(default)]
            cpu_limit_millicores: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "cpuTimeMicros")]
            #[serde(default)]
            cpu_time_micros: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "durationMicros")]
            duration_micros: Strict<SafeUnsignedLong>,
            #[serde(rename = "memoryBytes")]
            #[serde(default)]
            memory_bytes: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "memoryLimitBytes")]
            #[serde(default)]
            memory_limit_bytes: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "observedAtMicros")]
            observed_at_micros: Strict<SafeLong>,
            #[serde(rename = "peakMemoryBytes")]
            #[serde(default)]
            peak_memory_bytes: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "sequence")]
            sequence: Strict<SafeUnsignedLong>,
            #[serde(rename = "source")]
            source: Strict<ResourceUsageSource>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            cpu_limit_millicores: wire.cpu_limit_millicores.0,
            cpu_time_micros: wire.cpu_time_micros.0,
            duration_micros: wire.duration_micros.0,
            memory_bytes: wire.memory_bytes.0,
            memory_limit_bytes: wire.memory_limit_bytes.0,
            observed_at_micros: wire.observed_at_micros.0,
            peak_memory_bytes: wire.peak_memory_bytes.0,
            sequence: wire.sequence.0,
            source: wire.source.0,
        })
    }
}

/// ResourceUsageHistory contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResourceUsageHistory {
    /// Contract field attempts.
    #[serde(rename = "attempts")]
    pub attempts: Vec<WorkerAttempt>,
    /// Contract field fromMicros.
    #[serde(rename = "fromMicros")]
    pub from_micros: SafeLong,
    /// Contract field points.
    #[serde(rename = "points")]
    pub points: Vec<ResourceUsageSummary>,
    /// Contract field resolutionMicros.
    #[serde(rename = "resolutionMicros")]
    pub resolution_micros: SafeLong,
    /// Contract field toMicros.
    #[serde(rename = "toMicros")]
    pub to_micros: SafeLong,
}
impl<'de> DeserializeStrict<'de> for ResourceUsageHistory {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attempts")]
            attempts: Strict<Vec<WorkerAttempt>>,
            #[serde(rename = "fromMicros")]
            from_micros: Strict<SafeLong>,
            #[serde(rename = "points")]
            points: Strict<Vec<ResourceUsageSummary>>,
            #[serde(rename = "resolutionMicros")]
            resolution_micros: Strict<SafeLong>,
            #[serde(rename = "toMicros")]
            to_micros: Strict<SafeLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempts: wire.attempts.0,
            from_micros: wire.from_micros.0,
            points: wire.points.0,
            resolution_micros: wire.resolution_micros.0,
            to_micros: wire.to_micros.0,
        })
    }
}

/// ResourceUsageRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResourceUsageRequest {
    /// Contract field attemptId.
    #[serde(rename = "attemptId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attempt_id: Option<Uuid>,
}
impl<'de> DeserializeStrict<'de> for ResourceUsageRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attemptId")]
            #[serde(default)]
            attempt_id: Strict<Option<Uuid>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt_id: wire.attempt_id.0,
        })
    }
}

/// ResourceUsageSource contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ResourceUsageSource {
    /// A known contract value.
    Cgroup,
    /// A known contract value.
    ProcessTree,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for ResourceUsageSource {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Cgroup => "cgroup",
            Self::ProcessTree => "process_tree",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for ResourceUsageSource {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "cgroup" => Self::Cgroup,
            "process_tree" => Self::ProcessTree,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for ResourceUsageSource {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "cgroup")]
            Cgroup,
            #[serde(rename = "process_tree")]
            ProcessTree,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Cgroup => Self::Cgroup,
            __Known::ProcessTree => Self::ProcessTree,
        })
    }
}

/// ResourceUsageSummary contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResourceUsageSummary {
    /// Contract field cpuObservedMicros.
    #[serde(rename = "cpuObservedMicros")]
    pub cpu_observed_micros: SafeUnsignedLong,
    /// Contract field cpuTimeMicros.
    #[serde(rename = "cpuTimeMicros")]
    pub cpu_time_micros: SafeUnsignedLong,
    /// Contract field latest.
    #[serde(rename = "latest")]
    pub latest: ResourceUsage,
    /// Contract field peakMemoryBytes.
    #[serde(rename = "peakMemoryBytes")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub peak_memory_bytes: Option<SafeUnsignedLong>,
    /// Contract field receivedAtMicros.
    #[serde(rename = "receivedAtMicros")]
    pub received_at_micros: SafeLong,
}
impl<'de> DeserializeStrict<'de> for ResourceUsageSummary {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "cpuObservedMicros")]
            cpu_observed_micros: Strict<SafeUnsignedLong>,
            #[serde(rename = "cpuTimeMicros")]
            cpu_time_micros: Strict<SafeUnsignedLong>,
            #[serde(rename = "latest")]
            latest: Strict<ResourceUsage>,
            #[serde(rename = "peakMemoryBytes")]
            #[serde(default)]
            peak_memory_bytes: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "receivedAtMicros")]
            received_at_micros: Strict<SafeLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            cpu_observed_micros: wire.cpu_observed_micros.0,
            cpu_time_micros: wire.cpu_time_micros.0,
            latest: wire.latest.0,
            peak_memory_bytes: wire.peak_memory_bytes.0,
            received_at_micros: wire.received_at_micros.0,
        })
    }
}

/// RunTriggerRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RunTriggerRequest {
    /// Contract field requestId.
    #[serde(rename = "requestId")]
    pub request_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for RunTriggerRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "requestId")]
            request_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            request_id: wire.request_id.0,
        })
    }
}

/// SubmitTaskRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct SubmitTaskRequest {
    /// Contract field claim.
    #[serde(rename = "claim")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claim: Option<TaskClaim>,
    /// Contract field definition.
    #[serde(rename = "definition")]
    pub definition: TaskDefinition,
    /// Contract field idempotencyKey.
    #[serde(rename = "idempotencyKey")]
    pub idempotency_key: String,
    /// Contract field options.
    #[serde(rename = "options")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<TaskOptions>,
    /// Contract field parentTaskId.
    #[serde(rename = "parentTaskId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_task_id: Option<Uuid>,
}
impl<'de> DeserializeStrict<'de> for SubmitTaskRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "claim")]
            #[serde(default)]
            claim: Strict<Option<TaskClaim>>,
            #[serde(rename = "definition")]
            definition: Strict<TaskDefinition>,
            #[serde(rename = "idempotencyKey")]
            idempotency_key: Strict<String>,
            #[serde(rename = "options")]
            #[serde(default)]
            options: Strict<Option<TaskOptions>>,
            #[serde(rename = "parentTaskId")]
            #[serde(default)]
            parent_task_id: Strict<Option<Uuid>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            claim: wire.claim.0,
            definition: wire.definition.0,
            idempotency_key: wire.idempotency_key.0,
            options: wire.options.0,
            parent_task_id: wire.parent_task_id.0,
        })
    }
}

/// Compact and recluster the latest state of one Table branch, publishing each step as a new Table
/// version. The read target must be latestOnBranch.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TableMaintenanceDefinition {
    /// Contract field readTarget.
    #[serde(rename = "readTarget")]
    pub read_target: TaskReadTarget,
    /// Contract field tableResourceId.
    #[serde(rename = "tableResourceId")]
    pub table_resource_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for TableMaintenanceDefinition {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "readTarget")]
            read_target: Strict<TaskReadTarget>,
            #[serde(rename = "tableResourceId")]
            table_resource_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            read_target: wire.read_target.0,
            table_resource_id: wire.table_resource_id.0,
        })
    }
}

/// One durable Task. claim is absent only from servers that predate it.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Task {
    /// Contract field attemptCount.
    #[serde(rename = "attemptCount")]
    pub attempt_count: u32,
    /// Contract field availableAtMicros.
    #[serde(rename = "availableAtMicros")]
    pub available_at_micros: SafeLong,
    /// Contract field buffered.
    #[serde(rename = "buffered")]
    pub buffered: bool,
    /// Contract field cancellationReason.
    #[serde(rename = "cancellationReason")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cancellation_reason: Option<TaskCancellationReason>,
    /// Contract field cancelledBy.
    #[serde(rename = "cancelledBy")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cancelled_by: Option<Caller>,
    /// Contract field claim.
    #[serde(rename = "claim")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claim: Option<TaskClaim>,
    /// Contract field createdAtMicros.
    #[serde(rename = "createdAtMicros")]
    pub created_at_micros: SafeLong,
    /// Contract field currentAttemptId.
    #[serde(rename = "currentAttemptId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub current_attempt_id: Option<Uuid>,
    /// Contract field deadlineAtMicros.
    #[serde(rename = "deadlineAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deadline_at_micros: Option<SafeLong>,
    /// Contract field definition.
    #[serde(rename = "definition")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub definition: Option<TaskDefinition>,
    /// Contract field failure.
    #[serde(rename = "failure")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub failure: Option<TaskFailure>,
    /// Contract field latestWorker.
    #[serde(rename = "latestWorker")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub latest_worker: Option<TaskWorker>,
    /// Contract field legacyTableId.
    #[serde(rename = "legacyTableId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub legacy_table_id: Option<String>,
    /// Contract field maxAttempts.
    #[serde(rename = "maxAttempts")]
    pub max_attempts: u32,
    /// Contract field maximumAttemptDurationMicros.
    #[serde(rename = "maximumAttemptDurationMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub maximum_attempt_duration_micros: Option<SafeLong>,
    /// Contract field parentTaskId.
    #[serde(rename = "parentTaskId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_task_id: Option<Uuid>,
    /// Contract field pendingExpiresAtMicros.
    #[serde(rename = "pendingExpiresAtMicros")]
    pub pending_expires_at_micros: SafeLong,
    /// Contract field projectId.
    #[serde(rename = "projectId")]
    pub project_id: String,
    /// Contract field published.
    #[serde(rename = "published")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub published: Option<TaskResult>,
    /// Contract field requestedBy.
    #[serde(rename = "requestedBy")]
    pub requested_by: Caller,
    /// Contract field requirements.
    #[serde(rename = "requirements")]
    pub requirements: TaskRequirements,
    /// Contract field result.
    #[serde(rename = "result")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub result: Option<Value>,
    /// Contract field startedAtMicros.
    #[serde(rename = "startedAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub started_at_micros: Option<SafeLong>,
    /// Contract field status.
    #[serde(rename = "status")]
    pub status: TaskStatus,
    /// Contract field stopDeadlineAtMicros.
    #[serde(rename = "stopDeadlineAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stop_deadline_at_micros: Option<SafeLong>,
    /// Contract field stopReason.
    #[serde(rename = "stopReason")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stop_reason: Option<TaskStopReason>,
    /// Contract field stopRequestedAtMicros.
    #[serde(rename = "stopRequestedAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stop_requested_at_micros: Option<SafeLong>,
    /// Contract field taskId.
    #[serde(rename = "taskId")]
    pub task_id: Uuid,
    /// Contract field taskSpecId.
    #[serde(rename = "taskSpecId")]
    pub task_spec_id: TaskSpecId,
    /// Contract field terminalAtMicros.
    #[serde(rename = "terminalAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub terminal_at_micros: Option<SafeLong>,
    /// Contract field updatedAtMicros.
    #[serde(rename = "updatedAtMicros")]
    pub updated_at_micros: SafeLong,
    /// Contract field workerPoolClaimExpiresAtMicros.
    #[serde(rename = "workerPoolClaimExpiresAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub worker_pool_claim_expires_at_micros: Option<SafeLong>,
    /// Contract field workerPoolId.
    #[serde(rename = "workerPoolId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub worker_pool_id: Option<Uuid>,
}
impl<'de> DeserializeStrict<'de> for Task {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attemptCount")]
            attempt_count: Strict<u32>,
            #[serde(rename = "availableAtMicros")]
            available_at_micros: Strict<SafeLong>,
            #[serde(rename = "buffered")]
            buffered: Strict<bool>,
            #[serde(rename = "cancellationReason")]
            #[serde(default)]
            cancellation_reason: Strict<Option<TaskCancellationReason>>,
            #[serde(rename = "cancelledBy")]
            #[serde(default)]
            cancelled_by: Strict<Option<Caller>>,
            #[serde(rename = "claim")]
            #[serde(default)]
            claim: Strict<Option<TaskClaim>>,
            #[serde(rename = "createdAtMicros")]
            created_at_micros: Strict<SafeLong>,
            #[serde(rename = "currentAttemptId")]
            #[serde(default)]
            current_attempt_id: Strict<Option<Uuid>>,
            #[serde(rename = "deadlineAtMicros")]
            #[serde(default)]
            deadline_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "definition")]
            #[serde(default)]
            definition: Strict<Option<TaskDefinition>>,
            #[serde(rename = "failure")]
            #[serde(default)]
            failure: Strict<Option<TaskFailure>>,
            #[serde(rename = "latestWorker")]
            #[serde(default)]
            latest_worker: Strict<Option<TaskWorker>>,
            #[serde(rename = "legacyTableId")]
            #[serde(default)]
            legacy_table_id: Strict<Option<String>>,
            #[serde(rename = "maxAttempts")]
            max_attempts: Strict<u32>,
            #[serde(rename = "maximumAttemptDurationMicros")]
            #[serde(default)]
            maximum_attempt_duration_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "parentTaskId")]
            #[serde(default)]
            parent_task_id: Strict<Option<Uuid>>,
            #[serde(rename = "pendingExpiresAtMicros")]
            pending_expires_at_micros: Strict<SafeLong>,
            #[serde(rename = "projectId")]
            project_id: Strict<String>,
            #[serde(rename = "published")]
            #[serde(default)]
            published: Strict<Option<TaskResult>>,
            #[serde(rename = "requestedBy")]
            requested_by: Strict<Caller>,
            #[serde(rename = "requirements")]
            requirements: Strict<TaskRequirements>,
            #[serde(rename = "result")]
            #[serde(default)]
            result: Strict<Option<Value>>,
            #[serde(rename = "startedAtMicros")]
            #[serde(default)]
            started_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "status")]
            status: Strict<TaskStatus>,
            #[serde(rename = "stopDeadlineAtMicros")]
            #[serde(default)]
            stop_deadline_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "stopReason")]
            #[serde(default)]
            stop_reason: Strict<Option<TaskStopReason>>,
            #[serde(rename = "stopRequestedAtMicros")]
            #[serde(default)]
            stop_requested_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "taskId")]
            task_id: Strict<Uuid>,
            #[serde(rename = "taskSpecId")]
            task_spec_id: Strict<TaskSpecId>,
            #[serde(rename = "terminalAtMicros")]
            #[serde(default)]
            terminal_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "updatedAtMicros")]
            updated_at_micros: Strict<SafeLong>,
            #[serde(rename = "workerPoolClaimExpiresAtMicros")]
            #[serde(default)]
            worker_pool_claim_expires_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "workerPoolId")]
            #[serde(default)]
            worker_pool_id: Strict<Option<Uuid>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt_count: wire.attempt_count.0,
            available_at_micros: wire.available_at_micros.0,
            buffered: wire.buffered.0,
            cancellation_reason: wire.cancellation_reason.0,
            cancelled_by: wire.cancelled_by.0,
            claim: wire.claim.0,
            created_at_micros: wire.created_at_micros.0,
            current_attempt_id: wire.current_attempt_id.0,
            deadline_at_micros: wire.deadline_at_micros.0,
            definition: wire.definition.0,
            failure: wire.failure.0,
            latest_worker: wire.latest_worker.0,
            legacy_table_id: wire.legacy_table_id.0,
            max_attempts: wire.max_attempts.0,
            maximum_attempt_duration_micros: wire.maximum_attempt_duration_micros.0,
            parent_task_id: wire.parent_task_id.0,
            pending_expires_at_micros: wire.pending_expires_at_micros.0,
            project_id: wire.project_id.0,
            published: wire.published.0,
            requested_by: wire.requested_by.0,
            requirements: wire.requirements.0,
            result: wire.result.0,
            started_at_micros: wire.started_at_micros.0,
            status: wire.status.0,
            stop_deadline_at_micros: wire.stop_deadline_at_micros.0,
            stop_reason: wire.stop_reason.0,
            stop_requested_at_micros: wire.stop_requested_at_micros.0,
            task_id: wire.task_id.0,
            task_spec_id: wire.task_spec_id.0,
            terminal_at_micros: wire.terminal_at_micros.0,
            updated_at_micros: wire.updated_at_micros.0,
            worker_pool_claim_expires_at_micros: wire.worker_pool_claim_expires_at_micros.0,
            worker_pool_id: wire.worker_pool_id.0,
        })
    }
}

/// TaskAttempt contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskAttempt {
    /// Contract field attemptDeadlineAtMicros.
    #[serde(rename = "attemptDeadlineAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attempt_deadline_at_micros: Option<SafeLong>,
    /// Contract field attemptId.
    #[serde(rename = "attemptId")]
    pub attempt_id: Uuid,
    /// Contract field failure.
    #[serde(rename = "failure")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub failure: Option<TaskFailure>,
    /// Contract field lastHeartbeatAtMicros.
    #[serde(rename = "lastHeartbeatAtMicros")]
    pub last_heartbeat_at_micros: SafeLong,
    /// Contract field leaseExpiresAtMicros.
    #[serde(rename = "leaseExpiresAtMicros")]
    pub lease_expires_at_micros: SafeLong,
    /// Contract field ordinal.
    #[serde(rename = "ordinal")]
    pub ordinal: u32,
    /// Contract field progress.
    #[serde(rename = "progress")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub progress: Option<TaskProgress>,
    /// Contract field resourceUsage.
    #[serde(rename = "resourceUsage")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_usage: Option<ResourceUsageSummary>,
    /// Contract field startedAtMicros.
    #[serde(rename = "startedAtMicros")]
    pub started_at_micros: SafeLong,
    /// Contract field status.
    #[serde(rename = "status")]
    pub status: AttemptStatus,
    /// Contract field taskId.
    #[serde(rename = "taskId")]
    pub task_id: Uuid,
    /// Contract field terminalAtMicros.
    #[serde(rename = "terminalAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub terminal_at_micros: Option<SafeLong>,
    /// Contract field workerSessionId.
    #[serde(rename = "workerSessionId")]
    pub worker_session_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for TaskAttempt {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attemptDeadlineAtMicros")]
            #[serde(default)]
            attempt_deadline_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "attemptId")]
            attempt_id: Strict<Uuid>,
            #[serde(rename = "failure")]
            #[serde(default)]
            failure: Strict<Option<TaskFailure>>,
            #[serde(rename = "lastHeartbeatAtMicros")]
            last_heartbeat_at_micros: Strict<SafeLong>,
            #[serde(rename = "leaseExpiresAtMicros")]
            lease_expires_at_micros: Strict<SafeLong>,
            #[serde(rename = "ordinal")]
            ordinal: Strict<u32>,
            #[serde(rename = "progress")]
            #[serde(default)]
            progress: Strict<Option<TaskProgress>>,
            #[serde(rename = "resourceUsage")]
            #[serde(default)]
            resource_usage: Strict<Option<ResourceUsageSummary>>,
            #[serde(rename = "startedAtMicros")]
            started_at_micros: Strict<SafeLong>,
            #[serde(rename = "status")]
            status: Strict<AttemptStatus>,
            #[serde(rename = "taskId")]
            task_id: Strict<Uuid>,
            #[serde(rename = "terminalAtMicros")]
            #[serde(default)]
            terminal_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "workerSessionId")]
            worker_session_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt_deadline_at_micros: wire.attempt_deadline_at_micros.0,
            attempt_id: wire.attempt_id.0,
            failure: wire.failure.0,
            last_heartbeat_at_micros: wire.last_heartbeat_at_micros.0,
            lease_expires_at_micros: wire.lease_expires_at_micros.0,
            ordinal: wire.ordinal.0,
            progress: wire.progress.0,
            resource_usage: wire.resource_usage.0,
            started_at_micros: wire.started_at_micros.0,
            status: wire.status.0,
            task_id: wire.task_id.0,
            terminal_at_micros: wire.terminal_at_micros.0,
            worker_session_id: wire.worker_session_id.0,
        })
    }
}

/// TaskCancellationReason contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TaskCancellationReason {
    /// A known contract value.
    OverlapSkipped,
    /// A known contract value.
    User,
    /// A known contract value.
    PendingTimeout,
    /// A known contract value.
    ParentCancelled,
    /// A known contract value.
    ParentFailed,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for TaskCancellationReason {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::OverlapSkipped => "overlap_skipped",
            Self::User => "user",
            Self::PendingTimeout => "pending_timeout",
            Self::ParentCancelled => "parent_cancelled",
            Self::ParentFailed => "parent_failed",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for TaskCancellationReason {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "overlap_skipped" => Self::OverlapSkipped,
            "user" => Self::User,
            "pending_timeout" => Self::PendingTimeout,
            "parent_cancelled" => Self::ParentCancelled,
            "parent_failed" => Self::ParentFailed,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for TaskCancellationReason {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "overlap_skipped")]
            OverlapSkipped,
            #[serde(rename = "user")]
            User,
            #[serde(rename = "pending_timeout")]
            PendingTimeout,
            #[serde(rename = "parent_cancelled")]
            ParentCancelled,
            #[serde(rename = "parent_failed")]
            ParentFailed,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::OverlapSkipped => Self::OverlapSkipped,
            __Known::User => Self::User,
            __Known::PendingTimeout => Self::PendingTimeout,
            __Known::ParentCancelled => Self::ParentCancelled,
            __Known::ParentFailed => Self::ParentFailed,
        })
    }
}

/// Who may claim a Task. pool, the default, lets WorkerPools and Workers claim it when their
/// capabilities meet its requirements. submitter reserves it for its submitter: only a Worker
/// session authenticated as the submitter, without a WorkerPool, claims it by ID, and only its
/// installed handlers are checked, since the submitter chose the machine. A submitter-claimed Task
/// that no Worker claims within five minutes of becoming claimable fails with not_claimed.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TaskClaim {
    /// A known contract value.
    Pool,
    /// A known contract value.
    Submitter,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for TaskClaim {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Pool => "pool",
            Self::Submitter => "submitter",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for TaskClaim {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "pool" => Self::Pool,
            "submitter" => Self::Submitter,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for TaskClaim {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "pool")]
            Pool,
            #[serde(rename = "submitter")]
            Submitter,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Pool => Self::Pool,
            __Known::Submitter => Self::Submitter,
        })
    }
}

/// What one Task does. The arm names the kind of Task; each kind has one specification version,
/// which the Task's taskSpecId reports.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TaskDefinition {
    /// A known union arm.
    EnrichmentCompute(EnrichmentComputeDefinition),
    /// A known union arm.
    EnrichmentRefresh(EnrichmentRefreshDefinition),
    /// A known union arm.
    LegacyTableCompactionWorker(LegacyTableCompactionWorkerDefinition),
    /// A known union arm.
    LegacyTableMaintenance(LegacyTableMaintenanceDefinition),
    /// A known union arm.
    LegacyWalFlush(LegacyTableDefinition),
    /// A known union arm.
    LocationRefresh(LocationRefreshDefinition),
    /// A known union arm.
    TableMaintenance(TableMaintenanceDefinition),
    /// A known union arm.
    VectorIndexRefresh(VectorIndexRefreshDefinition),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for TaskDefinition {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::EnrichmentCompute(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("enrichmentCompute".into()));
                object.insert(
                    "enrichmentCompute".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::EnrichmentRefresh(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("enrichmentRefresh".into()));
                object.insert(
                    "enrichmentRefresh".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::LegacyTableCompactionWorker(value) => {
                let mut object = serde_json::Map::new();
                object.insert(
                    "type".into(),
                    Value::String("legacyTableCompactionWorker".into()),
                );
                object.insert(
                    "legacyTableCompactionWorker".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::LegacyTableMaintenance(value) => {
                let mut object = serde_json::Map::new();
                object.insert(
                    "type".into(),
                    Value::String("legacyTableMaintenance".into()),
                );
                object.insert(
                    "legacyTableMaintenance".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::LegacyWalFlush(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("legacyWalFlush".into()));
                object.insert(
                    "legacyWalFlush".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::LocationRefresh(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("locationRefresh".into()));
                object.insert(
                    "locationRefresh".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::TableMaintenance(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("tableMaintenance".into()));
                object.insert(
                    "tableMaintenance".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::VectorIndexRefresh(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("vectorIndexRefresh".into()));
                object.insert(
                    "vectorIndexRefresh".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Unknown { tag, value } => {
                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
                    return Err(serde::ser::Error::custom(
                        "unknown union discriminator mismatch",
                    ));
                }
                value.serialize(serializer)
            }
        }
    }
}
impl<'de> Deserialize<'de> for TaskDefinition {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(Value::as_str)
            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
        match tag {
            "enrichmentCompute" => Ok(Self::EnrichmentCompute(
                serde_json::from_value(
                    value
                        .get("enrichmentCompute")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "enrichmentRefresh" => Ok(Self::EnrichmentRefresh(
                serde_json::from_value(
                    value
                        .get("enrichmentRefresh")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "legacyTableCompactionWorker" => Ok(Self::LegacyTableCompactionWorker(
                serde_json::from_value(
                    value
                        .get("legacyTableCompactionWorker")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "legacyTableMaintenance" => Ok(Self::LegacyTableMaintenance(
                serde_json::from_value(
                    value
                        .get("legacyTableMaintenance")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "legacyWalFlush" => Ok(Self::LegacyWalFlush(
                serde_json::from_value(
                    value
                        .get("legacyWalFlush")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "locationRefresh" => Ok(Self::LocationRefresh(
                serde_json::from_value(
                    value
                        .get("locationRefresh")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "tableMaintenance" => Ok(Self::TableMaintenance(
                serde_json::from_value(
                    value
                        .get("tableMaintenance")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "vectorIndexRefresh" => Ok(Self::VectorIndexRefresh(
                serde_json::from_value(
                    value
                        .get("vectorIndexRefresh")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            tag => Ok(Self::Unknown {
                tag: tag.to_owned(),
                value,
            }),
        }
    }
}
impl<'de> DeserializeStrict<'de> for TaskDefinition {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "enrichmentCompute")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "enrichmentCompute")]
            value: Strict<EnrichmentComputeDefinition>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "enrichmentRefresh")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "enrichmentRefresh")]
            value: Strict<EnrichmentRefreshDefinition>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "legacyTableCompactionWorker")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "legacyTableCompactionWorker")]
            value: Strict<LegacyTableCompactionWorkerDefinition>,
        }
        #[derive(Deserialize)]
        enum __Tag3 {
            #[serde(rename = "legacyTableMaintenance")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm3 {
            #[serde(rename = "type")]
            _tag: __Tag3,
            #[serde(rename = "legacyTableMaintenance")]
            value: Strict<LegacyTableMaintenanceDefinition>,
        }
        #[derive(Deserialize)]
        enum __Tag4 {
            #[serde(rename = "legacyWalFlush")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm4 {
            #[serde(rename = "type")]
            _tag: __Tag4,
            #[serde(rename = "legacyWalFlush")]
            value: Strict<LegacyTableDefinition>,
        }
        #[derive(Deserialize)]
        enum __Tag5 {
            #[serde(rename = "locationRefresh")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm5 {
            #[serde(rename = "type")]
            _tag: __Tag5,
            #[serde(rename = "locationRefresh")]
            value: Strict<LocationRefreshDefinition>,
        }
        #[derive(Deserialize)]
        enum __Tag6 {
            #[serde(rename = "tableMaintenance")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm6 {
            #[serde(rename = "type")]
            _tag: __Tag6,
            #[serde(rename = "tableMaintenance")]
            value: Strict<TableMaintenanceDefinition>,
        }
        #[derive(Deserialize)]
        enum __Tag7 {
            #[serde(rename = "vectorIndexRefresh")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm7 {
            #[serde(rename = "type")]
            _tag: __Tag7,
            #[serde(rename = "vectorIndexRefresh")]
            value: Strict<VectorIndexRefreshDefinition>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            EnrichmentCompute(Box<__Arm0>),
            EnrichmentRefresh(Box<__Arm1>),
            LegacyTableCompactionWorker(Box<__Arm2>),
            LegacyTableMaintenance(Box<__Arm3>),
            LegacyWalFlush(Box<__Arm4>),
            LocationRefresh(Box<__Arm5>),
            TableMaintenance(Box<__Arm6>),
            VectorIndexRefresh(Box<__Arm7>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::EnrichmentCompute(arm) => Self::EnrichmentCompute(arm.value.0),
            __Known::EnrichmentRefresh(arm) => Self::EnrichmentRefresh(arm.value.0),
            __Known::LegacyTableCompactionWorker(arm) => {
                Self::LegacyTableCompactionWorker(arm.value.0)
            }
            __Known::LegacyTableMaintenance(arm) => Self::LegacyTableMaintenance(arm.value.0),
            __Known::LegacyWalFlush(arm) => Self::LegacyWalFlush(arm.value.0),
            __Known::LocationRefresh(arm) => Self::LocationRefresh(arm.value.0),
            __Known::TableMaintenance(arm) => Self::TableMaintenance(arm.value.0),
            __Known::VectorIndexRefresh(arm) => Self::VectorIndexRefresh(arm.value.0),
        })
    }
}

/// TaskDetails contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskDetails {
    /// Contract field attempts.
    #[serde(rename = "attempts")]
    pub attempts: Vec<TaskAttempt>,
    /// Contract field invocation.
    #[serde(rename = "invocation")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub invocation: Option<TriggerInvocation>,
    /// Contract field resources.
    #[serde(rename = "resources")]
    pub resources: Vec<TaskResourceReference>,
    /// Contract field task.
    #[serde(rename = "task")]
    pub task: Task,
}
impl<'de> DeserializeStrict<'de> for TaskDetails {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attempts")]
            attempts: Strict<Vec<TaskAttempt>>,
            #[serde(rename = "invocation")]
            #[serde(default)]
            invocation: Strict<Option<TriggerInvocation>>,
            #[serde(rename = "resources")]
            resources: Strict<Vec<TaskResourceReference>>,
            #[serde(rename = "task")]
            task: Strict<Task>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempts: wire.attempts.0,
            invocation: wire.invocation.0,
            resources: wire.resources.0,
            task: wire.task.0,
        })
    }
}

/// TaskFailure contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskFailure {
    /// Contract field code.
    #[serde(rename = "code")]
    pub code: String,
    /// Contract field message.
    #[serde(rename = "message")]
    pub message: String,
    /// Contract field retryable.
    #[serde(rename = "retryable")]
    pub retryable: bool,
}
impl<'de> DeserializeStrict<'de> for TaskFailure {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "code")]
            code: Strict<String>,
            #[serde(rename = "message")]
            message: Strict<String>,
            #[serde(rename = "retryable")]
            retryable: Strict<bool>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            code: wire.code.0,
            message: wire.message.0,
            retryable: wire.retryable.0,
        })
    }
}

/// TaskOptions contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskOptions {
    /// Contract field deadlineAtMicros.
    #[serde(rename = "deadlineAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deadline_at_micros: Option<SafeLong>,
    /// Contract field maxAttempts.
    #[serde(rename = "maxAttempts")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_attempts: Option<u32>,
    /// Contract field resourceProfile.
    #[serde(rename = "resourceProfile")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_profile: Option<ResourceProfile>,
}
impl<'de> DeserializeStrict<'de> for TaskOptions {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "deadlineAtMicros")]
            #[serde(default)]
            deadline_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "maxAttempts")]
            #[serde(default)]
            max_attempts: Strict<Option<u32>>,
            #[serde(rename = "resourceProfile")]
            #[serde(default)]
            resource_profile: Strict<Option<ResourceProfile>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            deadline_at_micros: wire.deadline_at_micros.0,
            max_attempts: wire.max_attempts.0,
            resource_profile: wire.resource_profile.0,
        })
    }
}

/// TaskOrigin contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TaskOrigin {
    /// A known contract value.
    Manual,
    /// A known contract value.
    Event,
    /// A known contract value.
    Schedule,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for TaskOrigin {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Manual => "manual",
            Self::Event => "event",
            Self::Schedule => "schedule",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for TaskOrigin {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "manual" => Self::Manual,
            "event" => Self::Event,
            "schedule" => Self::Schedule,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for TaskOrigin {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "manual")]
            Manual,
            #[serde(rename = "event")]
            Event,
            #[serde(rename = "schedule")]
            Schedule,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Manual => Self::Manual,
            __Known::Event => Self::Event,
            __Known::Schedule => Self::Schedule,
        })
    }
}

/// TaskOverlapPolicy contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TaskOverlapPolicy {
    /// A known contract value.
    AllowAll,
    /// A known contract value.
    BufferOne,
    /// A known contract value.
    BufferAll,
    /// A known contract value.
    RejectDuplicate,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for TaskOverlapPolicy {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::AllowAll => "allow_all",
            Self::BufferOne => "buffer_one",
            Self::BufferAll => "buffer_all",
            Self::RejectDuplicate => "reject_duplicate",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for TaskOverlapPolicy {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "allow_all" => Self::AllowAll,
            "buffer_one" => Self::BufferOne,
            "buffer_all" => Self::BufferAll,
            "reject_duplicate" => Self::RejectDuplicate,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for TaskOverlapPolicy {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "allow_all")]
            AllowAll,
            #[serde(rename = "buffer_one")]
            BufferOne,
            #[serde(rename = "buffer_all")]
            BufferAll,
            #[serde(rename = "reject_duplicate")]
            RejectDuplicate,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::AllowAll => Self::AllowAll,
            __Known::BufferOne => Self::BufferOne,
            __Known::BufferAll => Self::BufferAll,
            __Known::RejectDuplicate => Self::RejectDuplicate,
        })
    }
}

/// TaskProgress contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskProgress {
    /// Contract field maintenance.
    #[serde(rename = "maintenance")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub maintenance: Option<MaintenanceTaskProgress>,
    /// Contract field percentage.
    #[serde(rename = "percentage")]
    pub percentage: u32,
    /// Contract field phase.
    #[serde(rename = "phase")]
    pub phase: TaskProgressPhase,
    /// Contract field work.
    #[serde(rename = "work")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub work: Option<TaskWorkProgress>,
}
impl<'de> DeserializeStrict<'de> for TaskProgress {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "maintenance")]
            #[serde(default)]
            maintenance: Strict<Option<MaintenanceTaskProgress>>,
            #[serde(rename = "percentage")]
            percentage: Strict<u32>,
            #[serde(rename = "phase")]
            phase: Strict<TaskProgressPhase>,
            #[serde(rename = "work")]
            #[serde(default)]
            work: Strict<Option<TaskWorkProgress>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            maintenance: wire.maintenance.0,
            percentage: wire.percentage.0,
            phase: wire.phase.0,
            work: wire.work.0,
        })
    }
}

/// TaskProgressPhase contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TaskProgressPhase {
    /// A known contract value.
    Preparing,
    /// A known contract value.
    Computing,
    /// A known contract value.
    Finalizing,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for TaskProgressPhase {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Preparing => "preparing",
            Self::Computing => "computing",
            Self::Finalizing => "finalizing",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for TaskProgressPhase {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "preparing" => Self::Preparing,
            "computing" => Self::Computing,
            "finalizing" => Self::Finalizing,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for TaskProgressPhase {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "preparing")]
            Preparing,
            #[serde(rename = "computing")]
            Computing,
            #[serde(rename = "finalizing")]
            Finalizing,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Preparing => Self::Preparing,
            __Known::Computing => Self::Computing,
            __Known::Finalizing => Self::Finalizing,
        })
    }
}

/// TaskReadTarget contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TaskReadTarget {
    /// A known union arm.
    CommitOnBranch(TaskReadTargetCommitOnBranch),
    /// A known union arm.
    LatestOnBranch(TaskReadTargetLatestOnBranch),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for TaskReadTarget {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::CommitOnBranch(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("commitOnBranch".into()));
                object.insert(
                    "commitOnBranch".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::LatestOnBranch(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("latestOnBranch".into()));
                object.insert(
                    "latestOnBranch".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Unknown { tag, value } => {
                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
                    return Err(serde::ser::Error::custom(
                        "unknown union discriminator mismatch",
                    ));
                }
                value.serialize(serializer)
            }
        }
    }
}
impl<'de> Deserialize<'de> for TaskReadTarget {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(Value::as_str)
            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
        match tag {
            "commitOnBranch" => Ok(Self::CommitOnBranch(
                serde_json::from_value(
                    value
                        .get("commitOnBranch")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "latestOnBranch" => Ok(Self::LatestOnBranch(
                serde_json::from_value(
                    value
                        .get("latestOnBranch")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            tag => Ok(Self::Unknown {
                tag: tag.to_owned(),
                value,
            }),
        }
    }
}
impl<'de> DeserializeStrict<'de> for TaskReadTarget {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "commitOnBranch")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "commitOnBranch")]
            value: Strict<TaskReadTargetCommitOnBranch>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "latestOnBranch")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "latestOnBranch")]
            value: Strict<TaskReadTargetLatestOnBranch>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            CommitOnBranch(Box<__Arm0>),
            LatestOnBranch(Box<__Arm1>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::CommitOnBranch(arm) => Self::CommitOnBranch(arm.value.0),
            __Known::LatestOnBranch(arm) => Self::LatestOnBranch(arm.value.0),
        })
    }
}

/// TaskReadTargetCommitOnBranch contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskReadTargetCommitOnBranch {
    /// Contract field branchId.
    #[serde(rename = "branchId")]
    pub branch_id: Uuid,
    /// Contract field commitId.
    #[serde(rename = "commitId")]
    pub commit_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for TaskReadTargetCommitOnBranch {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "branchId")]
            branch_id: Strict<Uuid>,
            #[serde(rename = "commitId")]
            commit_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            branch_id: wire.branch_id.0,
            commit_id: wire.commit_id.0,
        })
    }
}

/// TaskReadTargetLatestOnBranch contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskReadTargetLatestOnBranch {
    /// Contract field branchId.
    #[serde(rename = "branchId")]
    pub branch_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for TaskReadTargetLatestOnBranch {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "branchId")]
            branch_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            branch_id: wire.branch_id.0,
        })
    }
}

/// TaskRequirements contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskRequirements {
    /// Contract field computeClass.
    #[serde(rename = "computeClass")]
    pub compute_class: ComputeClass,
    /// Contract field cpu.
    #[serde(rename = "cpu")]
    pub cpu: u32,
    /// Contract field memoryBytes.
    #[serde(rename = "memoryBytes")]
    pub memory_bytes: SafeUnsignedLong,
}
impl<'de> DeserializeStrict<'de> for TaskRequirements {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "computeClass")]
            compute_class: Strict<ComputeClass>,
            #[serde(rename = "cpu")]
            cpu: Strict<u32>,
            #[serde(rename = "memoryBytes")]
            memory_bytes: Strict<SafeUnsignedLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            compute_class: wire.compute_class.0,
            cpu: wire.cpu.0,
            memory_bytes: wire.memory_bytes.0,
        })
    }
}

/// TaskResourceReference contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskResourceReference {
    /// Contract field definitionVersionId.
    #[serde(rename = "definitionVersionId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub definition_version_id: Option<Uuid>,
    /// Contract field readTarget.
    #[serde(rename = "readTarget")]
    pub read_target: TaskReadTarget,
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    pub resource_id: Uuid,
    /// Contract field resourceVersionId.
    #[serde(rename = "resourceVersionId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_version_id: Option<Uuid>,
    /// Contract field role.
    #[serde(rename = "role")]
    pub role: TaskResourceRole,
}
impl<'de> DeserializeStrict<'de> for TaskResourceReference {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "definitionVersionId")]
            #[serde(default)]
            definition_version_id: Strict<Option<Uuid>>,
            #[serde(rename = "readTarget")]
            read_target: Strict<TaskReadTarget>,
            #[serde(rename = "resourceId")]
            resource_id: Strict<Uuid>,
            #[serde(rename = "resourceVersionId")]
            #[serde(default)]
            resource_version_id: Strict<Option<Uuid>>,
            #[serde(rename = "role")]
            role: Strict<TaskResourceRole>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            definition_version_id: wire.definition_version_id.0,
            read_target: wire.read_target.0,
            resource_id: wire.resource_id.0,
            resource_version_id: wire.resource_version_id.0,
            role: wire.role.0,
        })
    }
}

/// TaskResourceRole contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TaskResourceRole {
    /// A known contract value.
    Target,
    /// A known contract value.
    Source,
    /// A known contract value.
    Dependency,
    /// A known contract value.
    SourceLocation,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for TaskResourceRole {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Target => "target",
            Self::Source => "source",
            Self::Dependency => "dependency",
            Self::SourceLocation => "source_location",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for TaskResourceRole {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "target" => Self::Target,
            "source" => Self::Source,
            "dependency" => Self::Dependency,
            "source_location" => Self::SourceLocation,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for TaskResourceRole {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "target")]
            Target,
            #[serde(rename = "source")]
            Source,
            #[serde(rename = "dependency")]
            Dependency,
            #[serde(rename = "source_location")]
            SourceLocation,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Target => Self::Target,
            __Known::Source => Self::Source,
            __Known::Dependency => Self::Dependency,
            __Known::SourceLocation => Self::SourceLocation,
        })
    }
}

/// The resource versions a successful Task published, and the Project commit that published them
/// when it published any.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskResult {
    /// Contract field commitId.
    #[serde(rename = "commitId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub commit_id: Option<Uuid>,
    /// Contract field versions.
    #[serde(rename = "versions")]
    pub versions: Vec<PublishedVersion>,
}
impl<'de> DeserializeStrict<'de> for TaskResult {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "commitId")]
            #[serde(default)]
            commit_id: Strict<Option<Uuid>>,
            #[serde(rename = "versions")]
            versions: Strict<Vec<PublishedVersion>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            commit_id: wire.commit_id.0,
            versions: wire.versions.0,
        })
    }
}

/// TaskSpecDefaults contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskSpecDefaults {
    /// Contract field allowedResourceProfiles.
    #[serde(rename = "allowedResourceProfiles")]
    pub allowed_resource_profiles: Vec<ResourceProfileDetails>,
    /// Contract field defaultResourceProfile.
    #[serde(rename = "defaultResourceProfile")]
    pub default_resource_profile: ResourceProfile,
    /// Contract field overlapPolicy.
    #[serde(rename = "overlapPolicy")]
    pub overlap_policy: TaskOverlapPolicy,
    /// Contract field taskSpecId.
    #[serde(rename = "taskSpecId")]
    pub task_spec_id: TaskSpecId,
}
impl<'de> DeserializeStrict<'de> for TaskSpecDefaults {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "allowedResourceProfiles")]
            allowed_resource_profiles: Strict<Vec<ResourceProfileDetails>>,
            #[serde(rename = "defaultResourceProfile")]
            default_resource_profile: Strict<ResourceProfile>,
            #[serde(rename = "overlapPolicy")]
            overlap_policy: Strict<TaskOverlapPolicy>,
            #[serde(rename = "taskSpecId")]
            task_spec_id: Strict<TaskSpecId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            allowed_resource_profiles: wire.allowed_resource_profiles.0,
            default_resource_profile: wire.default_resource_profile.0,
            overlap_policy: wire.overlap_policy.0,
            task_spec_id: wire.task_spec_id.0,
        })
    }
}

/// TaskSpecId contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskSpecId {
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
    /// Contract field version.
    #[serde(rename = "version")]
    pub version: u32,
}
impl<'de> DeserializeStrict<'de> for TaskSpecId {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "name")]
            name: Strict<String>,
            #[serde(rename = "version")]
            version: Strict<u32>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            name: wire.name.0,
            version: wire.version.0,
        })
    }
}

/// TaskStats contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskStats {
    /// Contract field cancelledTaskCount.
    #[serde(rename = "cancelledTaskCount")]
    pub cancelled_task_count: SafeUnsignedLong,
    /// Contract field failedTaskCount.
    #[serde(rename = "failedTaskCount")]
    pub failed_task_count: SafeUnsignedLong,
    /// Contract field readyTaskCount.
    #[serde(rename = "readyTaskCount")]
    pub ready_task_count: SafeUnsignedLong,
    /// Contract field runningTaskCount.
    #[serde(rename = "runningTaskCount")]
    pub running_task_count: SafeUnsignedLong,
    /// Contract field succeededTaskCount.
    #[serde(rename = "succeededTaskCount")]
    pub succeeded_task_count: SafeUnsignedLong,
}
impl<'de> DeserializeStrict<'de> for TaskStats {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "cancelledTaskCount")]
            cancelled_task_count: Strict<SafeUnsignedLong>,
            #[serde(rename = "failedTaskCount")]
            failed_task_count: Strict<SafeUnsignedLong>,
            #[serde(rename = "readyTaskCount")]
            ready_task_count: Strict<SafeUnsignedLong>,
            #[serde(rename = "runningTaskCount")]
            running_task_count: Strict<SafeUnsignedLong>,
            #[serde(rename = "succeededTaskCount")]
            succeeded_task_count: Strict<SafeUnsignedLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            cancelled_task_count: wire.cancelled_task_count.0,
            failed_task_count: wire.failed_task_count.0,
            ready_task_count: wire.ready_task_count.0,
            running_task_count: wire.running_task_count.0,
            succeeded_task_count: wire.succeeded_task_count.0,
        })
    }
}

/// TaskStatsRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskStatsRequest {
    /// Contract field workerPoolId.
    #[serde(rename = "workerPoolId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub worker_pool_id: Option<Uuid>,
}
impl<'de> DeserializeStrict<'de> for TaskStatsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "workerPoolId")]
            #[serde(default)]
            worker_pool_id: Strict<Option<Uuid>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            worker_pool_id: wire.worker_pool_id.0,
        })
    }
}

/// TaskStatus contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TaskStatus {
    /// A known contract value.
    Ready,
    /// A known contract value.
    Running,
    /// A known contract value.
    Succeeded,
    /// A known contract value.
    Failed,
    /// A known contract value.
    Cancelled,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for TaskStatus {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Ready => "ready",
            Self::Running => "running",
            Self::Succeeded => "succeeded",
            Self::Failed => "failed",
            Self::Cancelled => "cancelled",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for TaskStatus {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "ready" => Self::Ready,
            "running" => Self::Running,
            "succeeded" => Self::Succeeded,
            "failed" => Self::Failed,
            "cancelled" => Self::Cancelled,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for TaskStatus {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "ready")]
            Ready,
            #[serde(rename = "running")]
            Running,
            #[serde(rename = "succeeded")]
            Succeeded,
            #[serde(rename = "failed")]
            Failed,
            #[serde(rename = "cancelled")]
            Cancelled,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Ready => Self::Ready,
            __Known::Running => Self::Running,
            __Known::Succeeded => Self::Succeeded,
            __Known::Failed => Self::Failed,
            __Known::Cancelled => Self::Cancelled,
        })
    }
}

/// TaskStopReason contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TaskStopReason {
    /// A known contract value.
    User,
    /// A known contract value.
    OverallDeadline,
    /// A known contract value.
    ParentFailed,
    /// A known contract value.
    ParentCancelled,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for TaskStopReason {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::User => "user",
            Self::OverallDeadline => "overall_deadline",
            Self::ParentFailed => "parent_failed",
            Self::ParentCancelled => "parent_cancelled",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for TaskStopReason {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "user" => Self::User,
            "overall_deadline" => Self::OverallDeadline,
            "parent_failed" => Self::ParentFailed,
            "parent_cancelled" => Self::ParentCancelled,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for TaskStopReason {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "user")]
            User,
            #[serde(rename = "overall_deadline")]
            OverallDeadline,
            #[serde(rename = "parent_failed")]
            ParentFailed,
            #[serde(rename = "parent_cancelled")]
            ParentCancelled,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::User => Self::User,
            __Known::OverallDeadline => Self::OverallDeadline,
            __Known::ParentFailed => Self::ParentFailed,
            __Known::ParentCancelled => Self::ParentCancelled,
        })
    }
}

/// TaskTrigger contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskTrigger {
    /// Contract field checkpointSequence.
    #[serde(rename = "checkpointSequence")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub checkpoint_sequence: Option<SafeLong>,
    /// Contract field createdAtMicros.
    #[serde(rename = "createdAtMicros")]
    pub created_at_micros: SafeLong,
    /// Contract field createdBy.
    #[serde(rename = "createdBy")]
    pub created_by: Caller,
    /// Contract field definition.
    #[serde(rename = "definition")]
    pub definition: TriggerDefinition,
    /// Contract field error.
    #[serde(rename = "error")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    /// Contract field nextFireAtMicros.
    #[serde(rename = "nextFireAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_fire_at_micros: Option<SafeLong>,
    /// Contract field projectId.
    #[serde(rename = "projectId")]
    pub project_id: String,
    /// Contract field resources.
    #[serde(rename = "resources")]
    pub resources: Vec<TaskResourceReference>,
    /// Contract field revision.
    #[serde(rename = "revision")]
    pub revision: SafeLong,
    /// Contract field triggerId.
    #[serde(rename = "triggerId")]
    pub trigger_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for TaskTrigger {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "checkpointSequence")]
            #[serde(default)]
            checkpoint_sequence: Strict<Option<SafeLong>>,
            #[serde(rename = "createdAtMicros")]
            created_at_micros: Strict<SafeLong>,
            #[serde(rename = "createdBy")]
            created_by: Strict<Caller>,
            #[serde(rename = "definition")]
            definition: Strict<TriggerDefinition>,
            #[serde(rename = "error")]
            #[serde(default)]
            error: Strict<Option<String>>,
            #[serde(rename = "nextFireAtMicros")]
            #[serde(default)]
            next_fire_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "projectId")]
            project_id: Strict<String>,
            #[serde(rename = "resources")]
            resources: Strict<Vec<TaskResourceReference>>,
            #[serde(rename = "revision")]
            revision: Strict<SafeLong>,
            #[serde(rename = "triggerId")]
            trigger_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            checkpoint_sequence: wire.checkpoint_sequence.0,
            created_at_micros: wire.created_at_micros.0,
            created_by: wire.created_by.0,
            definition: wire.definition.0,
            error: wire.error.0,
            next_fire_at_micros: wire.next_fire_at_micros.0,
            project_id: wire.project_id.0,
            resources: wire.resources.0,
            revision: wire.revision.0,
            trigger_id: wire.trigger_id.0,
        })
    }
}

/// TaskWorkProgress contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskWorkProgress {
    /// Contract field completed.
    #[serde(rename = "completed")]
    pub completed: SafeUnsignedLong,
    /// Contract field stage.
    #[serde(rename = "stage")]
    pub stage: TaskWorkStage,
    /// Contract field total.
    #[serde(rename = "total")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<SafeUnsignedLong>,
}
impl<'de> DeserializeStrict<'de> for TaskWorkProgress {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "completed")]
            completed: Strict<SafeUnsignedLong>,
            #[serde(rename = "stage")]
            stage: Strict<TaskWorkStage>,
            #[serde(rename = "total")]
            #[serde(default)]
            total: Strict<Option<SafeUnsignedLong>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            completed: wire.completed.0,
            stage: wire.stage.0,
            total: wire.total.0,
        })
    }
}

/// TaskWorkStage contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TaskWorkStage {
    /// A known contract value.
    Preparing,
    /// A known contract value.
    RefreshingDataset,
    /// A known contract value.
    BuildingVectorIndex,
    /// A known contract value.
    ReadingTable,
    /// A known contract value.
    Compacting,
    /// A known contract value.
    DispatchingWorkers,
    /// A known contract value.
    WaitingForWorkers,
    /// A known contract value.
    EvaluatingEnrichment,
    /// A known contract value.
    WritingFragment,
    /// A known contract value.
    Publishing,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for TaskWorkStage {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Preparing => "preparing",
            Self::RefreshingDataset => "refreshing_dataset",
            Self::BuildingVectorIndex => "building_vector_index",
            Self::ReadingTable => "reading_table",
            Self::Compacting => "compacting",
            Self::DispatchingWorkers => "dispatching_workers",
            Self::WaitingForWorkers => "waiting_for_workers",
            Self::EvaluatingEnrichment => "evaluating_enrichment",
            Self::WritingFragment => "writing_fragment",
            Self::Publishing => "publishing",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for TaskWorkStage {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "preparing" => Self::Preparing,
            "refreshing_dataset" => Self::RefreshingDataset,
            "building_vector_index" => Self::BuildingVectorIndex,
            "reading_table" => Self::ReadingTable,
            "compacting" => Self::Compacting,
            "dispatching_workers" => Self::DispatchingWorkers,
            "waiting_for_workers" => Self::WaitingForWorkers,
            "evaluating_enrichment" => Self::EvaluatingEnrichment,
            "writing_fragment" => Self::WritingFragment,
            "publishing" => Self::Publishing,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for TaskWorkStage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "preparing")]
            Preparing,
            #[serde(rename = "refreshing_dataset")]
            RefreshingDataset,
            #[serde(rename = "building_vector_index")]
            BuildingVectorIndex,
            #[serde(rename = "reading_table")]
            ReadingTable,
            #[serde(rename = "compacting")]
            Compacting,
            #[serde(rename = "dispatching_workers")]
            DispatchingWorkers,
            #[serde(rename = "waiting_for_workers")]
            WaitingForWorkers,
            #[serde(rename = "evaluating_enrichment")]
            EvaluatingEnrichment,
            #[serde(rename = "writing_fragment")]
            WritingFragment,
            #[serde(rename = "publishing")]
            Publishing,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Preparing => Self::Preparing,
            __Known::RefreshingDataset => Self::RefreshingDataset,
            __Known::BuildingVectorIndex => Self::BuildingVectorIndex,
            __Known::ReadingTable => Self::ReadingTable,
            __Known::Compacting => Self::Compacting,
            __Known::DispatchingWorkers => Self::DispatchingWorkers,
            __Known::WaitingForWorkers => Self::WaitingForWorkers,
            __Known::EvaluatingEnrichment => Self::EvaluatingEnrichment,
            __Known::WritingFragment => Self::WritingFragment,
            __Known::Publishing => Self::Publishing,
        })
    }
}

/// TaskWorker contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskWorker {
    /// Contract field managed.
    #[serde(rename = "managed")]
    pub managed: bool,
    /// Contract field workerPoolId.
    #[serde(rename = "workerPoolId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub worker_pool_id: Option<Uuid>,
    /// Contract field workerSessionId.
    #[serde(rename = "workerSessionId")]
    pub worker_session_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for TaskWorker {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "managed")]
            managed: Strict<bool>,
            #[serde(rename = "workerPoolId")]
            #[serde(default)]
            worker_pool_id: Strict<Option<Uuid>>,
            #[serde(rename = "workerSessionId")]
            worker_session_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            managed: wire.managed.0,
            worker_pool_id: wire.worker_pool_id.0,
            worker_session_id: wire.worker_session_id.0,
        })
    }
}

/// TestTriggerRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TestTriggerRequest {
    /// Contract field eventId.
    #[serde(rename = "eventId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub event_id: Option<Uuid>,
}
impl<'de> DeserializeStrict<'de> for TestTriggerRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "eventId")]
            #[serde(default)]
            event_id: Strict<Option<Uuid>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            event_id: wire.event_id.0,
        })
    }
}

/// TestTriggerResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TestTriggerResponse {
    /// Contract field eventId.
    #[serde(rename = "eventId")]
    pub event_id: Uuid,
    /// Contract field matches.
    #[serde(rename = "matches")]
    pub matches: bool,
}
impl<'de> DeserializeStrict<'de> for TestTriggerResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "eventId")]
            event_id: Strict<Uuid>,
            #[serde(rename = "matches")]
            matches: Strict<bool>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            event_id: wire.event_id.0,
            matches: wire.matches.0,
        })
    }
}

/// TriggerAction contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TriggerAction {
    /// Contract field input.
    #[serde(rename = "input")]
    pub input: Value,
    /// Contract field options.
    #[serde(rename = "options")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<TaskOptions>,
    /// Contract field taskSpecId.
    #[serde(rename = "taskSpecId")]
    pub task_spec_id: TaskSpecId,
}
impl<'de> DeserializeStrict<'de> for TriggerAction {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "input")]
            input: Strict<Value>,
            #[serde(rename = "options")]
            #[serde(default)]
            options: Strict<Option<TaskOptions>>,
            #[serde(rename = "taskSpecId")]
            task_spec_id: Strict<TaskSpecId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            input: wire.input.0,
            options: wire.options.0,
            task_spec_id: wire.task_spec_id.0,
        })
    }
}

/// TriggerDefinition contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TriggerDefinition {
    /// Contract field action.
    #[serde(rename = "action")]
    pub action: TriggerAction,
    /// Contract field enabled.
    #[serde(rename = "enabled")]
    pub enabled: bool,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
    /// Contract field source.
    #[serde(rename = "source")]
    pub source: TriggerSource,
}
impl<'de> DeserializeStrict<'de> for TriggerDefinition {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "action")]
            action: Strict<TriggerAction>,
            #[serde(rename = "enabled")]
            enabled: Strict<bool>,
            #[serde(rename = "name")]
            name: Strict<String>,
            #[serde(rename = "source")]
            source: Strict<TriggerSource>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            action: wire.action.0,
            enabled: wire.enabled.0,
            name: wire.name.0,
            source: wire.source.0,
        })
    }
}

/// TriggerInvocation contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TriggerInvocation {
    /// Contract field createdAtMicros.
    #[serde(rename = "createdAtMicros")]
    pub created_at_micros: SafeLong,
    /// Contract field invocationId.
    #[serde(rename = "invocationId")]
    pub invocation_id: Uuid,
    /// Contract field occurrence.
    #[serde(rename = "occurrence")]
    pub occurrence: TriggerOccurrence,
    /// Contract field status.
    #[serde(rename = "status")]
    pub status: InvocationStatus,
    /// Contract field taskId.
    #[serde(rename = "taskId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub task_id: Option<Uuid>,
    /// Contract field triggerId.
    #[serde(rename = "triggerId")]
    pub trigger_id: Uuid,
    /// Contract field triggerRevision.
    #[serde(rename = "triggerRevision")]
    pub trigger_revision: SafeLong,
}
impl<'de> DeserializeStrict<'de> for TriggerInvocation {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "createdAtMicros")]
            created_at_micros: Strict<SafeLong>,
            #[serde(rename = "invocationId")]
            invocation_id: Strict<Uuid>,
            #[serde(rename = "occurrence")]
            occurrence: Strict<TriggerOccurrence>,
            #[serde(rename = "status")]
            status: Strict<InvocationStatus>,
            #[serde(rename = "taskId")]
            #[serde(default)]
            task_id: Strict<Option<Uuid>>,
            #[serde(rename = "triggerId")]
            trigger_id: Strict<Uuid>,
            #[serde(rename = "triggerRevision")]
            trigger_revision: Strict<SafeLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            created_at_micros: wire.created_at_micros.0,
            invocation_id: wire.invocation_id.0,
            occurrence: wire.occurrence.0,
            status: wire.status.0,
            task_id: wire.task_id.0,
            trigger_id: wire.trigger_id.0,
            trigger_revision: wire.trigger_revision.0,
        })
    }
}

/// TriggerOccurrence contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TriggerOccurrence {
    /// A known union arm.
    JournalEvent(TriggerOccurrenceJournalEvent),
    /// A known union arm.
    Manual(TriggerOccurrenceManual),
    /// A known union arm.
    Schedule(TriggerOccurrenceSchedule),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for TriggerOccurrence {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::JournalEvent(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("journalEvent".into()));
                object.insert(
                    "journalEvent".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Manual(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("manual".into()));
                object.insert(
                    "manual".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Schedule(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("schedule".into()));
                object.insert(
                    "schedule".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Unknown { tag, value } => {
                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
                    return Err(serde::ser::Error::custom(
                        "unknown union discriminator mismatch",
                    ));
                }
                value.serialize(serializer)
            }
        }
    }
}
impl<'de> Deserialize<'de> for TriggerOccurrence {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(Value::as_str)
            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
        match tag {
            "journalEvent" => Ok(Self::JournalEvent(
                serde_json::from_value(
                    value
                        .get("journalEvent")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "manual" => Ok(Self::Manual(
                serde_json::from_value(
                    value
                        .get("manual")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "schedule" => Ok(Self::Schedule(
                serde_json::from_value(
                    value
                        .get("schedule")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            tag => Ok(Self::Unknown {
                tag: tag.to_owned(),
                value,
            }),
        }
    }
}
impl<'de> DeserializeStrict<'de> for TriggerOccurrence {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "journalEvent")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "journalEvent")]
            value: Strict<TriggerOccurrenceJournalEvent>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "manual")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "manual")]
            value: Strict<TriggerOccurrenceManual>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "schedule")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "schedule")]
            value: Strict<TriggerOccurrenceSchedule>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            JournalEvent(Box<__Arm0>),
            Manual(Box<__Arm1>),
            Schedule(Box<__Arm2>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::JournalEvent(arm) => Self::JournalEvent(arm.value.0),
            __Known::Manual(arm) => Self::Manual(arm.value.0),
            __Known::Schedule(arm) => Self::Schedule(arm.value.0),
        })
    }
}

/// TriggerOccurrenceJournalEvent contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TriggerOccurrenceJournalEvent {
    /// Contract field branchId.
    #[serde(rename = "branchId")]
    pub branch_id: Uuid,
    /// Contract field commitId.
    #[serde(rename = "commitId")]
    pub commit_id: Uuid,
    /// Contract field eventId.
    #[serde(rename = "eventId")]
    pub event_id: Uuid,
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    pub resource_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for TriggerOccurrenceJournalEvent {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "branchId")]
            branch_id: Strict<Uuid>,
            #[serde(rename = "commitId")]
            commit_id: Strict<Uuid>,
            #[serde(rename = "eventId")]
            event_id: Strict<Uuid>,
            #[serde(rename = "resourceId")]
            resource_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            branch_id: wire.branch_id.0,
            commit_id: wire.commit_id.0,
            event_id: wire.event_id.0,
            resource_id: wire.resource_id.0,
        })
    }
}

/// TriggerOccurrenceManual contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TriggerOccurrenceManual {
    /// Contract field requestId.
    #[serde(rename = "requestId")]
    pub request_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for TriggerOccurrenceManual {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "requestId")]
            request_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            request_id: wire.request_id.0,
        })
    }
}

/// TriggerOccurrenceSchedule contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TriggerOccurrenceSchedule {
    /// Contract field scheduledAtMicros.
    #[serde(rename = "scheduledAtMicros")]
    pub scheduled_at_micros: SafeLong,
}
impl<'de> DeserializeStrict<'de> for TriggerOccurrenceSchedule {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "scheduledAtMicros")]
            scheduled_at_micros: Strict<SafeLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            scheduled_at_micros: wire.scheduled_at_micros.0,
        })
    }
}

/// TriggerPage contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TriggerPage {
    /// Contract field items.
    #[serde(rename = "items")]
    pub items: Vec<TaskTrigger>,
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<String>,
}
impl<'de> DeserializeStrict<'de> for TriggerPage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "items")]
            items: Strict<Vec<TaskTrigger>>,
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            items: wire.items.0,
            next_page_token: wire.next_page_token.0,
        })
    }
}

/// TriggerPageRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TriggerPageRequest {
    /// Contract field legacyTableId.
    #[serde(rename = "legacyTableId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub legacy_table_id: Option<String>,
    /// Contract field pageToken.
    #[serde(rename = "pageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_token: Option<String>,
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_id: Option<Uuid>,
}
impl<'de> DeserializeStrict<'de> for TriggerPageRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "legacyTableId")]
            #[serde(default)]
            legacy_table_id: Strict<Option<String>>,
            #[serde(rename = "pageToken")]
            #[serde(default)]
            page_token: Strict<Option<String>>,
            #[serde(rename = "resourceId")]
            #[serde(default)]
            resource_id: Strict<Option<Uuid>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            legacy_table_id: wire.legacy_table_id.0,
            page_token: wire.page_token.0,
            resource_id: wire.resource_id.0,
        })
    }
}

/// TriggerSource contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TriggerSource {
    /// A known union arm.
    Interval(TriggerSourceInterval),
    /// A known union arm.
    JournalEvent(TriggerSourceJournalEvent),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for TriggerSource {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Interval(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("interval".into()));
                object.insert(
                    "interval".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::JournalEvent(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("journalEvent".into()));
                object.insert(
                    "journalEvent".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Unknown { tag, value } => {
                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
                    return Err(serde::ser::Error::custom(
                        "unknown union discriminator mismatch",
                    ));
                }
                value.serialize(serializer)
            }
        }
    }
}
impl<'de> Deserialize<'de> for TriggerSource {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(Value::as_str)
            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
        match tag {
            "interval" => Ok(Self::Interval(
                serde_json::from_value(
                    value
                        .get("interval")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "journalEvent" => Ok(Self::JournalEvent(
                serde_json::from_value(
                    value
                        .get("journalEvent")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            tag => Ok(Self::Unknown {
                tag: tag.to_owned(),
                value,
            }),
        }
    }
}
impl<'de> DeserializeStrict<'de> for TriggerSource {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "interval")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "interval")]
            value: Strict<TriggerSourceInterval>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "journalEvent")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "journalEvent")]
            value: Strict<TriggerSourceJournalEvent>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Interval(Box<__Arm0>),
            JournalEvent(Box<__Arm1>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Interval(arm) => Self::Interval(arm.value.0),
            __Known::JournalEvent(arm) => Self::JournalEvent(arm.value.0),
        })
    }
}

/// TriggerSourceInterval contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TriggerSourceInterval {
    /// Contract field everySeconds.
    #[serde(rename = "everySeconds")]
    pub every_seconds: u32,
    /// Contract field startAtMicros.
    #[serde(rename = "startAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub start_at_micros: Option<SafeLong>,
}
impl<'de> DeserializeStrict<'de> for TriggerSourceInterval {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "everySeconds")]
            every_seconds: Strict<u32>,
            #[serde(rename = "startAtMicros")]
            #[serde(default)]
            start_at_micros: Strict<Option<SafeLong>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            every_seconds: wire.every_seconds.0,
            start_at_micros: wire.start_at_micros.0,
        })
    }
}

/// TriggerSourceJournalEvent contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TriggerSourceJournalEvent {
    /// Contract field branchId.
    #[serde(rename = "branchId")]
    pub branch_id: Uuid,
    /// Contract field eventType.
    #[serde(rename = "eventType")]
    pub event_type: ResourceEventType,
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    pub resource_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for TriggerSourceJournalEvent {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "branchId")]
            branch_id: Strict<Uuid>,
            #[serde(rename = "eventType")]
            event_type: Strict<ResourceEventType>,
            #[serde(rename = "resourceId")]
            resource_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            branch_id: wire.branch_id.0,
            event_type: wire.event_type.0,
            resource_id: wire.resource_id.0,
        })
    }
}

/// UpdateTriggerRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct UpdateTriggerRequest {
    /// Contract field definition.
    #[serde(rename = "definition")]
    pub definition: TriggerDefinition,
    /// Contract field expectedRevision.
    #[serde(rename = "expectedRevision")]
    pub expected_revision: SafeLong,
}
impl<'de> DeserializeStrict<'de> for UpdateTriggerRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "definition")]
            definition: Strict<TriggerDefinition>,
            #[serde(rename = "expectedRevision")]
            expected_revision: Strict<SafeLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            definition: wire.definition.0,
            expected_revision: wire.expected_revision.0,
        })
    }
}

/// VectorIndexBuildMode contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum VectorIndexBuildMode {
    /// A known contract value.
    Auto,
    /// A known contract value.
    Full,
    /// A known contract value.
    Incremental,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for VectorIndexBuildMode {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Auto => "auto",
            Self::Full => "full",
            Self::Incremental => "incremental",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for VectorIndexBuildMode {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "auto" => Self::Auto,
            "full" => Self::Full,
            "incremental" => Self::Incremental,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for VectorIndexBuildMode {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "auto")]
            Auto,
            #[serde(rename = "full")]
            Full,
            #[serde(rename = "incremental")]
            Incremental,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Auto => Self::Auto,
            __Known::Full => Self::Full,
            __Known::Incremental => Self::Incremental,
        })
    }
}

/// Build an immutable successor of a Vector Index from its source Table. With latest, the pinned
/// versions are authorized at submission and the current state is resolved when the Task runs.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct VectorIndexRefreshDefinition {
    /// Contract field latest.
    #[serde(rename = "latest")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub latest: Option<bool>,
    /// Contract field mode.
    #[serde(rename = "mode")]
    pub mode: VectorIndexBuildMode,
    /// Contract field readTarget.
    #[serde(rename = "readTarget")]
    pub read_target: TaskReadTarget,
    /// Contract field sourceResourceId.
    #[serde(rename = "sourceResourceId")]
    pub source_resource_id: Uuid,
    /// Contract field vectorIndexId.
    #[serde(rename = "vectorIndexId")]
    pub vector_index_id: Uuid,
    /// Contract field vectorIndexResourceId.
    #[serde(rename = "vectorIndexResourceId")]
    pub vector_index_resource_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for VectorIndexRefreshDefinition {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "latest")]
            #[serde(default)]
            latest: Strict<Option<bool>>,
            #[serde(rename = "mode")]
            mode: Strict<VectorIndexBuildMode>,
            #[serde(rename = "readTarget")]
            read_target: Strict<TaskReadTarget>,
            #[serde(rename = "sourceResourceId")]
            source_resource_id: Strict<Uuid>,
            #[serde(rename = "vectorIndexId")]
            vector_index_id: Strict<Uuid>,
            #[serde(rename = "vectorIndexResourceId")]
            vector_index_resource_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            latest: wire.latest.0,
            mode: wire.mode.0,
            read_target: wire.read_target.0,
            source_resource_id: wire.source_resource_id.0,
            vector_index_id: wire.vector_index_id.0,
            vector_index_resource_id: wire.vector_index_resource_id.0,
        })
    }
}

/// WorkerAttempt contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkerAttempt {
    /// Contract field attemptId.
    #[serde(rename = "attemptId")]
    pub attempt_id: Uuid,
    /// Contract field ordinal.
    #[serde(rename = "ordinal")]
    pub ordinal: u32,
    /// Contract field requirements.
    #[serde(rename = "requirements")]
    pub requirements: TaskRequirements,
    /// Contract field startedAtMicros.
    #[serde(rename = "startedAtMicros")]
    pub started_at_micros: SafeLong,
    /// Contract field status.
    #[serde(rename = "status")]
    pub status: AttemptStatus,
    /// Contract field taskId.
    #[serde(rename = "taskId")]
    pub task_id: Uuid,
    /// Contract field taskSpecName.
    #[serde(rename = "taskSpecName")]
    pub task_spec_name: String,
    /// Contract field terminalAtMicros.
    #[serde(rename = "terminalAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub terminal_at_micros: Option<SafeLong>,
}
impl<'de> DeserializeStrict<'de> for WorkerAttempt {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attemptId")]
            attempt_id: Strict<Uuid>,
            #[serde(rename = "ordinal")]
            ordinal: Strict<u32>,
            #[serde(rename = "requirements")]
            requirements: Strict<TaskRequirements>,
            #[serde(rename = "startedAtMicros")]
            started_at_micros: Strict<SafeLong>,
            #[serde(rename = "status")]
            status: Strict<AttemptStatus>,
            #[serde(rename = "taskId")]
            task_id: Strict<Uuid>,
            #[serde(rename = "taskSpecName")]
            task_spec_name: Strict<String>,
            #[serde(rename = "terminalAtMicros")]
            #[serde(default)]
            terminal_at_micros: Strict<Option<SafeLong>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt_id: wire.attempt_id.0,
            ordinal: wire.ordinal.0,
            requirements: wire.requirements.0,
            started_at_micros: wire.started_at_micros.0,
            status: wire.status.0,
            task_id: wire.task_id.0,
            task_spec_name: wire.task_spec_name.0,
            terminal_at_micros: wire.terminal_at_micros.0,
        })
    }
}

/// WorkerCapabilities contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkerCapabilities {
    /// Contract field architecture.
    #[serde(rename = "architecture")]
    pub architecture: String,
    /// Contract field installedTaskSpecs.
    #[serde(rename = "installedTaskSpecs")]
    pub installed_task_specs: Vec<TaskSpecId>,
    /// Contract field operatingSystem.
    #[serde(rename = "operatingSystem")]
    pub operating_system: String,
    /// Contract field resources.
    #[serde(rename = "resources")]
    pub resources: WorkerResources,
}
impl<'de> DeserializeStrict<'de> for WorkerCapabilities {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "architecture")]
            architecture: Strict<String>,
            #[serde(rename = "installedTaskSpecs")]
            installed_task_specs: Strict<Vec<TaskSpecId>>,
            #[serde(rename = "operatingSystem")]
            operating_system: Strict<String>,
            #[serde(rename = "resources")]
            resources: Strict<WorkerResources>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            architecture: wire.architecture.0,
            installed_task_specs: wire.installed_task_specs.0,
            operating_system: wire.operating_system.0,
            resources: wire.resources.0,
        })
    }
}

/// WorkerGpuResources contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkerGpuResources {
    /// Contract field count.
    #[serde(rename = "count")]
    pub count: u32,
    /// Contract field memoryBytes.
    #[serde(rename = "memoryBytes")]
    pub memory_bytes: SafeUnsignedLong,
    /// Contract field runtime.
    #[serde(rename = "runtime")]
    pub runtime: GpuRuntime,
}
impl<'de> DeserializeStrict<'de> for WorkerGpuResources {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "count")]
            count: Strict<u32>,
            #[serde(rename = "memoryBytes")]
            memory_bytes: Strict<SafeUnsignedLong>,
            #[serde(rename = "runtime")]
            runtime: Strict<GpuRuntime>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            count: wire.count.0,
            memory_bytes: wire.memory_bytes.0,
            runtime: wire.runtime.0,
        })
    }
}

/// WorkerIdentity contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum WorkerIdentity {
    /// A known union arm.
    User(WorkerIdentityUser),
    /// A known union arm.
    Workload(WorkerIdentityWorkload),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for WorkerIdentity {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::User(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("user".into()));
                object.insert(
                    "user".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Workload(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("workload".into()));
                object.insert(
                    "workload".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Unknown { tag, value } => {
                if value.get("type").and_then(Value::as_str) != Some(tag.as_str()) {
                    return Err(serde::ser::Error::custom(
                        "unknown union discriminator mismatch",
                    ));
                }
                value.serialize(serializer)
            }
        }
    }
}
impl<'de> Deserialize<'de> for WorkerIdentity {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(Value::as_str)
            .ok_or_else(|| serde::de::Error::custom("union requires type"))?;
        match tag {
            "user" => Ok(Self::User(
                serde_json::from_value(
                    value
                        .get("user")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "workload" => Ok(Self::Workload(
                serde_json::from_value(
                    value
                        .get("workload")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            tag => Ok(Self::Unknown {
                tag: tag.to_owned(),
                value,
            }),
        }
    }
}
impl<'de> DeserializeStrict<'de> for WorkerIdentity {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "user")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "user")]
            value: Strict<WorkerIdentityUser>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "workload")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "workload")]
            value: Strict<WorkerIdentityWorkload>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            User(Box<__Arm0>),
            Workload(Box<__Arm1>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::User(arm) => Self::User(arm.value.0),
            __Known::Workload(arm) => Self::Workload(arm.value.0),
        })
    }
}

/// WorkerIdentityUser contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkerIdentityUser {
    /// Contract field userId.
    #[serde(rename = "userId")]
    pub user_id: String,
}
impl<'de> DeserializeStrict<'de> for WorkerIdentityUser {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "userId")]
            user_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            user_id: wire.user_id.0,
        })
    }
}

/// WorkerIdentityWorkload contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkerIdentityWorkload {
    /// Contract field workloadId.
    #[serde(rename = "workloadId")]
    pub workload_id: String,
}
impl<'de> DeserializeStrict<'de> for WorkerIdentityWorkload {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "workloadId")]
            workload_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            workload_id: wire.workload_id.0,
        })
    }
}

/// WorkerPool contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkerPool {
    /// Contract field capabilities.
    #[serde(rename = "capabilities")]
    pub capabilities: WorkerCapabilities,
    /// Contract field createdAtMicros.
    #[serde(rename = "createdAtMicros")]
    pub created_at_micros: SafeLong,
    /// Contract field managedProfileId.
    #[serde(rename = "managedProfileId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub managed_profile_id: Option<String>,
    /// Contract field managedProviderId.
    #[serde(rename = "managedProviderId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub managed_provider_id: Option<String>,
    /// Contract field maxWorkers.
    #[serde(rename = "maxWorkers")]
    pub max_workers: u32,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
    /// Contract field projectId.
    #[serde(rename = "projectId")]
    pub project_id: String,
    /// Contract field status.
    #[serde(rename = "status")]
    pub status: WorkerPoolStatus,
    /// Contract field updatedAtMicros.
    #[serde(rename = "updatedAtMicros")]
    pub updated_at_micros: SafeLong,
    /// Contract field workerPoolId.
    #[serde(rename = "workerPoolId")]
    pub worker_pool_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for WorkerPool {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "capabilities")]
            capabilities: Strict<WorkerCapabilities>,
            #[serde(rename = "createdAtMicros")]
            created_at_micros: Strict<SafeLong>,
            #[serde(rename = "managedProfileId")]
            #[serde(default)]
            managed_profile_id: Strict<Option<String>>,
            #[serde(rename = "managedProviderId")]
            #[serde(default)]
            managed_provider_id: Strict<Option<String>>,
            #[serde(rename = "maxWorkers")]
            max_workers: Strict<u32>,
            #[serde(rename = "name")]
            name: Strict<String>,
            #[serde(rename = "projectId")]
            project_id: Strict<String>,
            #[serde(rename = "status")]
            status: Strict<WorkerPoolStatus>,
            #[serde(rename = "updatedAtMicros")]
            updated_at_micros: Strict<SafeLong>,
            #[serde(rename = "workerPoolId")]
            worker_pool_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            capabilities: wire.capabilities.0,
            created_at_micros: wire.created_at_micros.0,
            managed_profile_id: wire.managed_profile_id.0,
            managed_provider_id: wire.managed_provider_id.0,
            max_workers: wire.max_workers.0,
            name: wire.name.0,
            project_id: wire.project_id.0,
            status: wire.status.0,
            updated_at_micros: wire.updated_at_micros.0,
            worker_pool_id: wire.worker_pool_id.0,
        })
    }
}

/// WorkerPoolDetails contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkerPoolDetails {
    /// Contract field stats.
    #[serde(rename = "stats")]
    pub stats: WorkerPoolStats,
    /// Contract field workerPool.
    #[serde(rename = "workerPool")]
    pub worker_pool: WorkerPool,
}
impl<'de> DeserializeStrict<'de> for WorkerPoolDetails {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "stats")]
            stats: Strict<WorkerPoolStats>,
            #[serde(rename = "workerPool")]
            worker_pool: Strict<WorkerPool>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            stats: wire.stats.0,
            worker_pool: wire.worker_pool.0,
        })
    }
}

/// WorkerPoolResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkerPoolResponse {
    /// Contract field workerPool.
    #[serde(rename = "workerPool")]
    pub worker_pool: WorkerPool,
}
impl<'de> DeserializeStrict<'de> for WorkerPoolResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "workerPool")]
            worker_pool: Strict<WorkerPool>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            worker_pool: wire.worker_pool.0,
        })
    }
}

/// WorkerPoolStats contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkerPoolStats {
    /// Contract field activeWorkerCount.
    #[serde(rename = "activeWorkerCount")]
    pub active_worker_count: SafeUnsignedLong,
    /// Contract field busyWorkerCount.
    #[serde(rename = "busyWorkerCount")]
    pub busy_worker_count: SafeUnsignedLong,
    /// Contract field claimedReadyTaskCount.
    #[serde(rename = "claimedReadyTaskCount")]
    pub claimed_ready_task_count: SafeUnsignedLong,
    /// Contract field oldestReadyTaskAvailableAtMicros.
    #[serde(rename = "oldestReadyTaskAvailableAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub oldest_ready_task_available_at_micros: Option<SafeLong>,
    /// Contract field runningTaskCount.
    #[serde(rename = "runningTaskCount")]
    pub running_task_count: SafeUnsignedLong,
    /// Contract field workerPoolId.
    #[serde(rename = "workerPoolId")]
    pub worker_pool_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for WorkerPoolStats {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "activeWorkerCount")]
            active_worker_count: Strict<SafeUnsignedLong>,
            #[serde(rename = "busyWorkerCount")]
            busy_worker_count: Strict<SafeUnsignedLong>,
            #[serde(rename = "claimedReadyTaskCount")]
            claimed_ready_task_count: Strict<SafeUnsignedLong>,
            #[serde(rename = "oldestReadyTaskAvailableAtMicros")]
            #[serde(default)]
            oldest_ready_task_available_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "runningTaskCount")]
            running_task_count: Strict<SafeUnsignedLong>,
            #[serde(rename = "workerPoolId")]
            worker_pool_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            active_worker_count: wire.active_worker_count.0,
            busy_worker_count: wire.busy_worker_count.0,
            claimed_ready_task_count: wire.claimed_ready_task_count.0,
            oldest_ready_task_available_at_micros: wire.oldest_ready_task_available_at_micros.0,
            running_task_count: wire.running_task_count.0,
            worker_pool_id: wire.worker_pool_id.0,
        })
    }
}

/// WorkerPoolStatus contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum WorkerPoolStatus {
    /// A known contract value.
    Active,
    /// A known contract value.
    Paused,
    /// A known contract value.
    Retired,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for WorkerPoolStatus {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Active => "active",
            Self::Paused => "paused",
            Self::Retired => "retired",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for WorkerPoolStatus {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "active" => Self::Active,
            "paused" => Self::Paused,
            "retired" => Self::Retired,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for WorkerPoolStatus {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "active")]
            Active,
            #[serde(rename = "paused")]
            Paused,
            #[serde(rename = "retired")]
            Retired,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Active => Self::Active,
            __Known::Paused => Self::Paused,
            __Known::Retired => Self::Retired,
        })
    }
}

/// WorkerResources contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkerResources {
    /// Contract field cpuCount.
    #[serde(rename = "cpuCount")]
    pub cpu_count: u32,
    /// Contract field gpu.
    #[serde(rename = "gpu")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub gpu: Option<WorkerGpuResources>,
    /// Contract field memoryBytes.
    #[serde(rename = "memoryBytes")]
    pub memory_bytes: SafeUnsignedLong,
}
impl<'de> DeserializeStrict<'de> for WorkerResources {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "cpuCount")]
            cpu_count: Strict<u32>,
            #[serde(rename = "gpu")]
            #[serde(default)]
            gpu: Strict<Option<WorkerGpuResources>>,
            #[serde(rename = "memoryBytes")]
            memory_bytes: Strict<SafeUnsignedLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            cpu_count: wire.cpu_count.0,
            gpu: wire.gpu.0,
            memory_bytes: wire.memory_bytes.0,
        })
    }
}

/// WorkerSession contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkerSession {
    /// Contract field capabilities.
    #[serde(rename = "capabilities")]
    pub capabilities: WorkerCapabilities,
    /// Contract field createdAtMicros.
    #[serde(rename = "createdAtMicros")]
    pub created_at_micros: SafeLong,
    /// Contract field currentAttemptId.
    #[serde(rename = "currentAttemptId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub current_attempt_id: Option<Uuid>,
    /// Contract field identity.
    #[serde(rename = "identity")]
    pub identity: WorkerIdentity,
    /// Contract field lastHeartbeatAtMicros.
    #[serde(rename = "lastHeartbeatAtMicros")]
    pub last_heartbeat_at_micros: SafeLong,
    /// Contract field processInstanceId.
    #[serde(rename = "processInstanceId")]
    pub process_instance_id: Uuid,
    /// Contract field projectId.
    #[serde(rename = "projectId")]
    pub project_id: String,
    /// Contract field releaseVersion.
    #[serde(rename = "releaseVersion")]
    pub release_version: String,
    /// Contract field resourceUsage.
    #[serde(rename = "resourceUsage")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_usage: Option<ResourceUsageSummary>,
    /// Contract field status.
    #[serde(rename = "status")]
    pub status: WorkerSessionStatus,
    /// Contract field tags.
    #[serde(rename = "tags")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<WorkerSessionTags>,
    /// Contract field updatedAtMicros.
    #[serde(rename = "updatedAtMicros")]
    pub updated_at_micros: SafeLong,
    /// Contract field workerPoolId.
    #[serde(rename = "workerPoolId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub worker_pool_id: Option<Uuid>,
    /// Contract field workerSessionId.
    #[serde(rename = "workerSessionId")]
    pub worker_session_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for WorkerSession {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "capabilities")]
            capabilities: Strict<WorkerCapabilities>,
            #[serde(rename = "createdAtMicros")]
            created_at_micros: Strict<SafeLong>,
            #[serde(rename = "currentAttemptId")]
            #[serde(default)]
            current_attempt_id: Strict<Option<Uuid>>,
            #[serde(rename = "identity")]
            identity: Strict<WorkerIdentity>,
            #[serde(rename = "lastHeartbeatAtMicros")]
            last_heartbeat_at_micros: Strict<SafeLong>,
            #[serde(rename = "processInstanceId")]
            process_instance_id: Strict<Uuid>,
            #[serde(rename = "projectId")]
            project_id: Strict<String>,
            #[serde(rename = "releaseVersion")]
            release_version: Strict<String>,
            #[serde(rename = "resourceUsage")]
            #[serde(default)]
            resource_usage: Strict<Option<ResourceUsageSummary>>,
            #[serde(rename = "status")]
            status: Strict<WorkerSessionStatus>,
            #[serde(rename = "tags")]
            #[serde(default)]
            tags: Strict<Option<WorkerSessionTags>>,
            #[serde(rename = "updatedAtMicros")]
            updated_at_micros: Strict<SafeLong>,
            #[serde(rename = "workerPoolId")]
            #[serde(default)]
            worker_pool_id: Strict<Option<Uuid>>,
            #[serde(rename = "workerSessionId")]
            worker_session_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            capabilities: wire.capabilities.0,
            created_at_micros: wire.created_at_micros.0,
            current_attempt_id: wire.current_attempt_id.0,
            identity: wire.identity.0,
            last_heartbeat_at_micros: wire.last_heartbeat_at_micros.0,
            process_instance_id: wire.process_instance_id.0,
            project_id: wire.project_id.0,
            release_version: wire.release_version.0,
            resource_usage: wire.resource_usage.0,
            status: wire.status.0,
            tags: wire.tags.0,
            updated_at_micros: wire.updated_at_micros.0,
            worker_pool_id: wire.worker_pool_id.0,
            worker_session_id: wire.worker_session_id.0,
        })
    }
}

/// WorkerSessionStatus contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum WorkerSessionStatus {
    /// A known contract value.
    Active,
    /// A known contract value.
    Draining,
    /// A known contract value.
    Expired,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for WorkerSessionStatus {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Active => "active",
            Self::Draining => "draining",
            Self::Expired => "expired",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for WorkerSessionStatus {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "active" => Self::Active,
            "draining" => Self::Draining,
            "expired" => Self::Expired,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for WorkerSessionStatus {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "active")]
            Active,
            #[serde(rename = "draining")]
            Draining,
            #[serde(rename = "expired")]
            Expired,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Active => Self::Active,
            __Known::Draining => Self::Draining,
            __Known::Expired => Self::Expired,
        })
    }
}

/// WorkerSessionTags contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct WorkerSessionTags(pub BTreeMap<String, String>);
impl<'de> DeserializeStrict<'de> for WorkerSessionTags {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(
            Strict::<BTreeMap<String, String>>::deserialize(deserializer)?.0,
        ))
    }
}

/// WorkerTask contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkerTask {
    /// Contract field attemptId.
    #[serde(rename = "attemptId")]
    pub attempt_id: Uuid,
    /// Contract field input.
    #[serde(rename = "input")]
    pub input: Value,
    /// Contract field leaseExpiresAtMicros.
    #[serde(rename = "leaseExpiresAtMicros")]
    pub lease_expires_at_micros: SafeLong,
    /// Contract field projectId.
    #[serde(rename = "projectId")]
    pub project_id: String,
    /// Contract field stopReason.
    #[serde(rename = "stopReason")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stop_reason: Option<TaskStopReason>,
    /// Contract field taskId.
    #[serde(rename = "taskId")]
    pub task_id: Uuid,
    /// Contract field taskSpecId.
    #[serde(rename = "taskSpecId")]
    pub task_spec_id: TaskSpecId,
    /// Contract field traceContext.
    #[serde(rename = "traceContext")]
    pub trace_context: BTreeMap<String, String>,
}
impl<'de> DeserializeStrict<'de> for WorkerTask {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attemptId")]
            attempt_id: Strict<Uuid>,
            #[serde(rename = "input")]
            input: Strict<Value>,
            #[serde(rename = "leaseExpiresAtMicros")]
            lease_expires_at_micros: Strict<SafeLong>,
            #[serde(rename = "projectId")]
            project_id: Strict<String>,
            #[serde(rename = "stopReason")]
            #[serde(default)]
            stop_reason: Strict<Option<TaskStopReason>>,
            #[serde(rename = "taskId")]
            task_id: Strict<Uuid>,
            #[serde(rename = "taskSpecId")]
            task_spec_id: Strict<TaskSpecId>,
            #[serde(rename = "traceContext")]
            trace_context: Strict<BTreeMap<String, String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt_id: wire.attempt_id.0,
            input: wire.input.0,
            lease_expires_at_micros: wire.lease_expires_at_micros.0,
            project_id: wire.project_id.0,
            stop_reason: wire.stop_reason.0,
            task_id: wire.task_id.0,
            task_spec_id: wire.task_spec_id.0,
            trace_context: wire.trace_context.0,
        })
    }
}

/// Typed errors declared by this service contract.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TasksError {
    /// Tasks:Conflict.
    Conflict { reason: String },
    /// Tasks:InvalidArgument.
    InvalidArgument { reason: String },
    /// Tasks:LimitReached.
    LimitReached { reason: String },
    /// Tasks:NotFound.
    NotFound { resource: String },
    /// Tasks:NotImplemented.
    NotImplemented { reason: String },
}
impl TasksError {
    /// HTTP status for this declared error.
    pub fn status(&self) -> u16 {
        match self {
            Self::Conflict { .. } => 409,
            Self::InvalidArgument { .. } => 400,
            Self::LimitReached { .. } => 412,
            Self::NotFound { .. } => 404,
            Self::NotImplemented { .. } => 412,
        }
    }
    /// Serialize only contract-declared error parameters.
    pub fn envelope(&self, instance: String) -> ErrorEnvelope {
        match self {
            Self::Conflict { reason } => {
                let mut envelope = ErrorEnvelope::new("CONFLICT", "Tasks:Conflict", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::InvalidArgument { reason } => {
                let mut envelope =
                    ErrorEnvelope::new("INVALID_ARGUMENT", "Tasks:InvalidArgument", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::LimitReached { reason } => {
                let mut envelope =
                    ErrorEnvelope::new("FAILED_PRECONDITION", "Tasks:LimitReached", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::NotFound { resource } => {
                let mut envelope = ErrorEnvelope::new("NOT_FOUND", "Tasks:NotFound", instance);
                envelope
                    .parameters
                    .insert("resource".into(), resource.to_string());
                envelope
            }
            Self::NotImplemented { reason } => {
                let mut envelope =
                    ErrorEnvelope::new("FAILED_PRECONDITION", "Tasks:NotImplemented", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
        }
    }
    /// Decode a declared error and its typed error parameters.
    pub fn decode_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
        if envelope.error_instance_id.len() != 36
            || Uuid::parse_str(&envelope.error_instance_id).is_err()
        {
            return None;
        }
        match envelope.error_name.as_str() {
            "Tasks:Conflict" => {
                if envelope.error_code != "CONFLICT" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::Conflict { reason })
            }
            "Tasks:InvalidArgument" => {
                if envelope.error_code != "INVALID_ARGUMENT" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::InvalidArgument { reason })
            }
            "Tasks:LimitReached" => {
                if envelope.error_code != "FAILED_PRECONDITION" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::LimitReached { reason })
            }
            "Tasks:NotFound" => {
                if envelope.error_code != "NOT_FOUND" {
                    return None;
                }
                let resource = envelope.parameters.get("resource")?.clone();
                Some(Self::NotFound { resource })
            }
            "Tasks:NotImplemented" => {
                if envelope.error_code != "FAILED_PRECONDITION" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::NotImplemented { reason })
            }
            _ => None,
        }
    }
}
impl Display for TasksError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Conflict { reason } => write!(formatter, "Tasks:Conflict (reason: {})", reason),
            Self::InvalidArgument { reason } => {
                write!(formatter, "Tasks:InvalidArgument (reason: {})", reason)
            }
            Self::LimitReached { reason } => {
                write!(formatter, "Tasks:LimitReached (reason: {})", reason)
            }
            Self::NotFound { resource } => {
                write!(formatter, "Tasks:NotFound (resource: {})", resource)
            }
            Self::NotImplemented { reason } => {
                write!(formatter, "Tasks:NotImplemented (reason: {})", reason)
            }
        }
    }
}
impl StdError for TasksError {}
impl ServiceError for TasksError {
    fn to_envelope(&self, instance: String) -> ErrorEnvelope {
        Self::envelope(self, instance)
    }
    fn from_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
        Self::decode_envelope(envelope)
    }
}
#[automatically_derived]
impl Default for InvocationPageRequest {
    fn default() -> Self {
        Self { page_token: None }
    }
}
#[automatically_derived]
impl Default for ListTasksRequest {
    fn default() -> Self {
        Self {
            legacy_table_id: None,
            origin: None,
            page_size: None,
            page_token: None,
            parent_task_id: None,
            query: None,
            resource_id: None,
            resource_role: None,
            status: None,
            task_spec_name: None,
            worker_pool_id: None,
            worker_session_id: None,
        }
    }
}
#[automatically_derived]
impl Default for ListWorkerAttemptsRequest {
    fn default() -> Self {
        Self {
            page_size: None,
            page_token: None,
        }
    }
}
#[automatically_derived]
impl Default for ListWorkerPoolsRequest {
    fn default() -> Self {
        Self {
            page_size: None,
            page_token: None,
            worker_pool_id: None,
        }
    }
}
#[automatically_derived]
impl Default for ListWorkerSessionsRequest {
    fn default() -> Self {
        Self {
            page_size: None,
            page_token: None,
            status: None,
            worker_pool_id: None,
        }
    }
}
#[automatically_derived]
impl Default for ResourceUsageRequest {
    fn default() -> Self {
        Self { attempt_id: None }
    }
}
#[automatically_derived]
impl Default for TaskStatsRequest {
    fn default() -> Self {
        Self {
            worker_pool_id: None,
        }
    }
}
#[automatically_derived]
impl Default for TestTriggerRequest {
    fn default() -> Self {
        Self { event_id: None }
    }
}
#[automatically_derived]
impl Default for TriggerPageRequest {
    fn default() -> Self {
        Self {
            legacy_table_id: None,
            page_token: None,
            resource_id: None,
        }
    }
}