spiral/api/scandal/

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::SafeUnsignedLong;
use spiral_contract::strict::{DeserializeStrict, Strict};
use uuid::Uuid;

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

/// Add `field` after the column or field `after`, or last when absent.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AddColumn {
    /// Contract field after.
    #[serde(rename = "after")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub after: Option<Vec<String>>,
    /// Contract field field.
    #[serde(rename = "field")]
    pub field: ArrowField,
}
impl<'de> DeserializeStrict<'de> for AddColumn {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "after")]
            #[serde(default)]
            after: Strict<Option<Vec<String>>>,
            #[serde(rename = "field")]
            field: Strict<ArrowField>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            after: wire.after.0,
            field: wire.field.0,
        })
    }
}

/// A file written after `from`, with the rows `to` keeps in it. `appended` holds rows added after
/// `from`, whose row IDs are past every row ID `from` allocated. `carried` holds rows of `from`
/// that a rewrite, such as compaction, moved here. A carried row holds the values it held in
/// `from`, unless it is also in `patched`: the carried rows whose requested columns a patch changed
/// after `from`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AddedFragment {
    /// Contract field appended.
    #[serde(rename = "appended")]
    pub appended: Vec<RowIdRange>,
    /// Contract field carried.
    #[serde(rename = "carried")]
    pub carried: Vec<RowIdRange>,
    /// Contract field patched.
    #[serde(rename = "patched")]
    pub patched: Vec<RowIdRange>,
}
impl<'de> DeserializeStrict<'de> for AddedFragment {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "appended")]
            appended: Strict<Vec<RowIdRange>>,
            #[serde(rename = "carried")]
            carried: Strict<Vec<RowIdRange>>,
            #[serde(rename = "patched")]
            patched: Strict<Vec<RowIdRange>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            appended: wire.appended.0,
            carried: wire.carried.0,
            patched: wire.patched.0,
        })
    }
}

/// Aggregates of the output rows: one row for each distinct value of the `groups` columns, or one
/// row for all rows when there are none. Each row holds the group columns, each aggregate by name,
/// `scandal.rows` (the rows the group covers, as `uint64`) and `scandal.other`. At most `maxGroups`
/// groups are kept, 1,000 unless set and at most 100,000; rows of further groups fold into one row
/// whose `scandal.other` is true and whose group columns are null. The result is exact while the
/// version holds no more distinct groups than `maxGroups`. Merged results order groups by
/// `scandal.rows`, largest first, then by their group values, with the folded row last.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Aggregate {
    /// Contract field aggregates.
    #[serde(rename = "aggregates")]
    pub aggregates: Vec<NamedAggregate>,
    /// Contract field groups.
    #[serde(rename = "groups")]
    pub groups: Vec<String>,
    /// Contract field maxGroups.
    #[serde(rename = "maxGroups")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_groups: Option<u32>,
}
impl<'de> DeserializeStrict<'de> for Aggregate {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "aggregates")]
            aggregates: Strict<Vec<NamedAggregate>>,
            #[serde(rename = "groups")]
            groups: Strict<Vec<String>>,
            #[serde(rename = "maxGroups")]
            #[serde(default)]
            max_groups: Strict<Option<u32>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            aggregates: wire.aggregates.0,
            groups: wire.groups.0,
            max_groups: wire.max_groups.0,
        })
    }
}

/// An aggregate whose partial results merge exactly. Each is a Vortex aggregate function, and its
/// partial state, which a split returns, has the type of its result. `count` counts rows, or a
/// column's non-null values, as `uint64` (`vortex.count`). `sum` adds a numeric or decimal column's
/// values (`vortex.sum`): booleans and unsigned integers as `uint64`, signed integers as `int64`,
/// floating point as `float64`, and decimals with ten more digits of precision. A sum of no values
/// is zero, and an integer sum that overflows is null. `min` and `max` keep a column's least or
/// greatest value, in its own type, and are null for a group without values (`vortex.min`,
/// `vortex.max`). NaN counts as a value, makes a sum NaN, and is the min and max of any values that
/// include it. `histogram` counts a numeric column's values in equal bins (`spql.agg.histogram`).
#[derive(Clone, Debug, PartialEq)]
pub enum AggregateFunction {
    /// A known union arm.
    Count(CountAggregate),
    /// A known union arm.
    Histogram(HistogramAggregate),
    /// A known union arm.
    Max(ColumnAggregate),
    /// A known union arm.
    Min(ColumnAggregate),
    /// A known union arm.
    Sum(ColumnAggregate),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for AggregateFunction {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Count(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("count".into()));
                object.insert(
                    "count".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Histogram(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("histogram".into()));
                object.insert(
                    "histogram".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Max(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("max".into()));
                object.insert(
                    "max".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Min(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("min".into()));
                object.insert(
                    "min".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Sum(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("sum".into()));
                object.insert(
                    "sum".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 AggregateFunction {
    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 {
            "count" => Ok(Self::Count(
                serde_json::from_value(
                    value
                        .get("count")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "histogram" => Ok(Self::Histogram(
                serde_json::from_value(
                    value
                        .get("histogram")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "max" => Ok(Self::Max(
                serde_json::from_value(
                    value
                        .get("max")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "min" => Ok(Self::Min(
                serde_json::from_value(
                    value
                        .get("min")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "sum" => Ok(Self::Sum(
                serde_json::from_value(
                    value
                        .get("sum")
                        .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 AggregateFunction {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "count")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "count")]
            value: Strict<CountAggregate>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "histogram")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "histogram")]
            value: Strict<HistogramAggregate>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "max")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "max")]
            value: Strict<ColumnAggregate>,
        }
        #[derive(Deserialize)]
        enum __Tag3 {
            #[serde(rename = "min")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm3 {
            #[serde(rename = "type")]
            _tag: __Tag3,
            #[serde(rename = "min")]
            value: Strict<ColumnAggregate>,
        }
        #[derive(Deserialize)]
        enum __Tag4 {
            #[serde(rename = "sum")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm4 {
            #[serde(rename = "type")]
            _tag: __Tag4,
            #[serde(rename = "sum")]
            value: Strict<ColumnAggregate>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Count(Box<__Arm0>),
            Histogram(Box<__Arm1>),
            Max(Box<__Arm2>),
            Min(Box<__Arm3>),
            Sum(Box<__Arm4>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Count(arm) => Self::Count(arm.value.0),
            __Known::Histogram(arm) => Self::Histogram(arm.value.0),
            __Known::Max(arm) => Self::Max(arm.value.0),
            __Known::Min(arm) => Self::Min(arm.value.0),
            __Known::Sum(arm) => Self::Sum(arm.value.0),
        })
    }
}

/// A version of a Table whose files mirror the files of `source`, a version of another Table: the
/// successor of `versionId`, or the Table's first version, with `schema`, when `versionId` is
/// absent. It takes the receipts of mirrored files and of patches to `versionId`'s rows. Finalizing
/// removes each file whose source file `source` no longer has, and refuses a file that does not
/// mirror a file of `source`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AlignedBase {
    /// Contract field schema.
    #[serde(rename = "schema")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub schema: Option<ArrowSchema>,
    /// Contract field source.
    #[serde(rename = "source")]
    pub source: TableVersion,
    /// Contract field sourceStorage.
    #[serde(rename = "sourceStorage")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_storage: Option<StorageBinding>,
    /// Contract field versionId.
    #[serde(rename = "versionId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version_id: Option<Uuid>,
}
impl<'de> DeserializeStrict<'de> for AlignedBase {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "schema")]
            #[serde(default)]
            schema: Strict<Option<ArrowSchema>>,
            #[serde(rename = "source")]
            source: Strict<TableVersion>,
            #[serde(rename = "sourceStorage")]
            #[serde(default)]
            source_storage: Strict<Option<StorageBinding>>,
            #[serde(rename = "versionId")]
            #[serde(default)]
            version_id: Strict<Option<Uuid>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            schema: wire.schema.0,
            source: wire.source.0,
            source_storage: wire.source_storage.0,
            version_id: wire.version_id.0,
        })
    }
}

/// The receipt of a mirrored file, to finalize on an `aligned` base.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AlignedFragment {
    /// Contract field receipt.
    #[serde(rename = "receipt")]
    pub receipt: FragmentReceipt,
}
impl<'de> DeserializeStrict<'de> for AlignedFragment {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "receipt")]
            receipt: Strict<FragmentReceipt>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            receipt: wire.receipt.0,
        })
    }
}

/// The Table to append to; the version the rows extend, absent for a new Table; and the write
/// attempt whose directory, `attempts/<attempt>/payloads/`, the rows' files go under. Without an
/// attempt the files go under `data/`, which only a binding that names no part of a write may
/// create. The rows have the Table's schema after `schemaChanges` apply to `base`; every request of
/// one edit carries the same changes, and its receipts finalize on an `edit` base.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AppendRowsRequest {
    /// Contract field attempt.
    #[serde(rename = "attempt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attempt: Option<Uuid>,
    /// Contract field base.
    #[serde(rename = "base")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub base: Option<Uuid>,
    /// Contract field properties.
    #[serde(rename = "properties")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub properties: Option<WriteProperties>,
    /// Contract field schemaChanges.
    #[serde(rename = "schemaChanges")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub schema_changes: Option<Vec<SchemaChange>>,
    /// Contract field table.
    #[serde(rename = "table")]
    pub table: TableBinding,
}
impl<'de> DeserializeStrict<'de> for AppendRowsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attempt")]
            #[serde(default)]
            attempt: Strict<Option<Uuid>>,
            #[serde(rename = "base")]
            #[serde(default)]
            base: Strict<Option<Uuid>>,
            #[serde(rename = "properties")]
            #[serde(default)]
            properties: Strict<Option<WriteProperties>>,
            #[serde(rename = "schemaChanges")]
            #[serde(default)]
            schema_changes: Strict<Option<Vec<SchemaChange>>>,
            #[serde(rename = "table")]
            table: Strict<TableBinding>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt: wire.attempt.0,
            base: wire.base.0,
            properties: wire.properties.0,
            schema_changes: wire.schema_changes.0,
            table: wire.table.0,
        })
    }
}

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

/// An Arrow data type in the JSON form of the Rust `arrow-schema` crate.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ArrowDataType(pub Value);
impl<'de> DeserializeStrict<'de> for ArrowDataType {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<Value>::deserialize(deserializer)?.0))
    }
}

/// One Arrow field in the JSON form of the Rust `arrow-schema` crate: `name`, `data_type`,
/// `nullable`, `dict_id`, `dict_is_ordered` and `metadata`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ArrowField(pub Value);
impl<'de> DeserializeStrict<'de> for ArrowField {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<Value>::deserialize(deserializer)?.0))
    }
}

/// An Arrow schema in the JSON form of the Rust `arrow-schema` crate: `fields` and `metadata`,
/// where each field has `name`, `data_type`, `nullable`, `dict_id`, `dict_is_ordered` and
/// `metadata`. Bind results, projected scan plans and execution outputs can attach a versioned JSON
/// plan description under the reserved metadata key `spiral.execution.plan`. This describes
/// execution rather than row types. A missing executionId denotes a preview; an execution reports
/// its actual physicalId and executionId. Literal payloads are omitted. Evaluate input schemas may
/// opt into aggregate profiling with `spiral.execution.options` metadata (profile, optional opaque
/// caller and partition). Projected scans use execution options independently of collectMetrics.
/// Execution descriptions then include a profile keyed by physical node IDs. Fixed-schema Arrow
/// responses preserve updates in a trailing `scandal.execution` dictionary column tagged by
/// `spiral.execution.frame`; adapters restore plan metadata and strip this framing before exposing
/// row columns. Empty batches can carry terminal or partial reports.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ArrowSchema(pub Value);
impl<'de> DeserializeStrict<'de> for ArrowSchema {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<Value>::deserialize(deserializer)?.0))
    }
}

/// Values for the columns that `schemaChanges` adds, for every row that file `fragmentId` of
/// version `base` keeps, in stored order. The service checks their count, places them at the kept
/// positions, writes nulls at the positions `base` deletes, and writes them as column files
/// attached to the file, to prepare on an `edit` base of `base`. The file's existing files are not
/// rewritten. Files go under `attempt`'s directory.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AttachColumnsRequest {
    /// Contract field attempt.
    #[serde(rename = "attempt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attempt: Option<Uuid>,
    /// Contract field base.
    #[serde(rename = "base")]
    pub base: Uuid,
    /// Contract field fragmentId.
    #[serde(rename = "fragmentId")]
    pub fragment_id: Uuid,
    /// Contract field schemaChanges.
    #[serde(rename = "schemaChanges")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub schema_changes: Option<Vec<SchemaChange>>,
    /// Contract field table.
    #[serde(rename = "table")]
    pub table: TableBinding,
}
impl<'de> DeserializeStrict<'de> for AttachColumnsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attempt")]
            #[serde(default)]
            attempt: Strict<Option<Uuid>>,
            #[serde(rename = "base")]
            base: Strict<Uuid>,
            #[serde(rename = "fragmentId")]
            fragment_id: Strict<Uuid>,
            #[serde(rename = "schemaChanges")]
            #[serde(default)]
            schema_changes: Strict<Option<Vec<SchemaChange>>>,
            #[serde(rename = "table")]
            table: Strict<TableBinding>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt: wire.attempt.0,
            base: wire.base.0,
            fragment_id: wire.fragment_id.0,
            schema_changes: wire.schema_changes.0,
            table: wire.table.0,
        })
    }
}

/// The receipt of an attachment of column files, to finalize.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AttachedColumns {
    /// Contract field receipt.
    #[serde(rename = "receipt")]
    pub receipt: FragmentReceipt,
}
impl<'de> DeserializeStrict<'de> for AttachedColumns {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "receipt")]
            receipt: Strict<FragmentReceipt>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            receipt: wire.receipt.0,
        })
    }
}

/// BindProjectionRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BindProjectionRequest {
    /// Contract field input.
    #[serde(rename = "input")]
    pub input: ArrowSchema,
    /// Contract field projection.
    #[serde(rename = "projection")]
    pub projection: Vec<NamedExpression>,
}
impl<'de> DeserializeStrict<'de> for BindProjectionRequest {
    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<ArrowSchema>,
            #[serde(rename = "projection")]
            projection: Strict<Vec<NamedExpression>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            input: wire.input.0,
            projection: wire.projection.0,
        })
    }
}

/// A reference to a payload that one Table owns. It is never a download URL. `digest` is the BLAKE3
/// digest of the whole payload, as lowercase hexadecimal. The payload is the object
/// `blobs/<objectId>` under the Table's root, or `attempts/<attempt>/blobs/<objectId>` when an
/// upload into a write attempt stored it.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Blob {
    /// Contract field attempt.
    #[serde(rename = "attempt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attempt: Option<Uuid>,
    /// Contract field digest.
    #[serde(rename = "digest")]
    pub digest: String,
    /// Contract field mediaType.
    #[serde(rename = "mediaType")]
    pub media_type: String,
    /// Contract field objectId.
    #[serde(rename = "objectId")]
    pub object_id: Uuid,
    /// Contract field size.
    #[serde(rename = "size")]
    pub size: SafeUnsignedLong,
    /// Contract field tableId.
    #[serde(rename = "tableId")]
    pub table_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for Blob {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attempt")]
            #[serde(default)]
            attempt: Strict<Option<Uuid>>,
            #[serde(rename = "digest")]
            digest: Strict<String>,
            #[serde(rename = "mediaType")]
            media_type: Strict<String>,
            #[serde(rename = "objectId")]
            object_id: Strict<Uuid>,
            #[serde(rename = "size")]
            size: Strict<SafeUnsignedLong>,
            #[serde(rename = "tableId")]
            table_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt: wire.attempt.0,
            digest: wire.digest.0,
            media_type: wire.media_type.0,
            object_id: wire.object_id.0,
            size: wire.size.0,
            table_id: wire.table_id.0,
        })
    }
}

/// A stored part of an upload. Pass it unchanged to complete the upload. `hash` is the BLAKE3
/// chaining value of the part's subtree of the payload, as lowercase hexadecimal. Part 1 also
/// carries its own `digest`, the payload's digest when it is the only part.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BlobPart {
    /// Contract field digest.
    #[serde(rename = "digest")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub digest: Option<String>,
    /// Contract field hash.
    #[serde(rename = "hash")]
    pub hash: String,
    /// Contract field part.
    #[serde(rename = "part")]
    pub part: u32,
    /// Contract field size.
    #[serde(rename = "size")]
    pub size: SafeUnsignedLong,
    /// Contract field tag.
    #[serde(rename = "tag")]
    pub tag: String,
}
impl<'de> DeserializeStrict<'de> for BlobPart {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "digest")]
            #[serde(default)]
            digest: Strict<Option<String>>,
            #[serde(rename = "hash")]
            hash: Strict<String>,
            #[serde(rename = "part")]
            part: Strict<u32>,
            #[serde(rename = "size")]
            size: Strict<SafeUnsignedLong>,
            #[serde(rename = "tag")]
            tag: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            digest: wire.digest.0,
            hash: wire.hash.0,
            part: wire.part.0,
            size: wire.size.0,
            tag: wire.tag.0,
        })
    }
}

/// What storage holds for a blob.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BlobStat {
    /// Contract field etag.
    #[serde(rename = "etag")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub etag: Option<String>,
    /// Contract field size.
    #[serde(rename = "size")]
    pub size: SafeUnsignedLong,
    /// Contract field version.
    #[serde(rename = "version")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
}
impl<'de> DeserializeStrict<'de> for BlobStat {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "etag")]
            #[serde(default)]
            etag: Strict<Option<String>>,
            #[serde(rename = "size")]
            size: Strict<SafeUnsignedLong>,
            #[serde(rename = "version")]
            #[serde(default)]
            version: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            etag: wire.etag.0,
            size: wire.size.0,
            version: wire.version.0,
        })
    }
}

/// A multipart upload of one blob into a write attempt, at `attempts/<attempt>/blobs/<objectId>`
/// under the Table's root. The client keeps it and sends it with each part and with its completion;
/// the storage provider keeps the upload's progress, so any instance serves any step. Every part
/// but the last holds exactly `partBytes`, a power of two.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BlobUpload {
    /// Contract field attempt.
    #[serde(rename = "attempt")]
    pub attempt: Uuid,
    /// Contract field mediaType.
    #[serde(rename = "mediaType")]
    pub media_type: String,
    /// Contract field objectId.
    #[serde(rename = "objectId")]
    pub object_id: Uuid,
    /// Contract field partBytes.
    #[serde(rename = "partBytes")]
    pub part_bytes: SafeUnsignedLong,
    /// Contract field tableId.
    #[serde(rename = "tableId")]
    pub table_id: Uuid,
    /// Contract field uploadId.
    #[serde(rename = "uploadId")]
    pub upload_id: String,
}
impl<'de> DeserializeStrict<'de> for BlobUpload {
    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<Uuid>,
            #[serde(rename = "mediaType")]
            media_type: Strict<String>,
            #[serde(rename = "objectId")]
            object_id: Strict<Uuid>,
            #[serde(rename = "partBytes")]
            part_bytes: Strict<SafeUnsignedLong>,
            #[serde(rename = "tableId")]
            table_id: Strict<Uuid>,
            #[serde(rename = "uploadId")]
            upload_id: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt: wire.attempt.0,
            media_type: wire.media_type.0,
            object_id: wire.object_id.0,
            part_bytes: wire.part_bytes.0,
            table_id: wire.table_id.0,
            upload_id: wire.upload_id.0,
        })
    }
}

/// Bytes `start..end` of a payload.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ByteRange {
    /// Contract field end.
    #[serde(rename = "end")]
    pub end: SafeUnsignedLong,
    /// Contract field start.
    #[serde(rename = "start")]
    pub start: SafeUnsignedLong,
}
impl<'de> DeserializeStrict<'de> for ByteRange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "end")]
            end: Strict<SafeUnsignedLong>,
            #[serde(rename = "start")]
            start: Strict<SafeUnsignedLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            end: wire.end.0,
            start: wire.start.0,
        })
    }
}

/// How version `to` of a Table changed since version `from`. `fragments` has one entry for each
/// file of `to`, in stored order. `removedFragmentIds` names the files of `from` that `to` no
/// longer has; each of their rows was deleted or carried into an added file. `retypedColumns` names
/// the requested columns whose type differs from their type in `from`, including columns that
/// `from` lacks. Each set of row IDs is sorted, disjoint ranges.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ChangePlan {
    /// Contract field fragments.
    #[serde(rename = "fragments")]
    pub fragments: Vec<FragmentChange>,
    /// Contract field removedFragmentIds.
    #[serde(rename = "removedFragmentIds")]
    pub removed_fragment_ids: Vec<Uuid>,
    /// Contract field retypedColumns.
    #[serde(rename = "retypedColumns")]
    pub retyped_columns: Vec<String>,
}
impl<'de> DeserializeStrict<'de> for ChangePlan {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "fragments")]
            fragments: Strict<Vec<FragmentChange>>,
            #[serde(rename = "removedFragmentIds")]
            removed_fragment_ids: Strict<Vec<Uuid>>,
            #[serde(rename = "retypedColumns")]
            retyped_columns: Strict<Vec<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            fragments: wire.fragments.0,
            removed_fragment_ids: wire.removed_fragment_ids.0,
            retyped_columns: wire.retyped_columns.0,
        })
    }
}

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

/// A top-level column, or a nested field by its segments.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ColumnPath {
    /// Contract field path.
    #[serde(rename = "path")]
    pub path: Vec<String>,
}
impl<'de> DeserializeStrict<'de> for ColumnPath {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "path")]
            path: Strict<Vec<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self { path: wire.path.0 })
    }
}

/// Stored bounds and counts for one output column. Values are typed literal expressions; missing
/// values are unknown.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ColumnStatistics {
    /// Contract field countsExact.
    #[serde(rename = "countsExact")]
    pub counts_exact: bool,
    /// Contract field maxExact.
    #[serde(rename = "maxExact")]
    pub max_exact: bool,
    /// Contract field maxValue.
    #[serde(rename = "maxValue")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_value: Option<Expression>,
    /// Contract field minExact.
    #[serde(rename = "minExact")]
    pub min_exact: bool,
    /// Contract field minValue.
    #[serde(rename = "minValue")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub min_value: Option<Expression>,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
    /// Contract field nanCount.
    #[serde(rename = "nanCount")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub nan_count: Option<SafeUnsignedLong>,
    /// Contract field nullCount.
    #[serde(rename = "nullCount")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub null_count: Option<SafeUnsignedLong>,
}
impl<'de> DeserializeStrict<'de> for ColumnStatistics {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "countsExact")]
            counts_exact: Strict<bool>,
            #[serde(rename = "maxExact")]
            max_exact: Strict<bool>,
            #[serde(rename = "maxValue")]
            #[serde(default)]
            max_value: Strict<Option<Expression>>,
            #[serde(rename = "minExact")]
            min_exact: Strict<bool>,
            #[serde(rename = "minValue")]
            #[serde(default)]
            min_value: Strict<Option<Expression>>,
            #[serde(rename = "name")]
            name: Strict<String>,
            #[serde(rename = "nanCount")]
            #[serde(default)]
            nan_count: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "nullCount")]
            #[serde(default)]
            null_count: Strict<Option<SafeUnsignedLong>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            counts_exact: wire.counts_exact.0,
            max_exact: wire.max_exact.0,
            max_value: wire.max_value.0,
            min_exact: wire.min_exact.0,
            min_value: wire.min_value.0,
            name: wire.name.0,
            nan_count: wire.nan_count.0,
            null_count: wire.null_count.0,
        })
    }
}

/// Every part of an upload, in order from part 1.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CompleteBlobUploadRequest {
    /// Contract field parts.
    #[serde(rename = "parts")]
    pub parts: Vec<BlobPart>,
    /// Contract field storage.
    #[serde(rename = "storage")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub storage: Option<StorageBinding>,
    /// Contract field upload.
    #[serde(rename = "upload")]
    pub upload: BlobUpload,
}
impl<'de> DeserializeStrict<'de> for CompleteBlobUploadRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "parts")]
            parts: Strict<Vec<BlobPart>>,
            #[serde(rename = "storage")]
            #[serde(default)]
            storage: Strict<Option<StorageBinding>>,
            #[serde(rename = "upload")]
            upload: Strict<BlobUpload>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            parts: wire.parts.0,
            storage: wire.storage.0,
            upload: wire.upload.0,
        })
    }
}

/// Counts rows, or the non-null values of `column` when it is set.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CountAggregate {
    /// Contract field column.
    #[serde(rename = "column")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub column: Option<String>,
}
impl<'de> DeserializeStrict<'de> for CountAggregate {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "column")]
            #[serde(default)]
            column: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            column: wire.column.0,
        })
    }
}

/// Delete visible rows matching the exact predicate, or all visible rows without one. Deletion
/// files use the attempt's storage binding; version metadata uses the finalization request's
/// publication binding. Both bindings must name the same root.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct DeleteBase {
    /// Contract field attempt.
    #[serde(rename = "attempt")]
    pub attempt: Uuid,
    /// Contract field expectedRows.
    #[serde(rename = "expectedRows")]
    pub expected_rows: SafeUnsignedLong,
    /// Contract field filter.
    #[serde(rename = "filter")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub filter: Option<Expression>,
    /// Contract field storage.
    #[serde(rename = "storage")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub storage: Option<StorageBinding>,
    /// Contract field versionId.
    #[serde(rename = "versionId")]
    pub version_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for DeleteBase {
    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<Uuid>,
            #[serde(rename = "expectedRows")]
            expected_rows: Strict<SafeUnsignedLong>,
            #[serde(rename = "filter")]
            #[serde(default)]
            filter: Strict<Option<Expression>>,
            #[serde(rename = "storage")]
            #[serde(default)]
            storage: Strict<Option<StorageBinding>>,
            #[serde(rename = "versionId")]
            version_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt: wire.attempt.0,
            expected_rows: wire.expected_rows.0,
            filter: wire.filter.0,
            storage: wire.storage.0,
            version_id: wire.version_id.0,
        })
    }
}

/// The Table whose rows to delete, the version they belong to, and the write attempt whose
/// directory the deletion files go under. The Arrow rows hold only `rowIdColumn`, a `uint64` column
/// of the row IDs to delete; each must be visible in `base`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct DeleteRowsRequest {
    /// Contract field attempt.
    #[serde(rename = "attempt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attempt: Option<Uuid>,
    /// Contract field base.
    #[serde(rename = "base")]
    pub base: Uuid,
    /// Contract field rowIdColumn.
    #[serde(rename = "rowIdColumn")]
    pub row_id_column: String,
    /// Contract field table.
    #[serde(rename = "table")]
    pub table: TableBinding,
}
impl<'de> DeserializeStrict<'de> for DeleteRowsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attempt")]
            #[serde(default)]
            attempt: Strict<Option<Uuid>>,
            #[serde(rename = "base")]
            base: Strict<Uuid>,
            #[serde(rename = "rowIdColumn")]
            row_id_column: Strict<String>,
            #[serde(rename = "table")]
            table: Strict<TableBinding>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt: wire.attempt.0,
            base: wire.base.0,
            row_id_column: wire.row_id_column.0,
            table: wire.table.0,
        })
    }
}

/// A read-only provider credential for a signed binding's storage: the `s3://` or `gs://` root
/// where the binding's root lives at its provider, and the provider session as JSON.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct DirectRead {
    /// Contract field credential.
    #[serde(rename = "credential")]
    pub credential: StorageCredential,
    /// Contract field rootUri.
    #[serde(rename = "rootUri")]
    pub root_uri: String,
}
impl<'de> DeserializeStrict<'de> for DirectRead {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "credential")]
            credential: Strict<StorageCredential>,
            #[serde(rename = "rootUri")]
            root_uri: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            credential: wire.credential.0,
            root_uri: wire.root_uri.0,
        })
    }
}

/// A successor of `versionId` built from the receipts of appends, patches, deleted rows and column
/// files, after `schemaChanges` apply to its schema. Every request that wrote one of its receipts
/// carried the same `schemaChanges`. Finalizing refuses a row both changed and deleted, a cell
/// changed twice, and a column written twice for one file.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct EditBase {
    /// Contract field schemaChanges.
    #[serde(rename = "schemaChanges")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub schema_changes: Option<Vec<SchemaChange>>,
    /// Contract field versionId.
    #[serde(rename = "versionId")]
    pub version_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for EditBase {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "schemaChanges")]
            #[serde(default)]
            schema_changes: Strict<Option<Vec<SchemaChange>>>,
            #[serde(rename = "versionId")]
            version_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            schema_changes: wire.schema_changes.0,
            version_id: wire.version_id.0,
        })
    }
}

/// What each split of a scan returns in place of its output rows: a top-k or aggregates. Each split
/// returns partial results; merging every split's results with the same emit gives the scan's
/// result, which the SDKs do. A split's results are complete only at the end of its stream, so a
/// failed split is read again from its start. A scan with an emit takes no `limit`.
#[derive(Clone, Debug, PartialEq)]
pub enum Emit {
    /// A known union arm.
    Aggregate(Aggregate),
    /// A known union arm.
    TopK(TopK),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for Emit {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Aggregate(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("aggregate".into()));
                object.insert(
                    "aggregate".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::TopK(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("topK".into()));
                object.insert(
                    "topK".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 Emit {
    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 {
            "aggregate" => Ok(Self::Aggregate(
                serde_json::from_value(
                    value
                        .get("aggregate")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "topK" => Ok(Self::TopK(
                serde_json::from_value(
                    value
                        .get("topK")
                        .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 Emit {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "aggregate")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "aggregate")]
            value: Strict<Aggregate>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "topK")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "topK")]
            value: Strict<TopK>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Aggregate(Box<__Arm0>),
            TopK(Box<__Arm1>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Aggregate(arm) => Self::Aggregate(arm.value.0),
            __Known::TopK(arm) => Self::TopK(arm.value.0),
        })
    }
}

/// Named expressions to evaluate, and the Tables whose blobs they may read.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct EvaluateRequest {
    /// Contract field projection.
    #[serde(rename = "projection")]
    pub projection: Vec<NamedExpression>,
    /// Contract field tables.
    #[serde(rename = "tables")]
    pub tables: Vec<TableBinding>,
}
impl<'de> DeserializeStrict<'de> for EvaluateRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "projection")]
            projection: Strict<Vec<NamedExpression>>,
            #[serde(rename = "tables")]
            tables: Strict<Vec<TableBinding>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            projection: wire.projection.0,
            tables: wire.tables.0,
        })
    }
}

/// Generic opt-in execution observations, separate from row semantics. A profile aggregates the
/// physical plan's node measurements without retaining per-row history. Caller is an opaque
/// correlation ID (at most 128 ASCII letters, digits, hyphen, underscore, dot or colon).
/// Unsupported device and allocator observations remain unknown.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ExecutionOptions {
    /// Contract field caller.
    #[serde(rename = "caller")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub caller: Option<String>,
    /// Contract field partition.
    #[serde(rename = "partition")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub partition: Option<u32>,
    /// Contract field profile.
    #[serde(rename = "profile")]
    pub profile: bool,
}
impl<'de> DeserializeStrict<'de> for ExecutionOptions {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "caller")]
            #[serde(default)]
            caller: Strict<Option<String>>,
            #[serde(rename = "partition")]
            #[serde(default)]
            partition: Strict<Option<u32>>,
            #[serde(rename = "profile")]
            profile: Strict<bool>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            caller: wire.caller.0,
            partition: wire.partition.0,
            profile: wire.profile.0,
        })
    }
}

/// An unbound SPQL expression in its protobuf encoding, base64-encoded with the standard alphabet
/// and padding, at most 512 KiB before encoding. The Rust SDK's `Expression` type produces it. The
/// service binds it against the exact input schema.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct Expression(pub String);
impl std::fmt::Display for Expression {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for Expression {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
    }
}

/// One top-level clause of a scan's filter and how the service enforces it.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FilterClause {
    /// Contract field expression.
    #[serde(rename = "expression")]
    pub expression: Expression,
    /// Contract field reason.
    #[serde(rename = "reason")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    /// Contract field support.
    #[serde(rename = "support")]
    pub support: FilterSupport,
}
impl<'de> DeserializeStrict<'de> for FilterClause {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "expression")]
            expression: Strict<Expression>,
            #[serde(rename = "reason")]
            #[serde(default)]
            reason: Strict<Option<String>>,
            #[serde(rename = "support")]
            support: Strict<FilterSupport>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            expression: wire.expression.0,
            reason: wire.reason.0,
            support: wire.support.0,
        })
    }
}

/// How exactly the service enforces one filter clause.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum FilterSupport {
    /// A known contract value.
    Exact,
    /// A known contract value.
    Inexact,
    /// A known contract value.
    Unsupported,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for FilterSupport {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Exact => "exact",
            Self::Inexact => "inexact",
            Self::Unsupported => "unsupported",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for FilterSupport {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "exact" => Self::Exact,
            "inexact" => Self::Inexact,
            "unsupported" => Self::Unsupported,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for FilterSupport {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "exact")]
            Exact,
            #[serde(rename = "inexact")]
            Inexact,
            #[serde(rename = "unsupported")]
            Unsupported,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Exact => Self::Exact,
            __Known::Inexact => Self::Inexact,
            __Known::Unsupported => Self::Unsupported,
        })
    }
}

/// The receipts of the appends, patches, deleted rows, column files and mirrored files a version
/// takes. Patches, deletions and column files need an `edit` base, since the rows they change are
/// the base's rows; mirrored files, and patches to a mirroring Table, need an `aligned` base.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FinalizeWriteRequest {
    /// Contract field base.
    #[serde(rename = "base")]
    pub base: WriteBase,
    /// Contract field receipts.
    #[serde(rename = "receipts")]
    pub receipts: Vec<FragmentReceipt>,
    /// Contract field table.
    #[serde(rename = "table")]
    pub table: TableBinding,
}
impl<'de> DeserializeStrict<'de> for FinalizeWriteRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "base")]
            base: Strict<WriteBase>,
            #[serde(rename = "receipts")]
            receipts: Strict<Vec<FragmentReceipt>>,
            #[serde(rename = "table")]
            table: Strict<TableBinding>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            base: wire.base.0,
            receipts: wire.receipts.0,
            table: wire.table.0,
        })
    }
}

/// One file of `to`, its stored row count, and how it relates to `from`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FragmentChange {
    /// Contract field change.
    #[serde(rename = "change")]
    pub change: FragmentDelta,
    /// Contract field fragmentId.
    #[serde(rename = "fragmentId")]
    pub fragment_id: Uuid,
    /// Contract field rowCount.
    #[serde(rename = "rowCount")]
    pub row_count: SafeUnsignedLong,
}
impl<'de> DeserializeStrict<'de> for FragmentChange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "change")]
            change: Strict<FragmentDelta>,
            #[serde(rename = "fragmentId")]
            fragment_id: Strict<Uuid>,
            #[serde(rename = "rowCount")]
            row_count: Strict<SafeUnsignedLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            change: wire.change.0,
            fragment_id: wire.fragment_id.0,
            row_count: wire.row_count.0,
        })
    }
}

/// `retained` for a file that `from` has at the same positions, `added` for a file written after
/// `from`.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum FragmentDelta {
    /// A known union arm.
    Added(AddedFragment),
    /// A known union arm.
    Retained(RetainedFragment),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for FragmentDelta {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Added(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("added".into()));
                object.insert(
                    "added".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Retained(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("retained".into()));
                object.insert(
                    "retained".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 FragmentDelta {
    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 {
            "added" => Ok(Self::Added(
                serde_json::from_value(
                    value
                        .get("added")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "retained" => Ok(Self::Retained(
                serde_json::from_value(
                    value
                        .get("retained")
                        .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 FragmentDelta {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "added")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "added")]
            value: Strict<AddedFragment>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "retained")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "retained")]
            value: Strict<RetainedFragment>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Added(Box<__Arm0>),
            Retained(Box<__Arm1>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Added(arm) => Self::Added(arm.value.0),
            __Known::Retained(arm) => Self::Retained(arm.value.0),
        })
    }
}

/// One file an append wrote. Pass it unchanged to finalize a write.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FragmentReceipt {
    /// Contract field token.
    #[serde(rename = "token")]
    pub token: String,
}
impl<'de> DeserializeStrict<'de> for FragmentReceipt {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "token")]
            token: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            token: wire.token.0,
        })
    }
}

/// A standard SQL spelling of a canonical SPQL function and its provenance.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FunctionAlias {
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
    /// Contract field source.
    #[serde(rename = "source")]
    pub source: String,
}
impl<'de> DeserializeStrict<'de> for FunctionAlias {
    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 = "source")]
            source: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            name: wire.name.0,
            source: wire.source.0,
        })
    }
}

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

/// An SPQL function, with its overloads in the order a call resolves them.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FunctionInfo {
    /// Contract field aliases.
    #[serde(rename = "aliases")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub aliases: Option<Vec<FunctionAlias>>,
    /// Contract field id.
    #[serde(rename = "id")]
    pub id: String,
    /// Contract field overloads.
    #[serde(rename = "overloads")]
    pub overloads: Vec<OverloadInfo>,
    /// Contract field volatility.
    #[serde(rename = "volatility")]
    pub volatility: FunctionVolatility,
}
impl<'de> DeserializeStrict<'de> for FunctionInfo {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "aliases")]
            #[serde(default)]
            aliases: Strict<Option<Vec<FunctionAlias>>>,
            #[serde(rename = "id")]
            id: Strict<String>,
            #[serde(rename = "overloads")]
            overloads: Strict<Vec<OverloadInfo>>,
            #[serde(rename = "volatility")]
            volatility: Strict<FunctionVolatility>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            aliases: wire.aliases.0,
            id: wire.id.0,
            overloads: wire.overloads.0,
            volatility: wire.volatility.0,
        })
    }
}

/// Whether a function's result can change for the same arguments.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum FunctionVolatility {
    /// A known contract value.
    Immutable,
    /// A known contract value.
    Stable,
    /// A known contract value.
    Volatile,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for FunctionVolatility {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Immutable => "immutable",
            Self::Stable => "stable",
            Self::Volatile => "volatile",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for FunctionVolatility {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "immutable" => Self::Immutable,
            "stable" => Self::Stable,
            "volatile" => Self::Volatile,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for FunctionVolatility {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "immutable")]
            Immutable,
            #[serde(rename = "stable")]
            Stable,
            #[serde(rename = "volatile")]
            Volatile,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Immutable => Self::Immutable,
            __Known::Stable => Self::Stable,
            __Known::Volatile => Self::Volatile,
        })
    }
}

/// The Table's first version, with the schema its appends used.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct GenesisBase {
    /// Contract field schema.
    #[serde(rename = "schema")]
    pub schema: ArrowSchema,
}
impl<'de> DeserializeStrict<'de> for GenesisBase {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "schema")]
            schema: Strict<ArrowSchema>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            schema: wire.schema.0,
        })
    }
}

/// Counts of a numeric column's values in `bins` bins of `width` from `start`, as a fixed-size list
/// of `bins + 2` counts: values below `start`, each bin in order, then values at or past the last
/// bin's end. Nulls and NaN are not counted. `bins` is at most 4,096.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct HistogramAggregate {
    /// Contract field bins.
    #[serde(rename = "bins")]
    pub bins: u32,
    /// Contract field column.
    #[serde(rename = "column")]
    pub column: String,
    /// Contract field start.
    #[serde(rename = "start")]
    pub start: f64,
    /// Contract field width.
    #[serde(rename = "width")]
    pub width: f64,
}
impl<'de> DeserializeStrict<'de> for HistogramAggregate {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "bins")]
            bins: Strict<u32>,
            #[serde(rename = "column")]
            column: Strict<String>,
            #[serde(rename = "start")]
            start: Strict<f64>,
            #[serde(rename = "width")]
            width: Strict<f64>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            bins: wire.bins.0,
            column: wire.column.0,
            start: wire.start.0,
            width: wire.width.0,
        })
    }
}

/// One typed predicate, applied before the read window. Kinds are text, number, boolean, uuid,
/// date, timestamp, duration and other. Operators are isNull, isNotNull, isTrue, isFalse, isEmpty,
/// isNotEmpty, contains, startsWith, endsWith, eq, notEq, gt, gte, lt and lte. Values are bound as
/// typed parameters; callers cannot submit SQL. Column and operator compatibility is checked by the
/// scan engine, including ordered text comparisons.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct LegacyFilter {
    /// Contract field field.
    #[serde(rename = "field")]
    pub field: String,
    /// Contract field kind.
    #[serde(rename = "kind")]
    pub kind: String,
    /// Contract field operator.
    #[serde(rename = "operator")]
    pub operator: String,
    /// Contract field value.
    #[serde(rename = "value")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}
impl<'de> DeserializeStrict<'de> for LegacyFilter {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "field")]
            field: Strict<String>,
            #[serde(rename = "kind")]
            kind: Strict<String>,
            #[serde(rename = "operator")]
            operator: Strict<String>,
            #[serde(rename = "value")]
            #[serde(default)]
            value: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            field: wire.field.0,
            kind: wire.kind.0,
            operator: wire.operator.0,
            value: wire.value.0,
        })
    }
}

/// Resolved legacy table metadata from GET /v1/tables/{tableId}/read-snapshot, passed unchanged:
/// tableId, asof, keySchema, keySpace and columnGroups. WAL patches are already folded at asof. No
/// credentials or endpoints occur here. This is a live read snapshot, not an Arbor version or a
/// resumable split.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct LegacyTableSnapshot(pub Value);
impl<'de> DeserializeStrict<'de> for LegacyTableSnapshot {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<Value>::deserialize(deserializer)?.0))
    }
}

/// Move the column or field at `path` after `after`, or first when absent.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct MoveColumn {
    /// Contract field after.
    #[serde(rename = "after")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub after: Option<Vec<String>>,
    /// Contract field path.
    #[serde(rename = "path")]
    pub path: Vec<String>,
}
impl<'de> DeserializeStrict<'de> for MoveColumn {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "after")]
            #[serde(default)]
            after: Strict<Option<Vec<String>>>,
            #[serde(rename = "path")]
            path: Strict<Vec<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            after: wire.after.0,
            path: wire.path.0,
        })
    }
}

/// One aggregate of an aggregate emit, as the output column `name`.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct NamedAggregate {
    /// Contract field function.
    #[serde(rename = "function")]
    pub function: AggregateFunction,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
}
impl<'de> DeserializeStrict<'de> for NamedAggregate {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "function")]
            function: Strict<AggregateFunction>,
            #[serde(rename = "name")]
            name: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            function: wire.function.0,
            name: wire.name.0,
        })
    }
}

/// One output column computed from each input row.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct NamedExpression {
    /// Contract field expression.
    #[serde(rename = "expression")]
    pub expression: Expression,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
}
impl<'de> DeserializeStrict<'de> for NamedExpression {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "expression")]
            expression: Strict<Expression>,
            #[serde(rename = "name")]
            name: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            expression: wire.expression.0,
            name: wire.name.0,
        })
    }
}

/// One overload of a function. `asynchronous` overloads run between batches, as storage reads do.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct OverloadInfo {
    /// Contract field asynchronous.
    #[serde(rename = "asynchronous")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub asynchronous: Option<bool>,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
    /// Contract field parameters.
    #[serde(rename = "parameters")]
    pub parameters: Vec<ParameterInfo>,
    /// Contract field summary.
    #[serde(rename = "summary")]
    pub summary: String,
}
impl<'de> DeserializeStrict<'de> for OverloadInfo {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "asynchronous")]
            #[serde(default)]
            asynchronous: Strict<Option<bool>>,
            #[serde(rename = "name")]
            name: Strict<String>,
            #[serde(rename = "parameters")]
            parameters: Strict<Vec<ParameterInfo>>,
            #[serde(rename = "summary")]
            summary: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            asynchronous: wire.asynchronous.0,
            name: wire.name.0,
            parameters: wire.parameters.0,
            summary: wire.summary.0,
        })
    }
}

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

/// One parameter of an overload. `accepts` names the accepted types, such as `utf8`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ParameterInfo {
    /// Contract field accepts.
    #[serde(rename = "accepts")]
    pub accepts: String,
    /// Contract field literal.
    #[serde(rename = "literal")]
    pub literal: bool,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
    /// Contract field required.
    #[serde(rename = "required")]
    pub required: bool,
}
impl<'de> DeserializeStrict<'de> for ParameterInfo {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "accepts")]
            accepts: Strict<String>,
            #[serde(rename = "literal")]
            literal: Strict<bool>,
            #[serde(rename = "name")]
            name: Strict<String>,
            #[serde(rename = "required")]
            required: Strict<bool>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            accepts: wire.accepts.0,
            literal: wire.literal.0,
            name: wire.name.0,
            required: wire.required.0,
        })
    }
}

/// A storage partition key and its canonical Iceberg transform.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PartitionColumn {
    /// Contract field path.
    #[serde(rename = "path")]
    pub path: Vec<String>,
    /// Contract field transform.
    #[serde(rename = "transform")]
    pub transform: String,
}
impl<'de> DeserializeStrict<'de> for PartitionColumn {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "path")]
            path: Strict<Vec<String>>,
            #[serde(rename = "transform")]
            transform: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            path: wire.path.0,
            transform: wire.transform.0,
        })
    }
}

/// The Table whose rows to patch, the version they belong to, and the write attempt whose directory
/// the patch files go under. The Arrow rows name each target by its row ID in `rowIdColumn`, a
/// `uint64` column; their other columns are columns of the Table, after `schemaChanges`, and
/// replace those values. A row ID appears at most once per request.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PatchRowsRequest {
    /// Contract field attempt.
    #[serde(rename = "attempt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attempt: Option<Uuid>,
    /// Contract field base.
    #[serde(rename = "base")]
    pub base: Uuid,
    /// Contract field rowIdColumn.
    #[serde(rename = "rowIdColumn")]
    pub row_id_column: String,
    /// Contract field schemaChanges.
    #[serde(rename = "schemaChanges")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub schema_changes: Option<Vec<SchemaChange>>,
    /// Contract field table.
    #[serde(rename = "table")]
    pub table: TableBinding,
}
impl<'de> DeserializeStrict<'de> for PatchRowsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attempt")]
            #[serde(default)]
            attempt: Strict<Option<Uuid>>,
            #[serde(rename = "base")]
            base: Strict<Uuid>,
            #[serde(rename = "rowIdColumn")]
            row_id_column: Strict<String>,
            #[serde(rename = "schemaChanges")]
            #[serde(default)]
            schema_changes: Strict<Option<Vec<SchemaChange>>>,
            #[serde(rename = "table")]
            table: Strict<TableBinding>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt: wire.attempt.0,
            base: wire.base.0,
            row_id_column: wire.row_id_column.0,
            schema_changes: wire.schema_changes.0,
            table: wire.table.0,
        })
    }
}

/// Two versions of one Table: `to`, and `from`, which is `to` or one of its ancestors at most 4,096
/// versions back. `columns` names the top-level columns of `to` whose changes count, or all of them
/// when absent.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PlanChangesRequest {
    /// Contract field columns.
    #[serde(rename = "columns")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub columns: Option<Vec<String>>,
    /// Contract field from.
    #[serde(rename = "from")]
    pub from: Uuid,
    /// Contract field storage.
    #[serde(rename = "storage")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub storage: Option<StorageBinding>,
    /// Contract field table.
    #[serde(rename = "table")]
    pub table: Uuid,
    /// Contract field to.
    #[serde(rename = "to")]
    pub to: Uuid,
}
impl<'de> DeserializeStrict<'de> for PlanChangesRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "columns")]
            #[serde(default)]
            columns: Strict<Option<Vec<String>>>,
            #[serde(rename = "from")]
            from: Strict<Uuid>,
            #[serde(rename = "storage")]
            #[serde(default)]
            storage: Strict<Option<StorageBinding>>,
            #[serde(rename = "table")]
            table: Strict<Uuid>,
            #[serde(rename = "to")]
            to: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            columns: wire.columns.0,
            from: wire.from.0,
            storage: wire.storage.0,
            table: wire.table.0,
            to: wire.to.0,
        })
    }
}

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

/// A split chosen by planning, with estimates for scheduling, and the stable ID of the file it
/// reads, which change plans and column attachments name.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PlannedSplit {
    /// Contract field estimatedBytes.
    #[serde(rename = "estimatedBytes")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub estimated_bytes: Option<SafeUnsignedLong>,
    /// Contract field estimatedRows.
    #[serde(rename = "estimatedRows")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub estimated_rows: Option<SafeUnsignedLong>,
    /// Contract field fragmentId.
    #[serde(rename = "fragmentId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fragment_id: Option<Uuid>,
    /// Contract field ordering.
    #[serde(rename = "ordering")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ordering: Option<Vec<SortColumn>>,
    /// Contract field split.
    #[serde(rename = "split")]
    pub split: Split,
}
impl<'de> DeserializeStrict<'de> for PlannedSplit {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "estimatedBytes")]
            #[serde(default)]
            estimated_bytes: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "estimatedRows")]
            #[serde(default)]
            estimated_rows: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "fragmentId")]
            #[serde(default)]
            fragment_id: Strict<Option<Uuid>>,
            #[serde(rename = "ordering")]
            #[serde(default)]
            ordering: Strict<Option<Vec<SortColumn>>>,
            #[serde(rename = "split")]
            split: Strict<Split>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            estimated_bytes: wire.estimated_bytes.0,
            estimated_rows: wire.estimated_rows.0,
            fragment_id: wire.fragment_id.0,
            ordering: wire.ordering.0,
            split: wire.split.0,
        })
    }
}

/// A prepared Table version, awaiting registration with the Tables API. `sequence` is its position
/// in the Table's history.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PreparedWriteReceipt {
    /// Contract field baseVersion.
    #[serde(rename = "baseVersion")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub base_version: Option<Uuid>,
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    pub resource_id: Uuid,
    /// Contract field sequence.
    #[serde(rename = "sequence")]
    pub sequence: SafeUnsignedLong,
    /// Contract field versionId.
    #[serde(rename = "versionId")]
    pub version_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for PreparedWriteReceipt {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "baseVersion")]
            #[serde(default)]
            base_version: Strict<Option<Uuid>>,
            #[serde(rename = "resourceId")]
            resource_id: Strict<Uuid>,
            #[serde(rename = "sequence")]
            sequence: Strict<SafeUnsignedLong>,
            #[serde(rename = "versionId")]
            version_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            base_version: wire.base_version.0,
            resource_id: wire.resource_id.0,
            sequence: wire.sequence.0,
            version_id: wire.version_id.0,
        })
    }
}

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

/// A bounded legacy read over host-resolved metadata and storage. limit is at most 10000; zero
/// reads only the schema, otherwise one extra row signals truncation. offset is at most 10000. Up
/// to 32 filters are allowed. scope is Cell, Panel or FullView for images. The read has a
/// one-minute deadline and a 64 MiB output bound. Optional filter is an exact synchronous
/// expression conjoined with filters before the window. Supported forms are field references, typed
/// literals, comparisons, boolean operators, null checks and synchronous SPQL calls. Other
/// expression forms are rejected. Optional columns selects top-level fields in output order after
/// filtering; absent selects all fields.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ReadLegacyTableRequest {
    /// Contract field columns.
    #[serde(rename = "columns")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub columns: Option<Vec<String>>,
    /// Contract field filter.
    #[serde(rename = "filter")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub filter: Option<Expression>,
    /// Contract field filters.
    #[serde(rename = "filters")]
    pub filters: Vec<LegacyFilter>,
    /// Contract field limit.
    #[serde(rename = "limit")]
    pub limit: u32,
    /// Contract field offset.
    #[serde(rename = "offset")]
    pub offset: u32,
    /// Contract field scope.
    #[serde(rename = "scope")]
    pub scope: String,
    /// Contract field snapshot.
    #[serde(rename = "snapshot")]
    pub snapshot: LegacyTableSnapshot,
    /// Contract field storage.
    #[serde(rename = "storage")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub storage: Option<StorageBinding>,
}
impl<'de> DeserializeStrict<'de> for ReadLegacyTableRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "columns")]
            #[serde(default)]
            columns: Strict<Option<Vec<String>>>,
            #[serde(rename = "filter")]
            #[serde(default)]
            filter: Strict<Option<Expression>>,
            #[serde(rename = "filters")]
            filters: Strict<Vec<LegacyFilter>>,
            #[serde(rename = "limit")]
            limit: Strict<u32>,
            #[serde(rename = "offset")]
            offset: Strict<u32>,
            #[serde(rename = "scope")]
            scope: Strict<String>,
            #[serde(rename = "snapshot")]
            snapshot: Strict<LegacyTableSnapshot>,
            #[serde(rename = "storage")]
            #[serde(default)]
            storage: Strict<Option<StorageBinding>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            columns: wire.columns.0,
            filter: wire.filter.0,
            filters: wire.filters.0,
            limit: wire.limit.0,
            offset: wire.offset.0,
            scope: wire.scope.0,
            snapshot: wire.snapshot.0,
            storage: wire.storage.0,
        })
    }
}

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

/// Rename the column or field at `path` to `name`, keeping its values.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RenameColumn {
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: String,
    /// Contract field path.
    #[serde(rename = "path")]
    pub path: Vec<String>,
}
impl<'de> DeserializeStrict<'de> for RenameColumn {
    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 = "path")]
            path: Strict<Vec<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            name: wire.name.0,
            path: wire.path.0,
        })
    }
}

/// A file of `from`, row for row at the same positions. `patched` holds the rows that `to` keeps
/// and whose requested columns a patch or column file wrote after `from`; `deleted` holds the rows
/// deleted after `from`. Every other row holds the values it held in `from`, so the file is
/// unchanged when both are empty.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RetainedFragment {
    /// Contract field deleted.
    #[serde(rename = "deleted")]
    pub deleted: Vec<RowIdRange>,
    /// Contract field patched.
    #[serde(rename = "patched")]
    pub patched: Vec<RowIdRange>,
}
impl<'de> DeserializeStrict<'de> for RetainedFragment {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "deleted")]
            deleted: Strict<Vec<RowIdRange>>,
            #[serde(rename = "patched")]
            patched: Strict<Vec<RowIdRange>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            deleted: wire.deleted.0,
            patched: wire.patched.0,
        })
    }
}

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

/// Stored rows `start..end` of one file, counted from its first stored row.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RowRange {
    /// Contract field end.
    #[serde(rename = "end")]
    pub end: SafeUnsignedLong,
    /// Contract field start.
    #[serde(rename = "start")]
    pub start: SafeUnsignedLong,
}
impl<'de> DeserializeStrict<'de> for RowRange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "end")]
            end: Strict<SafeUnsignedLong>,
            #[serde(rename = "start")]
            start: Strict<SafeUnsignedLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            end: wire.end.0,
            start: wire.start.0,
        })
    }
}

/// A read of one Table version, sent whole with every plan and read request. `columns` selects
/// top-level columns, or all of them when absent; `projection` computes the output columns instead.
/// A `filter` clause that the service cannot enforce exactly fails the scan before any rows are
/// read. `limit` caps the rows each split returns, in stored order. An `emit` returns a top-k or
/// aggregates of the output rows instead of the rows themselves. `rowRange` selects half-open
/// stored positions in this exact version, before filtering and deletion removal, concatenating
/// fragments in stored order. Positions are not stable across rewrites. Empty ranges return no
/// rows; reversed ranges are invalid. `rowIdColumn` adds a last output column of that name holding
/// each row's row ID: the Table's stable identity of the row, a `uint64` that survives rewrites and
/// compaction and is never reused. `rowIds` keeps only rows whose row IDs fall in its ranges:
/// planning prunes files whose row IDs cannot match, and reads enforce it exactly. A top-k can
/// return and order by the row ID column. Aggregates take no `rowIdColumn`.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Scan {
    /// Contract field batchRows.
    #[serde(rename = "batchRows")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub batch_rows: Option<u32>,
    /// Contract field collectMetrics.
    #[serde(rename = "collectMetrics")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub collect_metrics: Option<bool>,
    /// Contract field columns.
    #[serde(rename = "columns")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub columns: Option<Vec<String>>,
    /// Contract field emit.
    #[serde(rename = "emit")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub emit: Option<Emit>,
    /// Contract field execution.
    #[serde(rename = "execution")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execution: Option<ExecutionOptions>,
    /// Contract field filter.
    #[serde(rename = "filter")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub filter: Option<Expression>,
    /// Contract field limit.
    #[serde(rename = "limit")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<SafeUnsignedLong>,
    /// Contract field projection.
    #[serde(rename = "projection")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub projection: Option<Vec<NamedExpression>>,
    /// Contract field rowIdColumn.
    #[serde(rename = "rowIdColumn")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub row_id_column: Option<String>,
    /// Contract field rowIds.
    #[serde(rename = "rowIds")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub row_ids: Option<Vec<RowIdRange>>,
    /// Contract field rowRange.
    #[serde(rename = "rowRange")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub row_range: Option<RowRange>,
    /// Contract field table.
    #[serde(rename = "table")]
    pub table: TableVersion,
}
impl<'de> DeserializeStrict<'de> for Scan {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "batchRows")]
            #[serde(default)]
            batch_rows: Strict<Option<u32>>,
            #[serde(rename = "collectMetrics")]
            #[serde(default)]
            collect_metrics: Strict<Option<bool>>,
            #[serde(rename = "columns")]
            #[serde(default)]
            columns: Strict<Option<Vec<String>>>,
            #[serde(rename = "emit")]
            #[serde(default)]
            emit: Strict<Option<Emit>>,
            #[serde(rename = "execution")]
            #[serde(default)]
            execution: Strict<Option<ExecutionOptions>>,
            #[serde(rename = "filter")]
            #[serde(default)]
            filter: Strict<Option<Expression>>,
            #[serde(rename = "limit")]
            #[serde(default)]
            limit: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "projection")]
            #[serde(default)]
            projection: Strict<Option<Vec<NamedExpression>>>,
            #[serde(rename = "rowIdColumn")]
            #[serde(default)]
            row_id_column: Strict<Option<String>>,
            #[serde(rename = "rowIds")]
            #[serde(default)]
            row_ids: Strict<Option<Vec<RowIdRange>>>,
            #[serde(rename = "rowRange")]
            #[serde(default)]
            row_range: Strict<Option<RowRange>>,
            #[serde(rename = "table")]
            table: Strict<TableVersion>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            batch_rows: wire.batch_rows.0,
            collect_metrics: wire.collect_metrics.0,
            columns: wire.columns.0,
            emit: wire.emit.0,
            execution: wire.execution.0,
            filter: wire.filter.0,
            limit: wire.limit.0,
            projection: wire.projection.0,
            row_id_column: wire.row_id_column.0,
            row_ids: wire.row_ids.0,
            row_range: wire.row_range.0,
            table: wire.table.0,
        })
    }
}

/// A scan describes its output schema and filter support. An emit uses the schema of its results.
/// The sourceFields map relates top-level stored names to stable field identities, independently of
/// output projection. Omission means that the host does not expose these identities.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ScanInfo {
    /// Contract field filterClauses.
    #[serde(rename = "filterClauses")]
    pub filter_clauses: Vec<FilterClause>,
    /// Contract field schema.
    #[serde(rename = "schema")]
    pub schema: ArrowSchema,
    /// Contract field sourceFields.
    #[serde(rename = "sourceFields")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_fields: Option<BTreeMap<String, Uuid>>,
    /// Contract field statistics.
    #[serde(rename = "statistics")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub statistics: Option<ScanStatistics>,
    /// Contract field writeLayout.
    #[serde(rename = "writeLayout")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub write_layout: Option<WriteLayout>,
}
impl<'de> DeserializeStrict<'de> for ScanInfo {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "filterClauses")]
            filter_clauses: Strict<Vec<FilterClause>>,
            #[serde(rename = "schema")]
            schema: Strict<ArrowSchema>,
            #[serde(rename = "sourceFields")]
            #[serde(default)]
            source_fields: Strict<Option<BTreeMap<String, Uuid>>>,
            #[serde(rename = "statistics")]
            #[serde(default)]
            statistics: Strict<Option<ScanStatistics>>,
            #[serde(rename = "writeLayout")]
            #[serde(default)]
            write_layout: Strict<Option<WriteLayout>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            filter_clauses: wire.filter_clauses.0,
            schema: wire.schema.0,
            source_fields: wire.source_fields.0,
            statistics: wire.statistics.0,
            write_layout: wire.write_layout.0,
        })
    }
}

/// Counters for a scan's plan, or for one batch of a split read.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ScanMetricsSnapshot {
    /// Contract field filesConsidered.
    #[serde(rename = "filesConsidered")]
    pub files_considered: SafeUnsignedLong,
    /// Contract field filesPruned.
    #[serde(rename = "filesPruned")]
    pub files_pruned: SafeUnsignedLong,
    /// Contract field fragmentsConsidered.
    #[serde(rename = "fragmentsConsidered")]
    pub fragments_considered: SafeUnsignedLong,
    /// Contract field fragmentsPruned.
    #[serde(rename = "fragmentsPruned")]
    pub fragments_pruned: SafeUnsignedLong,
    /// Contract field outputRows.
    #[serde(rename = "outputRows")]
    pub output_rows: SafeUnsignedLong,
    /// Contract field storage.
    #[serde(rename = "storage")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub storage: Option<StorageCounters>,
    /// Contract field windows.
    #[serde(rename = "windows")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub windows: Option<WindowCounters>,
}
impl<'de> DeserializeStrict<'de> for ScanMetricsSnapshot {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "filesConsidered")]
            files_considered: Strict<SafeUnsignedLong>,
            #[serde(rename = "filesPruned")]
            files_pruned: Strict<SafeUnsignedLong>,
            #[serde(rename = "fragmentsConsidered")]
            fragments_considered: Strict<SafeUnsignedLong>,
            #[serde(rename = "fragmentsPruned")]
            fragments_pruned: Strict<SafeUnsignedLong>,
            #[serde(rename = "outputRows")]
            output_rows: Strict<SafeUnsignedLong>,
            #[serde(rename = "storage")]
            #[serde(default)]
            storage: Strict<Option<StorageCounters>>,
            #[serde(rename = "windows")]
            #[serde(default)]
            windows: Strict<Option<WindowCounters>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            files_considered: wire.files_considered.0,
            files_pruned: wire.files_pruned.0,
            fragments_considered: wire.fragments_considered.0,
            fragments_pruned: wire.fragments_pruned.0,
            output_rows: wire.output_rows.0,
            storage: wire.storage.0,
            windows: wire.windows.0,
        })
    }
}

/// A scan's output and one split for each file that statistics do not prune.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ScanPlan {
    /// Contract field info.
    #[serde(rename = "info")]
    pub info: ScanInfo,
    /// Contract field metrics.
    #[serde(rename = "metrics")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<ScanMetricsSnapshot>,
    /// Contract field splits.
    #[serde(rename = "splits")]
    pub splits: Vec<PlannedSplit>,
}
impl<'de> DeserializeStrict<'de> for ScanPlan {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "info")]
            info: Strict<ScanInfo>,
            #[serde(rename = "metrics")]
            #[serde(default)]
            metrics: Strict<Option<ScanMetricsSnapshot>>,
            #[serde(rename = "splits")]
            splits: Strict<Vec<PlannedSplit>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            info: wire.info.0,
            metrics: wire.metrics.0,
            splits: wire.splits.0,
        })
    }
}

/// Metadata-only statistics for selected rows. Stored bytes describe storage, not Arrow output
/// size.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ScanStatistics {
    /// Contract field columns.
    #[serde(rename = "columns")]
    pub columns: Vec<ColumnStatistics>,
    /// Contract field rowCount.
    #[serde(rename = "rowCount")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub row_count: Option<SafeUnsignedLong>,
    /// Contract field rowCountExact.
    #[serde(rename = "rowCountExact")]
    pub row_count_exact: bool,
    /// Contract field storedBytes.
    #[serde(rename = "storedBytes")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stored_bytes: Option<SafeUnsignedLong>,
}
impl<'de> DeserializeStrict<'de> for ScanStatistics {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "columns")]
            columns: Strict<Vec<ColumnStatistics>>,
            #[serde(rename = "rowCount")]
            #[serde(default)]
            row_count: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "rowCountExact")]
            row_count_exact: Strict<bool>,
            #[serde(rename = "storedBytes")]
            #[serde(default)]
            stored_bytes: Strict<Option<SafeUnsignedLong>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            columns: wire.columns.0,
            row_count: wire.row_count.0,
            row_count_exact: wire.row_count_exact.0,
            stored_bytes: wire.stored_bytes.0,
        })
    }
}

/// One change to a Table's schema. A path names a top-level column, or a nested field by its
/// segments. Changes apply in order and write no data files. An added column or field is nullable;
/// a widened type converts without loss, such as `int32` to `int64`; a partition or sort source
/// field cannot be dropped.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum SchemaChange {
    /// A known union arm.
    AddColumn(AddColumn),
    /// A known union arm.
    DropColumn(ColumnPath),
    /// A known union arm.
    MoveColumn(MoveColumn),
    /// A known union arm.
    RenameColumn(RenameColumn),
    /// A known union arm.
    SetNullable(ColumnPath),
    /// A known union arm.
    WidenType(WidenType),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for SchemaChange {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::AddColumn(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("addColumn".into()));
                object.insert(
                    "addColumn".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::DropColumn(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("dropColumn".into()));
                object.insert(
                    "dropColumn".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::MoveColumn(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("moveColumn".into()));
                object.insert(
                    "moveColumn".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::RenameColumn(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("renameColumn".into()));
                object.insert(
                    "renameColumn".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::SetNullable(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("setNullable".into()));
                object.insert(
                    "setNullable".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::WidenType(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("widenType".into()));
                object.insert(
                    "widenType".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 SchemaChange {
    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 {
            "addColumn" => Ok(Self::AddColumn(
                serde_json::from_value(
                    value
                        .get("addColumn")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "dropColumn" => Ok(Self::DropColumn(
                serde_json::from_value(
                    value
                        .get("dropColumn")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "moveColumn" => Ok(Self::MoveColumn(
                serde_json::from_value(
                    value
                        .get("moveColumn")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "renameColumn" => Ok(Self::RenameColumn(
                serde_json::from_value(
                    value
                        .get("renameColumn")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "setNullable" => Ok(Self::SetNullable(
                serde_json::from_value(
                    value
                        .get("setNullable")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "widenType" => Ok(Self::WidenType(
                serde_json::from_value(
                    value
                        .get("widenType")
                        .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 SchemaChange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "addColumn")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "addColumn")]
            value: Strict<AddColumn>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "dropColumn")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "dropColumn")]
            value: Strict<ColumnPath>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "moveColumn")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "moveColumn")]
            value: Strict<MoveColumn>,
        }
        #[derive(Deserialize)]
        enum __Tag3 {
            #[serde(rename = "renameColumn")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm3 {
            #[serde(rename = "type")]
            _tag: __Tag3,
            #[serde(rename = "renameColumn")]
            value: Strict<RenameColumn>,
        }
        #[derive(Deserialize)]
        enum __Tag4 {
            #[serde(rename = "setNullable")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm4 {
            #[serde(rename = "type")]
            _tag: __Tag4,
            #[serde(rename = "setNullable")]
            value: Strict<ColumnPath>,
        }
        #[derive(Deserialize)]
        enum __Tag5 {
            #[serde(rename = "widenType")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm5 {
            #[serde(rename = "type")]
            _tag: __Tag5,
            #[serde(rename = "widenType")]
            value: Strict<WidenType>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            AddColumn(Box<__Arm0>),
            DropColumn(Box<__Arm1>),
            MoveColumn(Box<__Arm2>),
            RenameColumn(Box<__Arm3>),
            SetNullable(Box<__Arm4>),
            WidenType(Box<__Arm5>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::AddColumn(arm) => Self::AddColumn(arm.value.0),
            __Known::DropColumn(arm) => Self::DropColumn(arm.value.0),
            __Known::MoveColumn(arm) => Self::MoveColumn(arm.value.0),
            __Known::RenameColumn(arm) => Self::RenameColumn(arm.value.0),
            __Known::SetNullable(arm) => Self::SetNullable(arm.value.0),
            __Known::WidenType(arm) => Self::WidenType(arm.value.0),
        })
    }
}

/// Search one exact index and the source version from its origin. The result has at most 1000 rows.
/// Rerank caps candidates at 100000, including excluded rows. The source filter and exclusions
/// apply before the final top-k selection. Columns select final source fields. Omission returns
/// only row IDs, distances, and ranks. Query coordinates and exact source distances use float64.
/// Candidate selection uses float32. Unsupported filters fail before payload reads. Codec v2
/// requires a resource refresh before this operation.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SearchVectorsRequest {
    /// Contract field columns.
    #[serde(rename = "columns")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub columns: Option<Vec<String>>,
    /// Contract field excludeRowIds.
    #[serde(rename = "excludeRowIds")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exclude_row_ids: Option<Vec<SafeUnsignedLong>>,
    /// Contract field filter.
    #[serde(rename = "filter")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub filter: Option<Expression>,
    /// Contract field index.
    #[serde(rename = "index")]
    pub index: VectorIndexArtifact,
    /// Contract field indexStorage.
    #[serde(rename = "indexStorage")]
    pub index_storage: StorageBinding,
    /// Contract field limit.
    #[serde(rename = "limit")]
    pub limit: u32,
    /// Contract field probes.
    #[serde(rename = "probes")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub probes: Option<u32>,
    /// Contract field query.
    #[serde(rename = "query")]
    pub query: Vec<f64>,
    /// Contract field rerank.
    #[serde(rename = "rerank")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rerank: Option<u32>,
    /// Contract field sourceStorage.
    #[serde(rename = "sourceStorage")]
    pub source_storage: StorageBinding,
}
impl<'de> DeserializeStrict<'de> for SearchVectorsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "columns")]
            #[serde(default)]
            columns: Strict<Option<Vec<String>>>,
            #[serde(rename = "excludeRowIds")]
            #[serde(default)]
            exclude_row_ids: Strict<Option<Vec<SafeUnsignedLong>>>,
            #[serde(rename = "filter")]
            #[serde(default)]
            filter: Strict<Option<Expression>>,
            #[serde(rename = "index")]
            index: Strict<VectorIndexArtifact>,
            #[serde(rename = "indexStorage")]
            index_storage: Strict<StorageBinding>,
            #[serde(rename = "limit")]
            limit: Strict<u32>,
            #[serde(rename = "probes")]
            #[serde(default)]
            probes: Strict<Option<u32>>,
            #[serde(rename = "query")]
            query: Strict<Vec<f64>>,
            #[serde(rename = "rerank")]
            #[serde(default)]
            rerank: Strict<Option<u32>>,
            #[serde(rename = "sourceStorage")]
            source_storage: Strict<StorageBinding>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            columns: wire.columns.0,
            exclude_row_ids: wire.exclude_row_ids.0,
            filter: wire.filter.0,
            index: wire.index.0,
            index_storage: wire.index_storage.0,
            limit: wire.limit.0,
            probes: wire.probes.0,
            query: wire.query.0,
            rerank: wire.rerank.0,
            source_storage: wire.source_storage.0,
        })
    }
}

/// One output column's comparison order within a stored fragment.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct SortColumn {
    /// Contract field descending.
    #[serde(rename = "descending")]
    pub descending: bool,
    /// Contract field nullsFirst.
    #[serde(rename = "nullsFirst")]
    pub nulls_first: bool,
    /// Contract field path.
    #[serde(rename = "path")]
    pub path: Vec<String>,
    /// Contract field transform.
    #[serde(rename = "transform")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub transform: Option<String>,
}
impl<'de> DeserializeStrict<'de> for SortColumn {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "descending")]
            descending: Strict<bool>,
            #[serde(rename = "nullsFirst")]
            nulls_first: Strict<bool>,
            #[serde(rename = "path")]
            path: Strict<Vec<String>>,
            #[serde(rename = "transform")]
            #[serde(default)]
            transform: Strict<Option<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            descending: wire.descending.0,
            nulls_first: wire.nulls_first.0,
            path: wire.path.0,
            transform: wire.transform.0,
        })
    }
}

/// An output column that a top-k orders by. Nulls sort last ascending and first descending, unless
/// `nullsFirst` says otherwise.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct SortKey {
    /// Contract field column.
    #[serde(rename = "column")]
    pub column: String,
    /// Contract field descending.
    #[serde(rename = "descending")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub descending: Option<bool>,
    /// Contract field nullsFirst.
    #[serde(rename = "nullsFirst")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub nulls_first: Option<bool>,
}
impl<'de> DeserializeStrict<'de> for SortKey {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "column")]
            column: Strict<String>,
            #[serde(rename = "descending")]
            #[serde(default)]
            descending: Strict<Option<bool>>,
            #[serde(rename = "nullsFirst")]
            #[serde(default)]
            nulls_first: Strict<Option<bool>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            column: wire.column.0,
            descending: wire.descending.0,
            nulls_first: wire.nulls_first.0,
        })
    }
}

/// Stored rows of one file of the scanned version. Stored rows include rows that a later version
/// deleted; a read skips them. Resume a split by raising `rows.start` to the last row a read
/// reported, and share one between readers by dividing `rows`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Split {
    /// Contract field fragment.
    #[serde(rename = "fragment")]
    pub fragment: SafeUnsignedLong,
    /// Contract field rows.
    #[serde(rename = "rows")]
    pub rows: RowRange,
}
impl<'de> DeserializeStrict<'de> for Split {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "fragment")]
            fragment: Strict<SafeUnsignedLong>,
            #[serde(rename = "rows")]
            rows: Strict<RowRange>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            fragment: wire.fragment.0,
            rows: wire.rows.0,
        })
    }
}

/// Rows of one planned split, by position. Position `p` is the `p`-th row of the split, counted
/// from zero in stored order, that the scanned version keeps after deleted rows are removed;
/// `count_rows` over the split gives how many there are. Positions may come in any order and
/// repeat.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct SplitTake {
    /// Contract field positions.
    #[serde(rename = "positions")]
    pub positions: Vec<SafeUnsignedLong>,
    /// Contract field split.
    #[serde(rename = "split")]
    pub split: Split,
}
impl<'de> DeserializeStrict<'de> for SplitTake {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "positions")]
            positions: Strict<Vec<SafeUnsignedLong>>,
            #[serde(rename = "split")]
            split: Strict<Split>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            positions: wire.positions.0,
            split: wire.split.0,
        })
    }
}

/// The Table and write attempt to upload into, with the attempt's binding from the Tables API.
/// `partBytes` is a power of two from 8 MiB to 1 GiB, 64 MiB unless set, and at most a request's
/// memory budget; an upload holds at most 10,000 parts.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct StartBlobUploadRequest {
    /// Contract field attempt.
    #[serde(rename = "attempt")]
    pub attempt: Uuid,
    /// Contract field mediaType.
    #[serde(rename = "mediaType")]
    pub media_type: String,
    /// Contract field partBytes.
    #[serde(rename = "partBytes")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub part_bytes: Option<SafeUnsignedLong>,
    /// Contract field table.
    #[serde(rename = "table")]
    pub table: TableBinding,
}
impl<'de> DeserializeStrict<'de> for StartBlobUploadRequest {
    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<Uuid>,
            #[serde(rename = "mediaType")]
            media_type: Strict<String>,
            #[serde(rename = "partBytes")]
            #[serde(default)]
            part_bytes: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "table")]
            table: Strict<TableBinding>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt: wire.attempt.0,
            media_type: wire.media_type.0,
            part_bytes: wire.part_bytes.0,
            table: wire.table.0,
        })
    }
}

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

/// Access to one Table's storage, built from what the Tables API returns for storage access.
/// `endpoint` is the SPFS endpoint that signs an SPFS root's requests; without one, the host's own
/// SPFS endpoint signs them. The host configures allowed storage providers and endpoints; hosted
/// ScanDAL refuses local file roots and any storage endpoint but its own. A host that resolved a
/// binding requests it again before `expiresAt`, Unix seconds; without one, the binding lasts as
/// long as its credential. A host that reads provider roots reads a read-only binding's
/// `directRead` at the provider instead of through SPFS.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct StorageBinding {
    /// Contract field credential.
    #[serde(rename = "credential")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub credential: Option<StorageCredential>,
    /// Contract field directRead.
    #[serde(rename = "directRead")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub direct_read: Option<DirectRead>,
    /// Contract field endpoint.
    #[serde(rename = "endpoint")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoint: Option<String>,
    /// Contract field expiresAt.
    #[serde(rename = "expiresAt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<SafeUnsignedLong>,
    /// Contract field rootAlias.
    #[serde(rename = "rootAlias")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub root_alias: Option<String>,
    /// Contract field rootUri.
    #[serde(rename = "rootUri")]
    pub root_uri: String,
}
impl<'de> DeserializeStrict<'de> for StorageBinding {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "credential")]
            #[serde(default)]
            credential: Strict<Option<StorageCredential>>,
            #[serde(rename = "directRead")]
            #[serde(default)]
            direct_read: Strict<Option<DirectRead>>,
            #[serde(rename = "endpoint")]
            #[serde(default)]
            endpoint: Strict<Option<String>>,
            #[serde(rename = "expiresAt")]
            #[serde(default)]
            expires_at: Strict<Option<SafeUnsignedLong>>,
            #[serde(rename = "rootAlias")]
            #[serde(default)]
            root_alias: Strict<Option<String>>,
            #[serde(rename = "rootUri")]
            root_uri: Strict<String>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            credential: wire.credential.0,
            direct_read: wire.direct_read.0,
            endpoint: wire.endpoint.0,
            expires_at: wire.expires_at.0,
            root_alias: wire.root_alias.0,
            root_uri: wire.root_uri.0,
        })
    }
}

/// Successful object reads of one scan or split read.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct StorageCounters {
    /// Contract field bytes.
    #[serde(rename = "bytes")]
    pub bytes: SafeUnsignedLong,
    /// Contract field readTimeNs.
    #[serde(rename = "readTimeNs")]
    pub read_time_ns: SafeUnsignedLong,
    /// Contract field requests.
    #[serde(rename = "requests")]
    pub requests: SafeUnsignedLong,
    /// Contract field scope.
    #[serde(rename = "scope")]
    pub scope: StorageScope,
}
impl<'de> DeserializeStrict<'de> for StorageCounters {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "bytes")]
            bytes: Strict<SafeUnsignedLong>,
            #[serde(rename = "readTimeNs")]
            read_time_ns: Strict<SafeUnsignedLong>,
            #[serde(rename = "requests")]
            requests: Strict<SafeUnsignedLong>,
            #[serde(rename = "scope")]
            scope: Strict<StorageScope>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            bytes: wire.bytes.0,
            read_time_ns: wire.read_time_ns.0,
            requests: wire.requests.0,
            scope: wire.scope.0,
        })
    }
}

/// The storage access token for signed access. Generated code keeps it out of debug output.
#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct StorageCredential(pub String);
impl std::fmt::Debug for StorageCredential {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter.write_str("StorageCredential(<redacted>)")
    }
}
impl<'de> DeserializeStrict<'de> for StorageCredential {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
    }
}

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

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

/// A Table identity and optional explicit storage. The host resolves omitted storage as the caller.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TableBinding {
    /// Contract field storage.
    #[serde(rename = "storage")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub storage: Option<StorageBinding>,
    /// Contract field tableId.
    #[serde(rename = "tableId")]
    pub table_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for TableBinding {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "storage")]
            #[serde(default)]
            storage: Strict<Option<StorageBinding>>,
            #[serde(rename = "tableId")]
            table_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            storage: wire.storage.0,
            table_id: wire.table_id.0,
        })
    }
}

/// An exact, immutable version of one Table.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TableVersion {
    /// 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 TableVersion {
    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,
        })
    }
}

/// Takes of a scan's rows, read in order. The scan's columns or projection, `batchRows` and
/// `collectMetrics` apply; a scan with a `filter`, `limit` or `emit` is invalid. A request takes at
/// most 65,536 positions from at most 256 splits.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TakeRowsRequest {
    /// Contract field scan.
    #[serde(rename = "scan")]
    pub scan: Scan,
    /// Contract field storage.
    #[serde(rename = "storage")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub storage: Option<StorageBinding>,
    /// Contract field takes.
    #[serde(rename = "takes")]
    pub takes: Vec<SplitTake>,
}
impl<'de> DeserializeStrict<'de> for TakeRowsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "scan")]
            scan: Strict<Scan>,
            #[serde(rename = "storage")]
            #[serde(default)]
            storage: Strict<Option<StorageBinding>>,
            #[serde(rename = "takes")]
            takes: Strict<Vec<SplitTake>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            scan: wire.scan.0,
            storage: wire.storage.0,
            takes: wire.takes.0,
        })
    }
}

/// The `k` rows that sort first by `keys`, with every output column, ties in stored order. `k` is
/// at most 10,000; order more rows in your own engine. A split selects its winners in one pass over
/// the key columns, then reads the other output columns of those rows only. When the first key is a
/// stored column, the pass skips rows, and whole zones by their statistics, that sort after the
/// worst winner so far. Keys are boolean, numeric, decimal, temporal, string or binary columns.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TopK {
    /// Contract field k.
    #[serde(rename = "k")]
    pub k: u32,
    /// Contract field keys.
    #[serde(rename = "keys")]
    pub keys: Vec<SortKey>,
}
impl<'de> DeserializeStrict<'de> for TopK {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "k")]
            k: Strict<u32>,
            #[serde(rename = "keys")]
            keys: Strict<Vec<SortKey>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            k: wire.k.0,
            keys: wire.keys.0,
        })
    }
}

/// One part of an upload: `part` counts from 1 and covers the payload's bytes from `(part - 1) *
/// partBytes`.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct UploadBlobPartRequest {
    /// Contract field part.
    #[serde(rename = "part")]
    pub part: u32,
    /// Contract field storage.
    #[serde(rename = "storage")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub storage: Option<StorageBinding>,
    /// Contract field upload.
    #[serde(rename = "upload")]
    pub upload: BlobUpload,
}
impl<'de> DeserializeStrict<'de> for UploadBlobPartRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "part")]
            part: Strict<u32>,
            #[serde(rename = "storage")]
            #[serde(default)]
            storage: Strict<Option<StorageBinding>>,
            #[serde(rename = "upload")]
            upload: Strict<BlobUpload>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            part: wire.part.0,
            storage: wire.storage.0,
            upload: wire.upload.0,
        })
    }
}

/// An exact index artifact from the Vector Index service. The manifest must agree with every
/// identity and physical attribute.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct VectorIndexArtifact {
    /// Contract field codec.
    #[serde(rename = "codec")]
    pub codec: String,
    /// Contract field codecVersion.
    #[serde(rename = "codecVersion")]
    pub codec_version: u32,
    /// Contract field dimensions.
    #[serde(rename = "dimensions")]
    pub dimensions: u32,
    /// Contract field indexedRows.
    #[serde(rename = "indexedRows")]
    pub indexed_rows: SafeUnsignedLong,
    /// Contract field manifestPath.
    #[serde(rename = "manifestPath")]
    pub manifest_path: String,
    /// Contract field metadata.
    #[serde(rename = "metadata")]
    pub metadata: String,
    /// Contract field metric.
    #[serde(rename = "metric")]
    pub metric: VectorMetric,
    /// Contract field origin.
    #[serde(rename = "origin")]
    pub origin: VectorIndexOrigin,
    /// Contract field partitions.
    #[serde(rename = "partitions")]
    pub partitions: u32,
}
impl<'de> DeserializeStrict<'de> for VectorIndexArtifact {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "codec")]
            codec: Strict<String>,
            #[serde(rename = "codecVersion")]
            codec_version: Strict<u32>,
            #[serde(rename = "dimensions")]
            dimensions: Strict<u32>,
            #[serde(rename = "indexedRows")]
            indexed_rows: Strict<SafeUnsignedLong>,
            #[serde(rename = "manifestPath")]
            manifest_path: Strict<String>,
            #[serde(rename = "metadata")]
            metadata: Strict<String>,
            #[serde(rename = "metric")]
            metric: Strict<VectorMetric>,
            #[serde(rename = "origin")]
            origin: Strict<VectorIndexOrigin>,
            #[serde(rename = "partitions")]
            partitions: Strict<u32>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            codec: wire.codec.0,
            codec_version: wire.codec_version.0,
            dimensions: wire.dimensions.0,
            indexed_rows: wire.indexed_rows.0,
            manifest_path: wire.manifest_path.0,
            metadata: wire.metadata.0,
            metric: wire.metric.0,
            origin: wire.origin.0,
            partitions: wire.partitions.0,
        })
    }
}

/// Exact identities that an immutable resource artifact records.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct VectorIndexOrigin {
    /// Contract field sourceFieldId.
    #[serde(rename = "sourceFieldId")]
    pub source_field_id: Uuid,
    /// Contract field sourceResourceId.
    #[serde(rename = "sourceResourceId")]
    pub source_resource_id: Uuid,
    /// Contract field sourceVersionId.
    #[serde(rename = "sourceVersionId")]
    pub source_version_id: Uuid,
    /// Contract field vectorIndexId.
    #[serde(rename = "vectorIndexId")]
    pub vector_index_id: Uuid,
    /// Contract field versionId.
    #[serde(rename = "versionId")]
    pub version_id: Uuid,
}
impl<'de> DeserializeStrict<'de> for VectorIndexOrigin {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "sourceFieldId")]
            source_field_id: Strict<Uuid>,
            #[serde(rename = "sourceResourceId")]
            source_resource_id: Strict<Uuid>,
            #[serde(rename = "sourceVersionId")]
            source_version_id: Strict<Uuid>,
            #[serde(rename = "vectorIndexId")]
            vector_index_id: Strict<Uuid>,
            #[serde(rename = "versionId")]
            version_id: Strict<Uuid>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            source_field_id: wire.source_field_id.0,
            source_resource_id: wire.source_resource_id.0,
            source_version_id: wire.source_version_id.0,
            vector_index_id: wire.vector_index_id.0,
            version_id: wire.version_id.0,
        })
    }
}

/// Distances use float64 source values. Smaller distances rank first. Dot distance is the negative
/// inner product.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum VectorMetric {
    /// A known contract value.
    Cosine,
    /// A known contract value.
    Euclidean,
    /// A known contract value.
    Dot,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for VectorMetric {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Cosine => "cosine",
            Self::Euclidean => "euclidean",
            Self::Dot => "dot",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for VectorMetric {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "cosine" => Self::Cosine,
            "euclidean" => Self::Euclidean,
            "dot" => Self::Dot,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for VectorMetric {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "cosine")]
            Cosine,
            #[serde(rename = "euclidean")]
            Euclidean,
            #[serde(rename = "dot")]
            Dot,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Cosine => Self::Cosine,
            __Known::Euclidean => Self::Euclidean,
            __Known::Dot => Self::Dot,
        })
    }
}

/// The Arrow schema stores this value as JSON under `scandal.vector_search`. Exhaustive means that
/// all indexed rows fit within the selected partition and candidate limits. A smaller result
/// exhausts this fixed budget. It does not prove exhaustion of the complete filtered population
/// unless exhaustive is true. Every result has `scandal.row_id`, `scandal.distance`, and one-based
/// `scandal.rank` columns. Requested source fields follow these columns. Their names must not
/// collide with these reserved names.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct VectorSearchInfo {
    /// Contract field exhaustive.
    #[serde(rename = "exhaustive")]
    pub exhaustive: bool,
    /// Contract field indexedRows.
    #[serde(rename = "indexedRows")]
    pub indexed_rows: SafeUnsignedLong,
    /// Contract field limit.
    #[serde(rename = "limit")]
    pub limit: u32,
    /// Contract field metric.
    #[serde(rename = "metric")]
    pub metric: VectorMetric,
    /// Contract field origin.
    #[serde(rename = "origin")]
    pub origin: VectorIndexOrigin,
    /// Contract field probes.
    #[serde(rename = "probes")]
    pub probes: u32,
    /// Contract field rerank.
    #[serde(rename = "rerank")]
    pub rerank: u32,
}
impl<'de> DeserializeStrict<'de> for VectorSearchInfo {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "exhaustive")]
            exhaustive: Strict<bool>,
            #[serde(rename = "indexedRows")]
            indexed_rows: Strict<SafeUnsignedLong>,
            #[serde(rename = "limit")]
            limit: Strict<u32>,
            #[serde(rename = "metric")]
            metric: Strict<VectorMetric>,
            #[serde(rename = "origin")]
            origin: Strict<VectorIndexOrigin>,
            #[serde(rename = "probes")]
            probes: Strict<u32>,
            #[serde(rename = "rerank")]
            rerank: Strict<u32>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            exhaustive: wire.exhaustive.0,
            indexed_rows: wire.indexed_rows.0,
            limit: wire.limit.0,
            metric: wire.metric.0,
            origin: wire.origin.0,
            probes: wire.probes.0,
            rerank: wire.rerank.0,
        })
    }
}

/// Change the type of the column or field at `path` to `dataType`, converting without loss.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WidenType {
    /// Contract field dataType.
    #[serde(rename = "dataType")]
    pub data_type: ArrowDataType,
    /// Contract field path.
    #[serde(rename = "path")]
    pub path: Vec<String>,
}
impl<'de> DeserializeStrict<'de> for WidenType {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "dataType")]
            data_type: Strict<ArrowDataType>,
            #[serde(rename = "path")]
            path: Strict<Vec<String>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            data_type: wire.data_type.0,
            path: wire.path.0,
        })
    }
}

/// Row windows that a scan visited or ruled out by statistics.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WindowCounters {
    /// Contract field prunedStatistics.
    #[serde(rename = "prunedStatistics")]
    pub pruned_statistics: SafeUnsignedLong,
    /// Contract field visited.
    #[serde(rename = "visited")]
    pub visited: SafeUnsignedLong,
}
impl<'de> DeserializeStrict<'de> for WindowCounters {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "prunedStatistics")]
            pruned_statistics: Strict<SafeUnsignedLong>,
            #[serde(rename = "visited")]
            visited: Strict<SafeUnsignedLong>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            pruned_statistics: wire.pruned_statistics.0,
            visited: wire.visited.0,
        })
    }
}

/// The mirror of file `fragmentId` of `source`, a version of another Table: a file of `table` with
/// the source file's ID, row count and row IDs, so a scan of `source` can read it at its own
/// positions. The Arrow rows have the Table's schema and are the rows `source` keeps in that file,
/// in stored order: the service checks their count, places them at the kept positions, and writes
/// nulls at the positions `source` deletes. `base` is the version the mirror is for, absent for the
/// Table's first. Files go under `attempt`'s directory.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WriteAlignedRequest {
    /// Contract field attempt.
    #[serde(rename = "attempt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attempt: Option<Uuid>,
    /// Contract field base.
    #[serde(rename = "base")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub base: Option<Uuid>,
    /// Contract field fragmentId.
    #[serde(rename = "fragmentId")]
    pub fragment_id: Uuid,
    /// Contract field source.
    #[serde(rename = "source")]
    pub source: TableVersion,
    /// Contract field sourceStorage.
    #[serde(rename = "sourceStorage")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_storage: Option<StorageBinding>,
    /// Contract field table.
    #[serde(rename = "table")]
    pub table: TableBinding,
}
impl<'de> DeserializeStrict<'de> for WriteAlignedRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "attempt")]
            #[serde(default)]
            attempt: Strict<Option<Uuid>>,
            #[serde(rename = "base")]
            #[serde(default)]
            base: Strict<Option<Uuid>>,
            #[serde(rename = "fragmentId")]
            fragment_id: Strict<Uuid>,
            #[serde(rename = "source")]
            source: Strict<TableVersion>,
            #[serde(rename = "sourceStorage")]
            #[serde(default)]
            source_storage: Strict<Option<StorageBinding>>,
            #[serde(rename = "table")]
            table: Strict<TableBinding>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            attempt: wire.attempt.0,
            base: wire.base.0,
            fragment_id: wire.fragment_id.0,
            source: wire.source.0,
            source_storage: wire.source_storage.0,
            table: wire.table.0,
        })
    }
}

/// What a prepared version builds on: the Table's first version, an append that keeps the base
/// version's rows, an overwrite that replaces them, a delete of selected rows, an edit that takes
/// appended rows, patches, deleted rows, column files and a schema change, or a version whose files
/// mirror the files of a version of another Table.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum WriteBase {
    /// A known union arm.
    Aligned(AlignedBase),
    /// A known union arm.
    Append(SuccessorBase),
    /// A known union arm.
    Delete(Box<DeleteBase>),
    /// A known union arm.
    Edit(EditBase),
    /// A known union arm.
    Genesis(GenesisBase),
    /// A known union arm.
    Overwrite(SuccessorBase),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for WriteBase {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Aligned(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("aligned".into()));
                object.insert(
                    "aligned".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Append(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("append".into()));
                object.insert(
                    "append".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Delete(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("delete".into()));
                object.insert(
                    "delete".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Edit(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("edit".into()));
                object.insert(
                    "edit".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Genesis(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("genesis".into()));
                object.insert(
                    "genesis".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Overwrite(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("overwrite".into()));
                object.insert(
                    "overwrite".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 WriteBase {
    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 {
            "aligned" => Ok(Self::Aligned(
                serde_json::from_value(
                    value
                        .get("aligned")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "append" => Ok(Self::Append(
                serde_json::from_value(
                    value
                        .get("append")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "delete" => Ok(Self::Delete(
                serde_json::from_value(
                    value
                        .get("delete")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "edit" => Ok(Self::Edit(
                serde_json::from_value(
                    value
                        .get("edit")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "genesis" => Ok(Self::Genesis(
                serde_json::from_value(
                    value
                        .get("genesis")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "overwrite" => Ok(Self::Overwrite(
                serde_json::from_value(
                    value
                        .get("overwrite")
                        .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 WriteBase {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "aligned")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "aligned")]
            value: Strict<AlignedBase>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "append")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "append")]
            value: Strict<SuccessorBase>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "delete")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "delete")]
            value: Strict<DeleteBase>,
        }
        #[derive(Deserialize)]
        enum __Tag3 {
            #[serde(rename = "edit")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm3 {
            #[serde(rename = "type")]
            _tag: __Tag3,
            #[serde(rename = "edit")]
            value: Strict<EditBase>,
        }
        #[derive(Deserialize)]
        enum __Tag4 {
            #[serde(rename = "genesis")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm4 {
            #[serde(rename = "type")]
            _tag: __Tag4,
            #[serde(rename = "genesis")]
            value: Strict<GenesisBase>,
        }
        #[derive(Deserialize)]
        enum __Tag5 {
            #[serde(rename = "overwrite")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm5 {
            #[serde(rename = "type")]
            _tag: __Tag5,
            #[serde(rename = "overwrite")]
            value: Strict<SuccessorBase>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Aligned(Box<__Arm0>),
            Append(Box<__Arm1>),
            Delete(Box<__Arm2>),
            Edit(Box<__Arm3>),
            Genesis(Box<__Arm4>),
            Overwrite(Box<__Arm5>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Aligned(arm) => Self::Aligned(arm.value.0),
            __Known::Append(arm) => Self::Append(arm.value.0),
            __Known::Delete(arm) => Self::Delete(Box::new(arm.value.0)),
            __Known::Edit(arm) => Self::Edit(arm.value.0),
            __Known::Genesis(arm) => Self::Genesis(arm.value.0),
            __Known::Overwrite(arm) => Self::Overwrite(arm.value.0),
        })
    }
}

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

/// Preferred storage partitioning and clustering for new fragments of an exact table.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WriteLayout {
    /// Contract field ordering.
    #[serde(rename = "ordering")]
    pub ordering: Vec<SortColumn>,
    /// Contract field partitioning.
    #[serde(rename = "partitioning")]
    pub partitioning: Vec<PartitionColumn>,
}
impl<'de> DeserializeStrict<'de> for WriteLayout {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "ordering")]
            ordering: Strict<Vec<SortColumn>>,
            #[serde(rename = "partitioning")]
            partitioning: Strict<Vec<PartitionColumn>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            ordering: wire.ordering.0,
            partitioning: wire.partitioning.0,
        })
    }
}

/// Guaranteed ordering of one input stream. Each stream is an independent ordered run; this does
/// not assert ordering between streams or fragments. Writers validate the order before certifying
/// fragments. An empty order makes no ordering claim.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct WriteProperties {
    /// Contract field ordering.
    #[serde(rename = "ordering")]
    pub ordering: Vec<SortColumn>,
}
impl<'de> DeserializeStrict<'de> for WriteProperties {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "ordering")]
            ordering: Strict<Vec<SortColumn>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            ordering: wire.ordering.0,
        })
    }
}

/// Typed errors declared by this service contract.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ScandalError {
    /// Scandal:BudgetExceeded.
    BudgetExceeded { message: String },
    /// Scandal:Conflict.
    Conflict { message: String },
    /// Scandal:Internal.
    Internal { message: String },
    /// Scandal:InvalidArgument.
    InvalidArgument { message: String },
    /// Scandal:NotFound.
    NotFound { resource: String },
    /// Scandal:PermissionDenied.
    PermissionDenied { operation: String, resource: String },
    /// Scandal:StorageUnavailable.
    StorageUnavailable { message: String },
    /// Scandal:Unauthenticated.
    Unauthenticated { message: String },
    /// Scandal:Unavailable.
    Unavailable { message: String },
}
impl ScandalError {
    /// HTTP status for this declared error.
    pub fn status(&self) -> u16 {
        match self {
            Self::BudgetExceeded { .. } => 400,
            Self::Conflict { .. } => 409,
            Self::Internal { .. } => 500,
            Self::InvalidArgument { .. } => 400,
            Self::NotFound { .. } => 404,
            Self::PermissionDenied { .. } => 403,
            Self::StorageUnavailable { .. } => 500,
            Self::Unauthenticated { .. } => 401,
            Self::Unavailable { .. } => 503,
        }
    }
    /// Serialize only contract-declared error parameters.
    pub fn envelope(&self, instance: String) -> ErrorEnvelope {
        match self {
            Self::BudgetExceeded { message } => {
                let mut envelope =
                    ErrorEnvelope::new("INVALID_ARGUMENT", "Scandal:BudgetExceeded", instance);
                envelope
                    .parameters
                    .insert("message".into(), message.to_string());
                envelope
            }
            Self::Conflict { message } => {
                let mut envelope = ErrorEnvelope::new("CONFLICT", "Scandal:Conflict", instance);
                envelope
                    .parameters
                    .insert("message".into(), message.to_string());
                envelope
            }
            Self::Internal { message } => {
                let mut envelope = ErrorEnvelope::new("INTERNAL", "Scandal:Internal", instance);
                envelope
                    .parameters
                    .insert("message".into(), message.to_string());
                envelope
            }
            Self::InvalidArgument { message } => {
                let mut envelope =
                    ErrorEnvelope::new("INVALID_ARGUMENT", "Scandal:InvalidArgument", instance);
                envelope
                    .parameters
                    .insert("message".into(), message.to_string());
                envelope
            }
            Self::NotFound { resource } => {
                let mut envelope = ErrorEnvelope::new("NOT_FOUND", "Scandal:NotFound", instance);
                envelope
                    .parameters
                    .insert("resource".into(), resource.to_string());
                envelope
            }
            Self::PermissionDenied {
                operation,
                resource,
            } => {
                let mut envelope =
                    ErrorEnvelope::new("PERMISSION_DENIED", "Scandal:PermissionDenied", instance);
                envelope
                    .parameters
                    .insert("operation".into(), operation.to_string());
                envelope
                    .parameters
                    .insert("resource".into(), resource.to_string());
                envelope
            }
            Self::StorageUnavailable { message } => {
                let mut envelope =
                    ErrorEnvelope::new("INTERNAL", "Scandal:StorageUnavailable", instance);
                envelope
                    .parameters
                    .insert("message".into(), message.to_string());
                envelope
            }
            Self::Unauthenticated { message } => {
                let mut envelope =
                    ErrorEnvelope::new("UNAUTHENTICATED", "Scandal:Unauthenticated", instance);
                envelope
                    .parameters
                    .insert("message".into(), message.to_string());
                envelope
            }
            Self::Unavailable { message } => {
                let mut envelope =
                    ErrorEnvelope::new("UNAVAILABLE", "Scandal:Unavailable", instance);
                envelope
                    .parameters
                    .insert("message".into(), message.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() {
            "Scandal:BudgetExceeded" => {
                if envelope.error_code != "INVALID_ARGUMENT" {
                    return None;
                }
                let message = envelope.parameters.get("message")?.clone();
                Some(Self::BudgetExceeded { message })
            }
            "Scandal:Conflict" => {
                if envelope.error_code != "CONFLICT" {
                    return None;
                }
                let message = envelope.parameters.get("message")?.clone();
                Some(Self::Conflict { message })
            }
            "Scandal:Internal" => {
                if envelope.error_code != "INTERNAL" {
                    return None;
                }
                let message = envelope.parameters.get("message")?.clone();
                Some(Self::Internal { message })
            }
            "Scandal:InvalidArgument" => {
                if envelope.error_code != "INVALID_ARGUMENT" {
                    return None;
                }
                let message = envelope.parameters.get("message")?.clone();
                Some(Self::InvalidArgument { message })
            }
            "Scandal:NotFound" => {
                if envelope.error_code != "NOT_FOUND" {
                    return None;
                }
                let resource = envelope.parameters.get("resource")?.clone();
                Some(Self::NotFound { resource })
            }
            "Scandal:PermissionDenied" => {
                if envelope.error_code != "PERMISSION_DENIED" {
                    return None;
                }
                let operation = envelope.parameters.get("operation")?.clone();
                let resource = envelope.parameters.get("resource")?.clone();
                Some(Self::PermissionDenied {
                    operation,
                    resource,
                })
            }
            "Scandal:StorageUnavailable" => {
                if envelope.error_code != "INTERNAL" {
                    return None;
                }
                let message = envelope.parameters.get("message")?.clone();
                Some(Self::StorageUnavailable { message })
            }
            "Scandal:Unauthenticated" => {
                if envelope.error_code != "UNAUTHENTICATED" {
                    return None;
                }
                let message = envelope.parameters.get("message")?.clone();
                Some(Self::Unauthenticated { message })
            }
            "Scandal:Unavailable" => {
                if envelope.error_code != "UNAVAILABLE" {
                    return None;
                }
                let message = envelope.parameters.get("message")?.clone();
                Some(Self::Unavailable { message })
            }
            _ => None,
        }
    }
}
impl Display for ScandalError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::BudgetExceeded { message } => {
                write!(formatter, "Scandal:BudgetExceeded (message: {})", message)
            }
            Self::Conflict { message } => {
                write!(formatter, "Scandal:Conflict (message: {})", message)
            }
            Self::Internal { message } => {
                write!(formatter, "Scandal:Internal (message: {})", message)
            }
            Self::InvalidArgument { message } => {
                write!(formatter, "Scandal:InvalidArgument (message: {})", message)
            }
            Self::NotFound { resource } => {
                write!(formatter, "Scandal:NotFound (resource: {})", resource)
            }
            Self::PermissionDenied {
                operation,
                resource,
            } => write!(
                formatter,
                "Scandal:PermissionDenied (operation: {}, resource: {})",
                operation, resource
            ),
            Self::StorageUnavailable { message } => write!(
                formatter,
                "Scandal:StorageUnavailable (message: {})",
                message
            ),
            Self::Unauthenticated { message } => {
                write!(formatter, "Scandal:Unauthenticated (message: {})", message)
            }
            Self::Unavailable { message } => {
                write!(formatter, "Scandal:Unavailable (message: {})", message)
            }
        }
    }
}
impl StdError for ScandalError {}
impl ServiceError for ScandalError {
    fn to_envelope(&self, instance: String) -> ErrorEnvelope {
        Self::envelope(self, instance)
    }
    fn from_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
        Self::decode_envelope(envelope)
    }
}