spiral-sdk 0.1.12

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

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

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

/// Authenticated actor recorded by the service; callers cannot choose an actor. At most 128 UTF-8
/// bytes.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ActorId(pub String);
impl std::fmt::Display for ActorId {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for ActorId {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
    }
}

/// Compare the live version with expected and replace it. Equal versions are invalid; use an
/// assertion instead.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AdvanceResourceChange {
    /// Contract field expected.
    #[serde(rename = "expected")]
    pub expected: VersionId,
    /// Contract field replacement.
    #[serde(rename = "replacement")]
    pub replacement: VersionId,
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    pub resource_id: ResourceId,
}
impl<'de> DeserializeStrict<'de> for AdvanceResourceChange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "expected")]
            expected: Strict<VersionId>,
            #[serde(rename = "replacement")]
            replacement: Strict<VersionId>,
            #[serde(rename = "resourceId")]
            resource_id: Strict<ResourceId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            expected: wire.expected.0,
            replacement: wire.replacement.0,
            resource_id: wire.resource_id.0,
        })
    }
}

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

/// Assert a binding or its absence without changing it.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AssertNamespaceChange {
    /// Contract field expected.
    #[serde(rename = "expected")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expected: Option<ResourceId>,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: NamespaceSegment,
    /// Contract field parent.
    #[serde(rename = "parent")]
    pub parent: NamespaceParent,
}
impl<'de> DeserializeStrict<'de> for AssertNamespaceChange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "expected")]
            #[serde(default)]
            expected: Strict<Option<ResourceId>>,
            #[serde(rename = "name")]
            name: Strict<NamespaceSegment>,
            #[serde(rename = "parent")]
            parent: Strict<NamespaceParent>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            expected: wire.expected.0,
            name: wire.name.0,
            parent: wire.parent.0,
        })
    }
}

/// Assert a live version or resource absence when expected is absent. Does not change the resource
/// map; included in atomic conflict checking. A descriptor remains immutable even when a resource
/// is retired.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct AssertResourceChange {
    /// Contract field expected.
    #[serde(rename = "expected")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expected: Option<VersionId>,
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    pub resource_id: ResourceId,
}
impl<'de> DeserializeStrict<'de> for AssertResourceChange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "expected")]
            #[serde(default)]
            expected: Strict<Option<VersionId>>,
            #[serde(rename = "resourceId")]
            resource_id: Strict<ResourceId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            expected: wire.expected.0,
            resource_id: wire.resource_id.0,
        })
    }
}

/// Compare an existing binding or absence and install replacement. Equal expected and replacement
/// are invalid; use an assertion.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BindNamespaceChange {
    /// Contract field expected.
    #[serde(rename = "expected")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expected: Option<ResourceId>,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: NamespaceSegment,
    /// Contract field parent.
    #[serde(rename = "parent")]
    pub parent: NamespaceParent,
    /// Contract field replacement.
    #[serde(rename = "replacement")]
    pub replacement: ResourceId,
}
impl<'de> DeserializeStrict<'de> for BindNamespaceChange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "expected")]
            #[serde(default)]
            expected: Strict<Option<ResourceId>>,
            #[serde(rename = "name")]
            name: Strict<NamespaceSegment>,
            #[serde(rename = "parent")]
            parent: Strict<NamespaceParent>,
            #[serde(rename = "replacement")]
            replacement: Strict<ResourceId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            expected: wire.expected.0,
            name: wire.name.0,
            parent: wire.parent.0,
            replacement: wire.replacement.0,
        })
    }
}

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

/// Branch contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Branch {
    /// Contract field branchId.
    #[serde(rename = "branchId")]
    pub branch_id: BranchId,
    /// Contract field createdAtMicros.
    #[serde(rename = "createdAtMicros")]
    pub created_at_micros: SafeLong,
    /// Contract field deletedAtMicros.
    #[serde(rename = "deletedAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted_at_micros: Option<SafeLong>,
    /// Contract field headCommitId.
    #[serde(rename = "headCommitId")]
    pub head_commit_id: CommitId,
    /// Contract field lastBranchEventId.
    #[serde(rename = "lastBranchEventId")]
    pub last_branch_event_id: BranchEventId,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: BranchName,
}
impl<'de> DeserializeStrict<'de> for Branch {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "branchId")]
            branch_id: Strict<BranchId>,
            #[serde(rename = "createdAtMicros")]
            created_at_micros: Strict<SafeLong>,
            #[serde(rename = "deletedAtMicros")]
            #[serde(default)]
            deleted_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "headCommitId")]
            head_commit_id: Strict<CommitId>,
            #[serde(rename = "lastBranchEventId")]
            last_branch_event_id: Strict<BranchEventId>,
            #[serde(rename = "name")]
            name: Strict<BranchName>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            branch_id: wire.branch_id.0,
            created_at_micros: wire.created_at_micros.0,
            deleted_at_micros: wire.deleted_at_micros.0,
            head_commit_id: wire.head_commit_id.0,
            last_branch_event_id: wire.last_branch_event_id.0,
            name: wire.name.0,
        })
    }
}

/// Immutable branch event. Optional fields describe the operation; previousBranchEventId links
/// events for the same stable branch identity.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BranchEvent {
    /// Contract field actor.
    #[serde(rename = "actor")]
    pub actor: ActorId,
    /// Contract field branchEventId.
    #[serde(rename = "branchEventId")]
    pub branch_event_id: BranchEventId,
    /// Contract field branchId.
    #[serde(rename = "branchId")]
    pub branch_id: BranchId,
    /// Contract field message.
    #[serde(rename = "message")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    /// Contract field newCommitId.
    #[serde(rename = "newCommitId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub new_commit_id: Option<CommitId>,
    /// Contract field newName.
    #[serde(rename = "newName")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub new_name: Option<BranchName>,
    /// Contract field occurredAtMicros.
    #[serde(rename = "occurredAtMicros")]
    pub occurred_at_micros: SafeLong,
    /// Contract field oldCommitId.
    #[serde(rename = "oldCommitId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub old_commit_id: Option<CommitId>,
    /// Contract field oldName.
    #[serde(rename = "oldName")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub old_name: Option<BranchName>,
    /// Contract field operation.
    #[serde(rename = "operation")]
    pub operation: BranchEventOperation,
    /// Contract field previousBranchEventId.
    #[serde(rename = "previousBranchEventId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub previous_branch_event_id: Option<BranchEventId>,
    /// Contract field transactionId.
    #[serde(rename = "transactionId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub transaction_id: Option<TransactionId>,
}
impl<'de> DeserializeStrict<'de> for BranchEvent {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "actor")]
            actor: Strict<ActorId>,
            #[serde(rename = "branchEventId")]
            branch_event_id: Strict<BranchEventId>,
            #[serde(rename = "branchId")]
            branch_id: Strict<BranchId>,
            #[serde(rename = "message")]
            #[serde(default)]
            message: Strict<Option<String>>,
            #[serde(rename = "newCommitId")]
            #[serde(default)]
            new_commit_id: Strict<Option<CommitId>>,
            #[serde(rename = "newName")]
            #[serde(default)]
            new_name: Strict<Option<BranchName>>,
            #[serde(rename = "occurredAtMicros")]
            occurred_at_micros: Strict<SafeLong>,
            #[serde(rename = "oldCommitId")]
            #[serde(default)]
            old_commit_id: Strict<Option<CommitId>>,
            #[serde(rename = "oldName")]
            #[serde(default)]
            old_name: Strict<Option<BranchName>>,
            #[serde(rename = "operation")]
            operation: Strict<BranchEventOperation>,
            #[serde(rename = "previousBranchEventId")]
            #[serde(default)]
            previous_branch_event_id: Strict<Option<BranchEventId>>,
            #[serde(rename = "transactionId")]
            #[serde(default)]
            transaction_id: Strict<Option<TransactionId>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            actor: wire.actor.0,
            branch_event_id: wire.branch_event_id.0,
            branch_id: wire.branch_id.0,
            message: wire.message.0,
            new_commit_id: wire.new_commit_id.0,
            new_name: wire.new_name.0,
            occurred_at_micros: wire.occurred_at_micros.0,
            old_commit_id: wire.old_commit_id.0,
            old_name: wire.old_name.0,
            operation: wire.operation.0,
            previous_branch_event_id: wire.previous_branch_event_id.0,
            transaction_id: wire.transaction_id.0,
        })
    }
}

/// Immutable UUIDv7 branch event identity.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct BranchEventId(pub Uuid);
impl std::fmt::Display for BranchEventId {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for BranchEventId {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<Uuid>::deserialize(deserializer)?.0))
    }
}

/// Branch identity lifecycle and head movement. Client responses retain unknown future operation
/// values.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum BranchEventOperation {
    /// A known contract value.
    Create,
    /// A known contract value.
    Advance,
    /// A known contract value.
    Merge,
    /// A known contract value.
    Rename,
    /// A known contract value.
    Delete,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for BranchEventOperation {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::Create => "create",
            Self::Advance => "advance",
            Self::Merge => "merge",
            Self::Rename => "rename",
            Self::Delete => "delete",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for BranchEventOperation {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "create" => Self::Create,
            "advance" => Self::Advance,
            "merge" => Self::Merge,
            "rename" => Self::Rename,
            "delete" => Self::Delete,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for BranchEventOperation {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "create")]
            Create,
            #[serde(rename = "advance")]
            Advance,
            #[serde(rename = "merge")]
            Merge,
            #[serde(rename = "rename")]
            Rename,
            #[serde(rename = "delete")]
            Delete,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Create => Self::Create,
            __Known::Advance => Self::Advance,
            __Known::Merge => Self::Merge,
            __Known::Rename => Self::Rename,
            __Known::Delete => Self::Delete,
        })
    }
}

/// Events follow the stable branch event chain newest first. Branch metadata is captured with the
/// first-page frontier and retained for that traversal; deleted branches remain inspectable.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct BranchEventPage {
    /// Contract field branchId.
    #[serde(rename = "branchId")]
    pub branch_id: BranchId,
    /// Contract field currentName.
    #[serde(rename = "currentName")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub current_name: Option<BranchName>,
    /// Contract field deletedAtMicros.
    #[serde(rename = "deletedAtMicros")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted_at_micros: Option<SafeLong>,
    /// Contract field events.
    #[serde(rename = "events")]
    pub events: Vec<BranchEvent>,
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<PageToken>,
}
impl<'de> DeserializeStrict<'de> for BranchEventPage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "branchId")]
            branch_id: Strict<BranchId>,
            #[serde(rename = "currentName")]
            #[serde(default)]
            current_name: Strict<Option<BranchName>>,
            #[serde(rename = "deletedAtMicros")]
            #[serde(default)]
            deleted_at_micros: Strict<Option<SafeLong>>,
            #[serde(rename = "events")]
            events: Strict<Vec<BranchEvent>>,
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<PageToken>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            branch_id: wire.branch_id.0,
            current_name: wire.current_name.0,
            deleted_at_micros: wire.deleted_at_micros.0,
            events: wire.events.0,
            next_page_token: wire.next_page_token.0,
        })
    }
}

/// Stable UUIDv7 branch identity. Rename preserves identity; deletion tombstones it.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct BranchId(pub Uuid);
impl std::fmt::Display for BranchId {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for BranchId {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<Uuid>::deserialize(deserializer)?.0))
    }
}

/// Slash-separated branch name, at most 255 UTF-8 bytes. Empty, dot, trailing-dot, .lock, and
/// control segments are rejected by the service.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct BranchName(pub String);
impl std::fmt::Display for BranchName {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for BranchName {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
    }
}

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

/// Immutable commit and its canonical submitted changes. Parents are ordered first-parent first:
/// genesis has none, ordinary commits have one, and merges have two. Assertions may be retained as
/// read dependencies; they do not contribute mutation counts. Timestamps serialize as signed
/// decimal strings.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Commit {
    /// Contract field actor.
    #[serde(rename = "actor")]
    pub actor: ActorId,
    /// Contract field commitId.
    #[serde(rename = "commitId")]
    pub commit_id: CommitId,
    /// Contract field committedAtMicros.
    #[serde(rename = "committedAtMicros")]
    pub committed_at_micros: SafeLong,
    /// Contract field message.
    #[serde(rename = "message")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    /// Contract field namespace.
    #[serde(rename = "namespace")]
    pub namespace: Vec<NamespaceChange>,
    /// Contract field parentCommitIds.
    #[serde(rename = "parentCommitIds")]
    pub parent_commit_ids: Vec<CommitId>,
    /// Contract field resources.
    #[serde(rename = "resources")]
    pub resources: Vec<ResourceChange>,
    /// Contract field transactionId.
    #[serde(rename = "transactionId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub transaction_id: Option<TransactionId>,
}
impl<'de> DeserializeStrict<'de> for Commit {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "actor")]
            actor: Strict<ActorId>,
            #[serde(rename = "commitId")]
            commit_id: Strict<CommitId>,
            #[serde(rename = "committedAtMicros")]
            committed_at_micros: Strict<SafeLong>,
            #[serde(rename = "message")]
            #[serde(default)]
            message: Strict<Option<String>>,
            #[serde(rename = "namespace")]
            namespace: Strict<Vec<NamespaceChange>>,
            #[serde(rename = "parentCommitIds")]
            parent_commit_ids: Strict<Vec<CommitId>>,
            #[serde(rename = "resources")]
            resources: Strict<Vec<ResourceChange>>,
            #[serde(rename = "transactionId")]
            #[serde(default)]
            transaction_id: Strict<Option<TransactionId>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            actor: wire.actor.0,
            commit_id: wire.commit_id.0,
            committed_at_micros: wire.committed_at_micros.0,
            message: wire.message.0,
            namespace: wire.namespace.0,
            parent_commit_ids: wire.parent_commit_ids.0,
            resources: wire.resources.0,
            transaction_id: wire.transaction_id.0,
        })
    }
}

/// Immutable UUIDv7 project commit identity.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct CommitId(pub Uuid);
impl std::fmt::Display for CommitId {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for CommitId {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<Uuid>::deserialize(deserializer)?.0))
    }
}

/// continuationCommitIds is the remaining graph frontier, not an opaque pagination token.
/// Continuing from it can revisit ancestors already returned; callers maintain visited identities
/// and reuse the exact resolved exclusion commits returned in resolvedExcludeAncestorsOf. No
/// generated pages/items helper is exposed for this graph traversal. Reference inventories are read
/// separately through paginated branch/tag methods. At most 1000 continuation identities are
/// returned; a larger frontier is a named limit error.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CommitLog {
    /// Contract field commits.
    #[serde(rename = "commits")]
    pub commits: Vec<CommitNode>,
    /// Contract field continuationCommitIds.
    #[serde(rename = "continuationCommitIds")]
    pub continuation_commit_ids: Vec<CommitId>,
    /// Contract field resolvedExcludeAncestorsOf.
    #[serde(rename = "resolvedExcludeAncestorsOf")]
    pub resolved_exclude_ancestors_of: Vec<ResolvedCommitSelector>,
    /// Contract field resolvedStarts.
    #[serde(rename = "resolvedStarts")]
    pub resolved_starts: Vec<ResolvedCommitSelector>,
    /// Contract field truncated.
    #[serde(rename = "truncated")]
    pub truncated: bool,
}
impl<'de> DeserializeStrict<'de> for CommitLog {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "commits")]
            commits: Strict<Vec<CommitNode>>,
            #[serde(rename = "continuationCommitIds")]
            continuation_commit_ids: Strict<Vec<CommitId>>,
            #[serde(rename = "resolvedExcludeAncestorsOf")]
            resolved_exclude_ancestors_of: Strict<Vec<ResolvedCommitSelector>>,
            #[serde(rename = "resolvedStarts")]
            resolved_starts: Strict<Vec<ResolvedCommitSelector>>,
            #[serde(rename = "truncated")]
            truncated: Strict<bool>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            commits: wire.commits.0,
            continuation_commit_ids: wire.continuation_commit_ids.0,
            resolved_exclude_ancestors_of: wire.resolved_exclude_ancestors_of.0,
            resolved_starts: wire.resolved_starts.0,
            truncated: wire.truncated.0,
        })
    }
}

/// Service validates 1 through 1000. Omission or null defaults to 100.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct CommitLogLimit(pub u32);
impl std::fmt::Display for CommitLogLimit {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for CommitLogLimit {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<u32>::deserialize(deserializer)?.0))
    }
}

/// Commit graph summary. Change counts count mutations, excluding read assertions.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CommitNode {
    /// Contract field actor.
    #[serde(rename = "actor")]
    pub actor: ActorId,
    /// Contract field commitId.
    #[serde(rename = "commitId")]
    pub commit_id: CommitId,
    /// Contract field committedAtMicros.
    #[serde(rename = "committedAtMicros")]
    pub committed_at_micros: SafeLong,
    /// Contract field message.
    #[serde(rename = "message")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    /// Contract field namespaceChangeCount.
    #[serde(rename = "namespaceChangeCount")]
    pub namespace_change_count: u32,
    /// Contract field parentCommitIds.
    #[serde(rename = "parentCommitIds")]
    pub parent_commit_ids: Vec<CommitId>,
    /// Contract field resourceChangeCount.
    #[serde(rename = "resourceChangeCount")]
    pub resource_change_count: u32,
    /// Contract field transactionId.
    #[serde(rename = "transactionId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub transaction_id: Option<TransactionId>,
}
impl<'de> DeserializeStrict<'de> for CommitNode {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "actor")]
            actor: Strict<ActorId>,
            #[serde(rename = "commitId")]
            commit_id: Strict<CommitId>,
            #[serde(rename = "committedAtMicros")]
            committed_at_micros: Strict<SafeLong>,
            #[serde(rename = "message")]
            #[serde(default)]
            message: Strict<Option<String>>,
            #[serde(rename = "namespaceChangeCount")]
            namespace_change_count: Strict<u32>,
            #[serde(rename = "parentCommitIds")]
            parent_commit_ids: Strict<Vec<CommitId>>,
            #[serde(rename = "resourceChangeCount")]
            resource_change_count: Strict<u32>,
            #[serde(rename = "transactionId")]
            #[serde(default)]
            transaction_id: Strict<Option<TransactionId>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            actor: wire.actor.0,
            commit_id: wire.commit_id.0,
            committed_at_micros: wire.committed_at_micros.0,
            message: wire.message.0,
            namespace_change_count: wire.namespace_change_count.0,
            parent_commit_ids: wire.parent_commit_ids.0,
            resource_change_count: wire.resource_change_count.0,
            transaction_id: wire.transaction_id.0,
        })
    }
}

/// A commit identity or a movable branch/immutable tag resolved exactly once per request. Relative
/// expressions such as main~3 are not supported.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CommitSelector {
    /// A known union arm.
    Branch(BranchTarget),
    /// A known union arm.
    Commit(CommitTarget),
    /// A known union arm.
    Tag(TagTarget),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for CommitSelector {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Branch(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("branch".into()));
                object.insert(
                    "branch".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Commit(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("commit".into()));
                object.insert(
                    "commit".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Tag(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("tag".into()));
                object.insert(
                    "tag".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 CommitSelector {
    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 {
            "branch" => Ok(Self::Branch(
                serde_json::from_value(
                    value
                        .get("branch")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "commit" => Ok(Self::Commit(
                serde_json::from_value(
                    value
                        .get("commit")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "tag" => Ok(Self::Tag(
                serde_json::from_value(
                    value
                        .get("tag")
                        .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 CommitSelector {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "branch")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "branch")]
            value: Strict<BranchTarget>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "commit")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "commit")]
            value: Strict<CommitTarget>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "tag")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "tag")]
            value: Strict<TagTarget>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Branch(Box<__Arm0>),
            Commit(Box<__Arm1>),
            Tag(Box<__Arm2>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Branch(arm) => Self::Branch(arm.value.0),
            __Known::Commit(arm) => Self::Commit(arm.value.0),
            __Known::Tag(arm) => Self::Tag(arm.value.0),
        })
    }
}

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

/// CompareCommitsRequest contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CompareCommitsRequest {
    /// Contract field base.
    #[serde(rename = "base")]
    pub base: CommitSelector,
    /// Contract field head.
    #[serde(rename = "head")]
    pub head: CommitSelector,
    /// Contract field maxCommits.
    #[serde(rename = "maxCommits")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_commits: Option<CommitLogLimit>,
}
impl<'de> DeserializeStrict<'de> for CompareCommitsRequest {
    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<CommitSelector>,
            #[serde(rename = "head")]
            head: Strict<CommitSelector>,
            #[serde(rename = "maxCommits")]
            #[serde(default)]
            max_commits: Strict<Option<CommitLogLimit>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            base: wire.base.0,
            head: wire.head.0,
            max_commits: wire.max_commits.0,
        })
    }
}

/// Exact ahead/behind counts and bounded head-only commit graph. Counts serialize as unsigned
/// decimal strings. continuationCommitIds is a graph frontier with the same duplicate-handling
/// responsibility and 1000-identity bound as CommitLog; it is not a page token. Internal traversal
/// is bounded to 100000 commits per side and exceeding that bound is a named error.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CompareCommitsResponse {
    /// Contract field aheadCount.
    #[serde(rename = "aheadCount")]
    pub ahead_count: SafeUnsignedLong,
    /// Contract field baseCommitId.
    #[serde(rename = "baseCommitId")]
    pub base_commit_id: CommitId,
    /// Contract field behindCount.
    #[serde(rename = "behindCount")]
    pub behind_count: SafeUnsignedLong,
    /// Contract field commits.
    #[serde(rename = "commits")]
    pub commits: Vec<CommitNode>,
    /// Contract field continuationCommitIds.
    #[serde(rename = "continuationCommitIds")]
    pub continuation_commit_ids: Vec<CommitId>,
    /// Contract field headCommitId.
    #[serde(rename = "headCommitId")]
    pub head_commit_id: CommitId,
    /// Contract field mergeBaseCommitIds.
    #[serde(rename = "mergeBaseCommitIds")]
    pub merge_base_commit_ids: Vec<CommitId>,
    /// Contract field truncated.
    #[serde(rename = "truncated")]
    pub truncated: bool,
}
impl<'de> DeserializeStrict<'de> for CompareCommitsResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "aheadCount")]
            ahead_count: Strict<SafeUnsignedLong>,
            #[serde(rename = "baseCommitId")]
            base_commit_id: Strict<CommitId>,
            #[serde(rename = "behindCount")]
            behind_count: Strict<SafeUnsignedLong>,
            #[serde(rename = "commits")]
            commits: Strict<Vec<CommitNode>>,
            #[serde(rename = "continuationCommitIds")]
            continuation_commit_ids: Strict<Vec<CommitId>>,
            #[serde(rename = "headCommitId")]
            head_commit_id: Strict<CommitId>,
            #[serde(rename = "mergeBaseCommitIds")]
            merge_base_commit_ids: Strict<Vec<CommitId>>,
            #[serde(rename = "truncated")]
            truncated: Strict<bool>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            ahead_count: wire.ahead_count.0,
            base_commit_id: wire.base_commit_id.0,
            behind_count: wire.behind_count.0,
            commits: wire.commits.0,
            continuation_commit_ids: wire.continuation_commit_ids.0,
            head_commit_id: wire.head_commit_id.0,
            merge_base_commit_ids: wire.merge_base_commit_ids.0,
            truncated: wire.truncated.0,
        })
    }
}

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

/// Install a resource absent from the target state. The descriptor supplies its identity and must
/// match any prior registration across project history and retirement; its service must own and
/// validate the version.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreateResourceChange {
    /// Contract field descriptor.
    #[serde(rename = "descriptor")]
    pub descriptor: ResourceDescriptor,
    /// Contract field versionId.
    #[serde(rename = "versionId")]
    pub version_id: VersionId,
}
impl<'de> DeserializeStrict<'de> for CreateResourceChange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "descriptor")]
            descriptor: Strict<ResourceDescriptor>,
            #[serde(rename = "versionId")]
            version_id: Strict<VersionId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            descriptor: wire.descriptor.0,
            version_id: wire.version_id.0,
        })
    }
}

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

/// Tombstone the stable branch identity. Historical commits and branch events remain readable.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct DeleteBranchRequest {
    /// Contract field idempotencyKey.
    #[serde(rename = "idempotencyKey")]
    pub idempotency_key: IdempotencyKey,
}
impl<'de> DeserializeStrict<'de> for DeleteBranchRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "idempotencyKey")]
            idempotency_key: Strict<IdempotencyKey>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            idempotency_key: wire.idempotency_key.0,
        })
    }
}

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

/// Canonical net mutations transforming base state into head state. Does not include assertions.
/// Materialization limits produce named errors rather than silently truncating a diff.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct DiffStateResponse {
    /// Contract field baseCommitId.
    #[serde(rename = "baseCommitId")]
    pub base_commit_id: CommitId,
    /// Contract field headCommitId.
    #[serde(rename = "headCommitId")]
    pub head_commit_id: CommitId,
    /// Contract field namespace.
    #[serde(rename = "namespace")]
    pub namespace: Vec<NamespaceChange>,
    /// Contract field resources.
    #[serde(rename = "resources")]
    pub resources: Vec<ResourceChange>,
}
impl<'de> DeserializeStrict<'de> for DiffStateResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "baseCommitId")]
            base_commit_id: Strict<CommitId>,
            #[serde(rename = "headCommitId")]
            head_commit_id: Strict<CommitId>,
            #[serde(rename = "namespace")]
            namespace: Strict<Vec<NamespaceChange>>,
            #[serde(rename = "resources")]
            resources: Strict<Vec<ResourceChange>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            base_commit_id: wire.base_commit_id.0,
            head_commit_id: wire.head_commit_id.0,
            namespace: wire.namespace.0,
            resources: wire.resources.0,
        })
    }
}

/// Empty payload for a union variant without additional data.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Empty {}
impl<'de> DeserializeStrict<'de> for Empty {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {}
        __Wire::deserialize(deserializer)?;
        Ok(Self {})
    }
}

/// Follow all ordered parents or only the first parent; omission defaults to all_parents.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum GraphTraversal {
    /// A known contract value.
    AllParents,
    /// A known contract value.
    FirstParent,
    /// A value introduced by a newer server.
    Unknown(String),
}
impl Serialize for GraphTraversal {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(match self {
            Self::AllParents => "all_parents",
            Self::FirstParent => "first_parent",
            Self::Unknown(value) => value,
        })
    }
}
impl<'de> Deserialize<'de> for GraphTraversal {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(match String::deserialize(deserializer)?.as_str() {
            "all_parents" => Self::AllParents,
            "first_parent" => Self::FirstParent,
            value => Self::Unknown(value.to_owned()),
        })
    }
}
impl<'de> DeserializeStrict<'de> for GraphTraversal {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Known {
            #[serde(rename = "all_parents")]
            AllParents,
            #[serde(rename = "first_parent")]
            FirstParent,
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::AllParents => Self::AllParents,
            __Known::FirstParent => Self::FirstParent,
        })
    }
}

/// Nonempty opaque retry key, at most 128 UTF-8 bytes, scoped to project and authenticated actor.
/// Identical retries return the saved result; reuse for a different operation or request is
/// rejected.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct IdempotencyKey(pub String);
impl std::fmt::Display for IdempotencyKey {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for IdempotencyKey {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
    }
}

/// includeDeleted defaults to false. The opaque token preserves the project, endpoint,
/// includeDeleted filter, page size, authorization scope, and current position in the live listing.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListBranchesRequest {
    /// Contract field includeDeleted.
    #[serde(rename = "includeDeleted")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub include_deleted: Option<bool>,
    /// Contract field pageSize.
    #[serde(rename = "pageSize")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_size: Option<PageSize>,
    /// Contract field pageToken.
    #[serde(rename = "pageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_token: Option<PageToken>,
}
impl<'de> DeserializeStrict<'de> for ListBranchesRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "includeDeleted")]
            #[serde(default)]
            include_deleted: Strict<Option<bool>>,
            #[serde(rename = "pageSize")]
            #[serde(default)]
            page_size: Strict<Option<PageSize>>,
            #[serde(rename = "pageToken")]
            #[serde(default)]
            page_token: Strict<Option<PageToken>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            include_deleted: wire.include_deleted.0,
            page_size: wire.page_size.0,
            page_token: wire.page_token.0,
        })
    }
}

/// Live branches ordered by name, then stable identity. Weak consistency: concurrent creates,
/// renames, or deletions can omit or repeat entries across pages. A complete consistent project
/// state uses an immutable commit, not this live reference inventory.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListBranchesResponse {
    /// Contract field branches.
    #[serde(rename = "branches")]
    pub branches: Vec<Branch>,
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<PageToken>,
}
impl<'de> DeserializeStrict<'de> for ListBranchesResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "branches")]
            branches: Strict<Vec<Branch>>,
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<PageToken>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            branches: wire.branches.0,
            next_page_token: wire.next_page_token.0,
        })
    }
}

/// List concrete bindings within the selected resource anchor and implicit-prefix subtree at the
/// exact commit. Traversal stops at concrete resource boundaries. A resource parent lists
/// identity-anchored children. To inspect path-anchored children, use a prefix parent formed from
/// the returned canonical parent and leaf name; aliases may have distinct path subtrees.
/// hasChildren covers either domain. Entries are ordered lexicographically by relative path
/// segments, then resource identity. Implicit prefixes are traversal structure rather than
/// fabricated resource entries. Continuations preserve the parent and exact commit.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListNamespaceRequest {
    /// Contract field pageSize.
    #[serde(rename = "pageSize")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_size: Option<PageSize>,
    /// Contract field pageToken.
    #[serde(rename = "pageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_token: Option<PageToken>,
    /// Contract field parent.
    #[serde(rename = "parent")]
    pub parent: NamespaceParent,
}
impl<'de> DeserializeStrict<'de> for ListNamespaceRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "pageSize")]
            #[serde(default)]
            page_size: Strict<Option<PageSize>>,
            #[serde(rename = "pageToken")]
            #[serde(default)]
            page_token: Strict<Option<PageToken>>,
            #[serde(rename = "parent")]
            parent: Strict<NamespaceParent>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            page_size: wire.page_size.0,
            page_token: wire.page_token.0,
            parent: wire.parent.0,
        })
    }
}

/// The opaque token preserves the project, endpoint, page size, authorization scope, and current
/// position in the live listing.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListTagsRequest {
    /// Contract field pageSize.
    #[serde(rename = "pageSize")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_size: Option<PageSize>,
    /// Contract field pageToken.
    #[serde(rename = "pageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_token: Option<PageToken>,
}
impl<'de> DeserializeStrict<'de> for ListTagsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "pageSize")]
            #[serde(default)]
            page_size: Strict<Option<PageSize>>,
            #[serde(rename = "pageToken")]
            #[serde(default)]
            page_token: Strict<Option<PageToken>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            page_size: wire.page_size.0,
            page_token: wire.page_token.0,
        })
    }
}

/// Live tags ordered by name. Weak consistency: a concurrent creation before the cursor may not
/// appear in this traversal. Tags themselves remain immutable.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListTagsResponse {
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<PageToken>,
    /// Contract field tags.
    #[serde(rename = "tags")]
    pub tags: Vec<Tag>,
}
impl<'de> DeserializeStrict<'de> for ListTagsResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<PageToken>>,
            #[serde(rename = "tags")]
            tags: Strict<Vec<Tag>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            next_page_token: wire.next_page_token.0,
            tags: wire.tags.0,
        })
    }
}

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

/// All best common ancestors of the two resolved commits. Empty means unrelated histories; multiple
/// bases are preserved rather than arbitrarily choosing one.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct MergeBasesResponse {
    /// Contract field leftCommitId.
    #[serde(rename = "leftCommitId")]
    pub left_commit_id: CommitId,
    /// Contract field mergeBaseCommitIds.
    #[serde(rename = "mergeBaseCommitIds")]
    pub merge_base_commit_ids: Vec<CommitId>,
    /// Contract field rightCommitId.
    #[serde(rename = "rightCommitId")]
    pub right_commit_id: CommitId,
}
impl<'de> DeserializeStrict<'de> for MergeBasesResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "leftCommitId")]
            left_commit_id: Strict<CommitId>,
            #[serde(rename = "mergeBaseCommitIds")]
            merge_base_commit_ids: Strict<Vec<CommitId>>,
            #[serde(rename = "rightCommitId")]
            right_commit_id: Strict<CommitId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            left_commit_id: wire.left_commit_id.0,
            merge_base_commit_ids: wire.merge_base_commit_ids.0,
            right_commit_id: wire.right_commit_id.0,
        })
    }
}

/// MergeConflict contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct MergeConflict {
    /// Contract field constraints.
    #[serde(rename = "constraints")]
    pub constraints: Vec<NamespaceConstraintConflict>,
    /// Contract field mergeBaseCommitId.
    #[serde(rename = "mergeBaseCommitId")]
    pub merge_base_commit_id: CommitId,
    /// Contract field namespace.
    #[serde(rename = "namespace")]
    pub namespace: Vec<NamespaceMergeConflict>,
    /// Contract field resources.
    #[serde(rename = "resources")]
    pub resources: Vec<ResourceMergeConflict>,
    /// Contract field sourceCommitId.
    #[serde(rename = "sourceCommitId")]
    pub source_commit_id: CommitId,
    /// Contract field targetCommitId.
    #[serde(rename = "targetCommitId")]
    pub target_commit_id: CommitId,
}
impl<'de> DeserializeStrict<'de> for MergeConflict {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "constraints")]
            constraints: Strict<Vec<NamespaceConstraintConflict>>,
            #[serde(rename = "mergeBaseCommitId")]
            merge_base_commit_id: Strict<CommitId>,
            #[serde(rename = "namespace")]
            namespace: Strict<Vec<NamespaceMergeConflict>>,
            #[serde(rename = "resources")]
            resources: Strict<Vec<ResourceMergeConflict>>,
            #[serde(rename = "sourceCommitId")]
            source_commit_id: Strict<CommitId>,
            #[serde(rename = "targetCommitId")]
            target_commit_id: Strict<CommitId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            constraints: wire.constraints.0,
            merge_base_commit_id: wire.merge_base_commit_id.0,
            namespace: wire.namespace.0,
            resources: wire.resources.0,
            source_commit_id: wire.source_commit_id.0,
            target_commit_id: wire.target_commit_id.0,
        })
    }
}

/// Assess or publish a three-way merge. dryRun defaults to false. Both expected heads are required
/// when supplying participant resolutions so assessment and publication use identical heads. Source
/// selector resolves once. Multiple best common ancestors produce AmbiguousMergeBase. Catalog
/// coordinates pointers and namespace constraints without initializing a query engine.
/// resourceResolutions is required, may be empty, and is bounded to 1000 entries; message and retry
/// bounds match PublishRequest.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct MergeRequest {
    /// Contract field dryRun.
    #[serde(rename = "dryRun")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dry_run: Option<bool>,
    /// Contract field expectedSourceCommitId.
    #[serde(rename = "expectedSourceCommitId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expected_source_commit_id: Option<CommitId>,
    /// Contract field expectedTargetCommitId.
    #[serde(rename = "expectedTargetCommitId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expected_target_commit_id: Option<CommitId>,
    /// Contract field idempotencyKey.
    #[serde(rename = "idempotencyKey")]
    pub idempotency_key: IdempotencyKey,
    /// Contract field message.
    #[serde(rename = "message")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    /// Contract field resourceResolutions.
    #[serde(rename = "resourceResolutions")]
    pub resource_resolutions: Vec<ResourceMergeResolution>,
    /// Contract field source.
    #[serde(rename = "source")]
    pub source: CommitSelector,
    /// Contract field targetBranchId.
    #[serde(rename = "targetBranchId")]
    pub target_branch_id: BranchId,
    /// Contract field transactionId.
    #[serde(rename = "transactionId")]
    pub transaction_id: TransactionId,
}
impl<'de> DeserializeStrict<'de> for MergeRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "dryRun")]
            #[serde(default)]
            dry_run: Strict<Option<bool>>,
            #[serde(rename = "expectedSourceCommitId")]
            #[serde(default)]
            expected_source_commit_id: Strict<Option<CommitId>>,
            #[serde(rename = "expectedTargetCommitId")]
            #[serde(default)]
            expected_target_commit_id: Strict<Option<CommitId>>,
            #[serde(rename = "idempotencyKey")]
            idempotency_key: Strict<IdempotencyKey>,
            #[serde(rename = "message")]
            #[serde(default)]
            message: Strict<Option<String>>,
            #[serde(rename = "resourceResolutions")]
            resource_resolutions: Strict<Vec<ResourceMergeResolution>>,
            #[serde(rename = "source")]
            source: Strict<CommitSelector>,
            #[serde(rename = "targetBranchId")]
            target_branch_id: Strict<BranchId>,
            #[serde(rename = "transactionId")]
            transaction_id: Strict<TransactionId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            dry_run: wire.dry_run.0,
            expected_source_commit_id: wire.expected_source_commit_id.0,
            expected_target_commit_id: wire.expected_target_commit_id.0,
            idempotency_key: wire.idempotency_key.0,
            message: wire.message.0,
            resource_resolutions: wire.resource_resolutions.0,
            source: wire.source.0,
            target_branch_id: wire.target_branch_id.0,
            transaction_id: wire.transaction_id.0,
        })
    }
}

/// Mergeable is the successful dry-run assessment; published is an atomic merge commit with target
/// first parent and source second parent. Conflicts are response data and publish nothing.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum MergeResponse {
    /// A known union arm.
    AlreadyUpToDate(AlreadyUpToDate),
    /// A known union arm.
    Conflict(MergeConflict),
    /// A known union arm.
    Mergeable(Mergeable),
    /// A known union arm.
    Published(Merged),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for MergeResponse {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::AlreadyUpToDate(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("alreadyUpToDate".into()));
                object.insert(
                    "alreadyUpToDate".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Conflict(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("conflict".into()));
                object.insert(
                    "conflict".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Mergeable(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("mergeable".into()));
                object.insert(
                    "mergeable".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Published(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("published".into()));
                object.insert(
                    "published".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 MergeResponse {
    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 {
            "alreadyUpToDate" => Ok(Self::AlreadyUpToDate(
                serde_json::from_value(
                    value
                        .get("alreadyUpToDate")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "conflict" => Ok(Self::Conflict(
                serde_json::from_value(
                    value
                        .get("conflict")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "mergeable" => Ok(Self::Mergeable(
                serde_json::from_value(
                    value
                        .get("mergeable")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "published" => Ok(Self::Published(
                serde_json::from_value(
                    value
                        .get("published")
                        .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 MergeResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "alreadyUpToDate")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "alreadyUpToDate")]
            value: Strict<AlreadyUpToDate>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "conflict")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "conflict")]
            value: Strict<MergeConflict>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "mergeable")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "mergeable")]
            value: Strict<Mergeable>,
        }
        #[derive(Deserialize)]
        enum __Tag3 {
            #[serde(rename = "published")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm3 {
            #[serde(rename = "type")]
            _tag: __Tag3,
            #[serde(rename = "published")]
            value: Strict<Merged>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            AlreadyUpToDate(Box<__Arm0>),
            Conflict(Box<__Arm1>),
            Mergeable(Box<__Arm2>),
            Published(Box<__Arm3>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::AlreadyUpToDate(arm) => Self::AlreadyUpToDate(arm.value.0),
            __Known::Conflict(arm) => Self::Conflict(arm.value.0),
            __Known::Mergeable(arm) => Self::Mergeable(arm.value.0),
            __Known::Published(arm) => Self::Published(arm.value.0),
        })
    }
}

/// Mergeable contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Mergeable {
    /// Contract field mergeBaseCommitId.
    #[serde(rename = "mergeBaseCommitId")]
    pub merge_base_commit_id: CommitId,
    /// Contract field namespaceChangeCount.
    #[serde(rename = "namespaceChangeCount")]
    pub namespace_change_count: u32,
    /// Contract field resourceChangeCount.
    #[serde(rename = "resourceChangeCount")]
    pub resource_change_count: u32,
    /// Contract field sourceCommitId.
    #[serde(rename = "sourceCommitId")]
    pub source_commit_id: CommitId,
    /// Contract field targetCommitId.
    #[serde(rename = "targetCommitId")]
    pub target_commit_id: CommitId,
}
impl<'de> DeserializeStrict<'de> for Mergeable {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "mergeBaseCommitId")]
            merge_base_commit_id: Strict<CommitId>,
            #[serde(rename = "namespaceChangeCount")]
            namespace_change_count: Strict<u32>,
            #[serde(rename = "resourceChangeCount")]
            resource_change_count: Strict<u32>,
            #[serde(rename = "sourceCommitId")]
            source_commit_id: Strict<CommitId>,
            #[serde(rename = "targetCommitId")]
            target_commit_id: Strict<CommitId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            merge_base_commit_id: wire.merge_base_commit_id.0,
            namespace_change_count: wire.namespace_change_count.0,
            resource_change_count: wire.resource_change_count.0,
            source_commit_id: wire.source_commit_id.0,
            target_commit_id: wire.target_commit_id.0,
        })
    }
}

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

/// One submitted namespace-map operation. A request must contain at most one entry for each
/// canonical parent/name domain across all variants.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum NamespaceChange {
    /// A known union arm.
    Assert(AssertNamespaceChange),
    /// A known union arm.
    Bind(BindNamespaceChange),
    /// A known union arm.
    Unbind(UnbindNamespaceChange),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for NamespaceChange {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Assert(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("assert".into()));
                object.insert(
                    "assert".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Bind(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("bind".into()));
                object.insert(
                    "bind".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Unbind(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("unbind".into()));
                object.insert(
                    "unbind".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 NamespaceChange {
    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 {
            "assert" => Ok(Self::Assert(
                serde_json::from_value(
                    value
                        .get("assert")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "bind" => Ok(Self::Bind(
                serde_json::from_value(
                    value
                        .get("bind")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "unbind" => Ok(Self::Unbind(
                serde_json::from_value(
                    value
                        .get("unbind")
                        .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 NamespaceChange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "assert")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "assert")]
            value: Strict<AssertNamespaceChange>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "bind")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "bind")]
            value: Strict<BindNamespaceChange>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "unbind")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "unbind")]
            value: Strict<UnbindNamespaceChange>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Assert(Box<__Arm0>),
            Bind(Box<__Arm1>),
            Unbind(Box<__Arm2>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Assert(arm) => Self::Assert(arm.value.0),
            __Known::Bind(arm) => Self::Bind(arm.value.0),
            __Known::Unbind(arm) => Self::Unbind(arm.value.0),
        })
    }
}

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

/// Constraint failures from evaluating the complete proposed atomic state. No submitted changes are
/// published when any conflict is returned.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum NamespaceConstraintConflict {
    /// A known union arm.
    AmbiguousBinding(BindingConstraint),
    /// A known union arm.
    BindingTargetsRetiredResource(RetiredTargetConstraint),
    /// A known union arm.
    ManagedBinding(ResourceConstraint),
    /// A known union arm.
    NamespaceCycle(ResourceConstraint),
    /// A known union arm.
    NamespaceRootNotLive(RootConstraint),
    /// A known union arm.
    OutsideNamespaceRoot(RootConstraint),
    /// A known union arm.
    ParentNotLive(ParentConstraint),
    /// A known union arm.
    ResourceHasChildren(ResourceConstraint),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for NamespaceConstraintConflict {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::AmbiguousBinding(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("ambiguousBinding".into()));
                object.insert(
                    "ambiguousBinding".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::BindingTargetsRetiredResource(value) => {
                let mut object = serde_json::Map::new();
                object.insert(
                    "type".into(),
                    Value::String("bindingTargetsRetiredResource".into()),
                );
                object.insert(
                    "bindingTargetsRetiredResource".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::ManagedBinding(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("managedBinding".into()));
                object.insert(
                    "managedBinding".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::NamespaceCycle(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("namespaceCycle".into()));
                object.insert(
                    "namespaceCycle".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::NamespaceRootNotLive(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("namespaceRootNotLive".into()));
                object.insert(
                    "namespaceRootNotLive".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::OutsideNamespaceRoot(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("outsideNamespaceRoot".into()));
                object.insert(
                    "outsideNamespaceRoot".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::ParentNotLive(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("parentNotLive".into()));
                object.insert(
                    "parentNotLive".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::ResourceHasChildren(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("resourceHasChildren".into()));
                object.insert(
                    "resourceHasChildren".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 NamespaceConstraintConflict {
    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 {
            "ambiguousBinding" => Ok(Self::AmbiguousBinding(
                serde_json::from_value(
                    value
                        .get("ambiguousBinding")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "bindingTargetsRetiredResource" => Ok(Self::BindingTargetsRetiredResource(
                serde_json::from_value(
                    value
                        .get("bindingTargetsRetiredResource")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "managedBinding" => Ok(Self::ManagedBinding(
                serde_json::from_value(
                    value
                        .get("managedBinding")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "namespaceCycle" => Ok(Self::NamespaceCycle(
                serde_json::from_value(
                    value
                        .get("namespaceCycle")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "namespaceRootNotLive" => Ok(Self::NamespaceRootNotLive(
                serde_json::from_value(
                    value
                        .get("namespaceRootNotLive")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "outsideNamespaceRoot" => Ok(Self::OutsideNamespaceRoot(
                serde_json::from_value(
                    value
                        .get("outsideNamespaceRoot")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "parentNotLive" => Ok(Self::ParentNotLive(
                serde_json::from_value(
                    value
                        .get("parentNotLive")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "resourceHasChildren" => Ok(Self::ResourceHasChildren(
                serde_json::from_value(
                    value
                        .get("resourceHasChildren")
                        .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 NamespaceConstraintConflict {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "ambiguousBinding")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "ambiguousBinding")]
            value: Strict<BindingConstraint>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "bindingTargetsRetiredResource")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "bindingTargetsRetiredResource")]
            value: Strict<RetiredTargetConstraint>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "managedBinding")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "managedBinding")]
            value: Strict<ResourceConstraint>,
        }
        #[derive(Deserialize)]
        enum __Tag3 {
            #[serde(rename = "namespaceCycle")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm3 {
            #[serde(rename = "type")]
            _tag: __Tag3,
            #[serde(rename = "namespaceCycle")]
            value: Strict<ResourceConstraint>,
        }
        #[derive(Deserialize)]
        enum __Tag4 {
            #[serde(rename = "namespaceRootNotLive")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm4 {
            #[serde(rename = "type")]
            _tag: __Tag4,
            #[serde(rename = "namespaceRootNotLive")]
            value: Strict<RootConstraint>,
        }
        #[derive(Deserialize)]
        enum __Tag5 {
            #[serde(rename = "outsideNamespaceRoot")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm5 {
            #[serde(rename = "type")]
            _tag: __Tag5,
            #[serde(rename = "outsideNamespaceRoot")]
            value: Strict<RootConstraint>,
        }
        #[derive(Deserialize)]
        enum __Tag6 {
            #[serde(rename = "parentNotLive")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm6 {
            #[serde(rename = "type")]
            _tag: __Tag6,
            #[serde(rename = "parentNotLive")]
            value: Strict<ParentConstraint>,
        }
        #[derive(Deserialize)]
        enum __Tag7 {
            #[serde(rename = "resourceHasChildren")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm7 {
            #[serde(rename = "type")]
            _tag: __Tag7,
            #[serde(rename = "resourceHasChildren")]
            value: Strict<ResourceConstraint>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            AmbiguousBinding(Box<__Arm0>),
            BindingTargetsRetiredResource(Box<__Arm1>),
            ManagedBinding(Box<__Arm2>),
            NamespaceCycle(Box<__Arm3>),
            NamespaceRootNotLive(Box<__Arm4>),
            OutsideNamespaceRoot(Box<__Arm5>),
            ParentNotLive(Box<__Arm6>),
            ResourceHasChildren(Box<__Arm7>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::AmbiguousBinding(arm) => Self::AmbiguousBinding(arm.value.0),
            __Known::BindingTargetsRetiredResource(arm) => {
                Self::BindingTargetsRetiredResource(arm.value.0)
            }
            __Known::ManagedBinding(arm) => Self::ManagedBinding(arm.value.0),
            __Known::NamespaceCycle(arm) => Self::NamespaceCycle(arm.value.0),
            __Known::NamespaceRootNotLive(arm) => Self::NamespaceRootNotLive(arm.value.0),
            __Known::OutsideNamespaceRoot(arm) => Self::OutsideNamespaceRoot(arm.value.0),
            __Known::ParentNotLive(arm) => Self::ParentNotLive(arm.value.0),
            __Known::ResourceHasChildren(arm) => Self::ResourceHasChildren(arm.value.0),
        })
    }
}

/// A concrete binding at the selected commit. relativePath is relative to the requested parent and
/// defines listing order; parent and name retain the canonical binding domain. hasChildren reports
/// descendants in either the resource-anchored domain or the literal path subtree. These remain
/// distinct when a resource has multiple aliases; callers select the desired domain explicitly.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct NamespaceEntry {
    /// Contract field hasChildren.
    #[serde(rename = "hasChildren")]
    pub has_children: bool,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: NamespaceSegment,
    /// Contract field parent.
    #[serde(rename = "parent")]
    pub parent: NamespaceParent,
    /// Contract field relativePath.
    #[serde(rename = "relativePath")]
    pub relative_path: NamespacePath,
    /// Contract field resource.
    #[serde(rename = "resource")]
    pub resource: ResourceState,
}
impl<'de> DeserializeStrict<'de> for NamespaceEntry {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "hasChildren")]
            has_children: Strict<bool>,
            #[serde(rename = "name")]
            name: Strict<NamespaceSegment>,
            #[serde(rename = "parent")]
            parent: Strict<NamespaceParent>,
            #[serde(rename = "relativePath")]
            relative_path: Strict<NamespacePath>,
            #[serde(rename = "resource")]
            resource: Strict<ResourceState>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            has_children: wire.has_children.0,
            name: wire.name.0,
            parent: wire.parent.0,
            relative_path: wire.relative_path.0,
            resource: wire.resource.0,
        })
    }
}

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

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

/// Explicit namespace binding domain. Implicit prefixes do not allocate resources. Persistence
/// encoding is an implementation detail.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum NamespaceParent {
    /// A known union arm.
    Prefix(PrefixParent),
    /// A known union arm.
    ProjectRoot(Empty),
    /// A known union arm.
    Resource(ResourceParent),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for NamespaceParent {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Prefix(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("prefix".into()));
                object.insert(
                    "prefix".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::ProjectRoot(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("projectRoot".into()));
                object.insert(
                    "projectRoot".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Resource(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("resource".into()));
                object.insert(
                    "resource".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::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 NamespaceParent {
    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 {
            "prefix" => Ok(Self::Prefix(
                serde_json::from_value(
                    value
                        .get("prefix")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "projectRoot" => Ok(Self::ProjectRoot(
                serde_json::from_value(
                    value
                        .get("projectRoot")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "resource" => Ok(Self::Resource(
                serde_json::from_value(
                    value
                        .get("resource")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            tag => Ok(Self::Unknown {
                tag: tag.to_owned(),
                value,
            }),
        }
    }
}
impl<'de> DeserializeStrict<'de> for NamespaceParent {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "prefix")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "prefix")]
            value: Strict<PrefixParent>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "projectRoot")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "projectRoot")]
            value: Strict<Empty>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "resource")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "resource")]
            value: Strict<ResourceParent>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Prefix(Box<__Arm0>),
            ProjectRoot(Box<__Arm1>),
            Resource(Box<__Arm2>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Prefix(arm) => Self::Prefix(arm.value.0),
            __Known::ProjectRoot(arm) => Self::ProjectRoot(arm.value.0),
            __Known::Resource(arm) => Self::Resource(arm.value.0),
        })
    }
}

/// Absolute path from the project root, or a relative path where explicitly stated. Empty selects
/// the root. At most 64 segments.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct NamespacePath(pub Vec<NamespaceSegment>);
impl<'de> DeserializeStrict<'de> for NamespacePath {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(
            Strict::<Vec<NamespaceSegment>>::deserialize(deserializer)?.0,
        ))
    }
}

/// One nonempty namespace segment, at most 255 UTF-8 bytes, with no control characters. Dot,
/// dot-dot, and slash-containing segments are rejected. Segments are passed as JSON array elements,
/// not parsed from dotted or slash-separated text.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct NamespaceSegment(pub String);
impl std::fmt::Display for NamespaceSegment {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for NamespaceSegment {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
    }
}

/// Caller-allocated durable operation identity, scoped to one project.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct OperationId(pub Uuid);
impl std::fmt::Display for OperationId {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for OperationId {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<Uuid>::deserialize(deserializer)?.0))
    }
}

/// Only successful committed operations have receipts; an attempted publication conflict does not
/// constitute a completed operation.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct OperationReceipt {
    /// Contract field operation.
    #[serde(rename = "operation")]
    pub operation: ProjectOperation,
    /// Contract field publication.
    #[serde(rename = "publication")]
    pub publication: Publication,
}
impl<'de> DeserializeStrict<'de> for OperationReceipt {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "operation")]
            operation: Strict<ProjectOperation>,
            #[serde(rename = "publication")]
            publication: Strict<Publication>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            operation: wire.operation.0,
            publication: wire.publication.0,
        })
    }
}

/// Service validates 1 through 1000. Omission or null defaults to 100; generated clients do not
/// supply or clamp a value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct PageSize(pub u32);
impl std::fmt::Display for PageSize {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for PageSize {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<u32>::deserialize(deserializer)?.0))
    }
}

/// Opaque continuation returned by this API. Bound to project, endpoint, authorization scope,
/// filters, page size, and immutable commit, captured event frontier, or live-list cursor as
/// applicable. Invalid, expired, or mismatched tokens are errors; clients must not decode or
/// manufacture them.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct PageToken(pub String);
impl std::fmt::Display for PageToken {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for PageToken {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
    }
}

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

/// Implicit path segments relative to a resource anchor, or the project root when resourceId is
/// absent. Must leave room for one leaf segment.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PrefixParent {
    /// Contract field path.
    #[serde(rename = "path")]
    pub path: NamespacePath,
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_id: Option<ResourceId>,
}
impl<'de> DeserializeStrict<'de> for PrefixParent {
    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<NamespacePath>,
            #[serde(rename = "resourceId")]
            #[serde(default)]
            resource_id: Strict<Option<ResourceId>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            path: wire.path.0,
            resource_id: wire.resource_id.0,
        })
    }
}

/// Owning project identifier. Nonempty, at most 128 UTF-8 bytes, with no control characters.
/// Project creation belongs to the project service.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ProjectId(pub String);
impl std::fmt::Display for ProjectId {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for ProjectId {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
    }
}

/// Opaque JSON operation input and completed result saved atomically with publication. Catalog does
/// not interpret resource-specific payloads. Operation identity is project-scoped and independent
/// of transaction and caller identity. Precision-sensitive numbers in opaque JSON should be encoded
/// as strings for cross-language portability.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProjectOperation {
    /// Contract field input.
    #[serde(rename = "input")]
    pub input: Value,
    /// Contract field operationId.
    #[serde(rename = "operationId")]
    pub operation_id: OperationId,
    /// Contract field result.
    #[serde(rename = "result")]
    pub result: Value,
}
impl<'de> DeserializeStrict<'de> for ProjectOperation {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "input")]
            input: Strict<Value>,
            #[serde(rename = "operationId")]
            operation_id: Strict<OperationId>,
            #[serde(rename = "result")]
            result: Strict<Value>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            input: wire.input.0,
            operation_id: wire.operation_id.0,
            result: wire.result.0,
        })
    }
}

/// Saved publication result. The ordinary publication commit has one first parent; retry returns
/// the original result even if the branch subsequently advanced.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Publication {
    /// Contract field commitId.
    #[serde(rename = "commitId")]
    pub commit_id: CommitId,
    /// Contract field parentCommitId.
    #[serde(rename = "parentCommitId")]
    pub parent_commit_id: CommitId,
}
impl<'de> DeserializeStrict<'de> for Publication {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "commitId")]
            commit_id: Strict<CommitId>,
            #[serde(rename = "parentCommitId")]
            parent_commit_id: Strict<CommitId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            commit_id: wire.commit_id.0,
            parent_commit_id: wire.parent_commit_id.0,
        })
    }
}

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

/// Publish at most once for operationId and input. A retry with the same input returns the saved
/// publication and preserves the first completed result, even if a later caller supplies a
/// different result. Different input for an existing operation is rejected. Input comparison
/// ignores JSON object key order and preserves array element order. Unlike ordinary publication,
/// empty change lists may save a durable result without resource changes.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PublishOperationRequest {
    /// Contract field operation.
    #[serde(rename = "operation")]
    pub operation: ProjectOperation,
    /// Contract field publication.
    #[serde(rename = "publication")]
    pub publication: PublishRequest,
}
impl<'de> DeserializeStrict<'de> for PublishOperationRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "operation")]
            operation: Strict<ProjectOperation>,
            #[serde(rename = "publication")]
            publication: Strict<PublishRequest>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            operation: wire.operation.0,
            publication: wire.publication.0,
        })
    }
}

/// A successful operation publication returns the winning receipt, including its original saved
/// result and publication identities. Candidates with the same input do not replace an existing
/// receipt. Conflicts publish no operation result.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum PublishOperationResponse {
    /// A known union arm.
    Conflict(PublicationConflict),
    /// A known union arm.
    Published(OperationReceipt),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for PublishOperationResponse {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Conflict(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("conflict".into()));
                object.insert(
                    "conflict".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Published(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("published".into()));
                object.insert(
                    "published".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 PublishOperationResponse {
    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 {
            "conflict" => Ok(Self::Conflict(
                serde_json::from_value(
                    value
                        .get("conflict")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "published" => Ok(Self::Published(
                serde_json::from_value(
                    value
                        .get("published")
                        .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 PublishOperationResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "conflict")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "conflict")]
            value: Strict<PublicationConflict>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "published")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "published")]
            value: Strict<OperationReceipt>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Conflict(Box<__Arm0>),
            Published(Box<__Arm1>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Conflict(arm) => Self::Conflict(arm.value.0),
            __Known::Published(arm) => Self::Published(arm.value.0),
        })
    }
}

/// Atomic entry-wise publication against a stable branch identity. baseCommitId must be an ancestor
/// of its current head. Compare only submitted domains, permitting disjoint changes since the base;
/// expectedHeadCommitId additionally requires an exact current head. Lists are required, may be
/// empty individually, and are bounded to 1000 entries each. At least one mutation or assertion is
/// required. Assertions participate in conflict checking; an assertion-only publication records a
/// commit. Messages are at most 16384 UTF-8 bytes. The service authenticates the actor, checks
/// state-read permission for assertions including absent resources, and checks resource-kind
/// mutation permissions for all mutated and bound identities.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PublishRequest {
    /// Contract field baseCommitId.
    #[serde(rename = "baseCommitId")]
    pub base_commit_id: CommitId,
    /// Contract field branchId.
    #[serde(rename = "branchId")]
    pub branch_id: BranchId,
    /// Contract field expectedHeadCommitId.
    #[serde(rename = "expectedHeadCommitId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expected_head_commit_id: Option<CommitId>,
    /// Contract field idempotencyKey.
    #[serde(rename = "idempotencyKey")]
    pub idempotency_key: IdempotencyKey,
    /// Contract field message.
    #[serde(rename = "message")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    /// Contract field namespace.
    #[serde(rename = "namespace")]
    pub namespace: Vec<NamespaceChange>,
    /// Contract field resources.
    #[serde(rename = "resources")]
    pub resources: Vec<ResourceChange>,
    /// Contract field transactionId.
    #[serde(rename = "transactionId")]
    pub transaction_id: TransactionId,
}
impl<'de> DeserializeStrict<'de> for PublishRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "baseCommitId")]
            base_commit_id: Strict<CommitId>,
            #[serde(rename = "branchId")]
            branch_id: Strict<BranchId>,
            #[serde(rename = "expectedHeadCommitId")]
            #[serde(default)]
            expected_head_commit_id: Strict<Option<CommitId>>,
            #[serde(rename = "idempotencyKey")]
            idempotency_key: Strict<IdempotencyKey>,
            #[serde(rename = "message")]
            #[serde(default)]
            message: Strict<Option<String>>,
            #[serde(rename = "namespace")]
            namespace: Strict<Vec<NamespaceChange>>,
            #[serde(rename = "resources")]
            resources: Strict<Vec<ResourceChange>>,
            #[serde(rename = "transactionId")]
            transaction_id: Strict<TransactionId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            base_commit_id: wire.base_commit_id.0,
            branch_id: wire.branch_id.0,
            expected_head_commit_id: wire.expected_head_commit_id.0,
            idempotency_key: wire.idempotency_key.0,
            message: wire.message.0,
            namespace: wire.namespace.0,
            resources: wire.resources.0,
            transaction_id: wire.transaction_id.0,
        })
    }
}

/// Expected compare-and-swap and namespace constraint conflicts are successful typed responses, not
/// transport errors.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum PublishResponse {
    /// A known union arm.
    Conflict(PublicationConflict),
    /// A known union arm.
    Published(Publication),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for PublishResponse {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Conflict(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("conflict".into()));
                object.insert(
                    "conflict".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Published(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("published".into()));
                object.insert(
                    "published".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 PublishResponse {
    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 {
            "conflict" => Ok(Self::Conflict(
                serde_json::from_value(
                    value
                        .get("conflict")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "published" => Ok(Self::Published(
                serde_json::from_value(
                    value
                        .get("published")
                        .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 PublishResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "conflict")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "conflict")]
            value: Strict<PublicationConflict>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "published")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "published")]
            value: Strict<Publication>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Conflict(Box<__Arm0>),
            Published(Box<__Arm1>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Conflict(arm) => Self::Conflict(arm.value.0),
            __Known::Published(arm) => Self::Published(arm.value.0),
        })
    }
}

/// Read and pin a live branch by name. Names are query values rather than path segments, so
/// slash-separated names need no catch-all routes.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ReadBranchRequest {
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: BranchName,
}
impl<'de> DeserializeStrict<'de> for ReadBranchRequest {
    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<BranchName>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self { name: wire.name.0 })
    }
}

/// starts is required and contains 1 through 1000 selectors. Absent exclusions means none;
/// exclusions are bounded to 1000. Selectors resolve once for this request. Traverse descendants
/// before ancestors, breaking generation ties by descending timestamp and commit identity. Excluded
/// commits and their ancestors are omitted. Results are bounded graph slices, not cursor pages. An
/// unprocessed frontier exceeding 1000 identities fails with CommitTraversalLimitExceeded rather
/// than discarding reachable history.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ReadCommitLogRequest {
    /// Contract field excludeAncestorsOf.
    #[serde(rename = "excludeAncestorsOf")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exclude_ancestors_of: Option<Vec<CommitSelector>>,
    /// Contract field maxCommits.
    #[serde(rename = "maxCommits")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_commits: Option<CommitLogLimit>,
    /// Contract field starts.
    #[serde(rename = "starts")]
    pub starts: Vec<CommitSelector>,
    /// Contract field traversal.
    #[serde(rename = "traversal")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub traversal: Option<GraphTraversal>,
}
impl<'de> DeserializeStrict<'de> for ReadCommitLogRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "excludeAncestorsOf")]
            #[serde(default)]
            exclude_ancestors_of: Strict<Option<Vec<CommitSelector>>>,
            #[serde(rename = "maxCommits")]
            #[serde(default)]
            max_commits: Strict<Option<CommitLogLimit>>,
            #[serde(rename = "starts")]
            starts: Strict<Vec<CommitSelector>>,
            #[serde(rename = "traversal")]
            #[serde(default)]
            traversal: Strict<Option<GraphTraversal>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            exclude_ancestors_of: wire.exclude_ancestors_of.0,
            max_commits: wire.max_commits.0,
            starts: wire.starts.0,
            traversal: wire.traversal.0,
        })
    }
}

/// Absent receipt means no completed operation was found, not a fence preventing late completion.
/// Internal trusted recovery/closure is outside this public API.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ReadOperationResponse {
    /// Contract field receipt.
    #[serde(rename = "receipt")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub receipt: Option<OperationReceipt>,
}
impl<'de> DeserializeStrict<'de> for ReadOperationResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "receipt")]
            #[serde(default)]
            receipt: Strict<Option<OperationReceipt>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            receipt: wire.receipt.0,
        })
    }
}

/// Read bounded event pages. Branch history follows its captured predecessor chain; project-wide
/// events use a live UUIDv7 cursor. An empty page with a continuation is not terminal.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ReadRefEventsRequest {
    /// Contract field pageSize.
    #[serde(rename = "pageSize")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_size: Option<PageSize>,
    /// Contract field pageToken.
    #[serde(rename = "pageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_token: Option<PageToken>,
}
impl<'de> DeserializeStrict<'de> for ReadRefEventsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "pageSize")]
            #[serde(default)]
            page_size: Strict<Option<PageSize>>,
            #[serde(rename = "pageToken")]
            #[serde(default)]
            page_token: Strict<Option<PageToken>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            page_size: wire.page_size.0,
            page_token: wire.page_token.0,
        })
    }
}

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

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

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

/// Recover whether a transaction published. notPublished is an observation and does not prevent a
/// still-running publication from completing later.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum RecoverPublicationResponse {
    /// A known union arm.
    NotPublished(Empty),
    /// A known union arm.
    Published(RecoveredPublication),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for RecoverPublicationResponse {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::NotPublished(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("notPublished".into()));
                object.insert(
                    "notPublished".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Published(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("published".into()));
                object.insert(
                    "published".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 RecoverPublicationResponse {
    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 {
            "notPublished" => Ok(Self::NotPublished(
                serde_json::from_value(
                    value
                        .get("notPublished")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "published" => Ok(Self::Published(
                serde_json::from_value(
                    value
                        .get("published")
                        .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 RecoverPublicationResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "notPublished")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "notPublished")]
            value: Strict<Empty>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "published")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "published")]
            value: Strict<RecoveredPublication>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            NotPublished(Box<__Arm0>),
            Published(Box<__Arm1>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::NotPublished(arm) => Self::NotPublished(arm.value.0),
            __Known::Published(arm) => Self::Published(arm.value.0),
        })
    }
}

/// Ordered parents retain merge and revert publication history.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RecoveredPublication {
    /// Contract field commitId.
    #[serde(rename = "commitId")]
    pub commit_id: CommitId,
    /// Contract field parentCommitIds.
    #[serde(rename = "parentCommitIds")]
    pub parent_commit_ids: Vec<CommitId>,
}
impl<'de> DeserializeStrict<'de> for RecoveredPublication {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "commitId")]
            commit_id: Strict<CommitId>,
            #[serde(rename = "parentCommitIds")]
            parent_commit_ids: Strict<Vec<CommitId>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            commit_id: wire.commit_id.0,
            parent_commit_ids: wire.parent_commit_ids.0,
        })
    }
}

/// Project-wide events in descending UUIDv7 identity order. This is a live traversal, not a
/// snapshot of committed events. Concurrent inserts below the cursor may appear on later pages;
/// inserts above it are not revisited.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RefEventPage {
    /// Contract field events.
    #[serde(rename = "events")]
    pub events: Vec<BranchEvent>,
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<PageToken>,
}
impl<'de> DeserializeStrict<'de> for RefEventPage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "events")]
            events: Strict<Vec<BranchEvent>>,
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<PageToken>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            events: wire.events.0,
            next_page_token: wire.next_page_token.0,
        })
    }
}

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

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

/// Resolved immutable identity for the supplied selector. Pin this commit for subsequent
/// multi-request reads.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResolveCommitResponse {
    /// Contract field commitId.
    #[serde(rename = "commitId")]
    pub commit_id: CommitId,
    /// Contract field selector.
    #[serde(rename = "selector")]
    pub selector: CommitSelector,
}
impl<'de> DeserializeStrict<'de> for ResolveCommitResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "commitId")]
            commit_id: Strict<CommitId>,
            #[serde(rename = "selector")]
            selector: Strict<CommitSelector>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            commit_id: wire.commit_id.0,
            selector: wire.selector.0,
        })
    }
}

/// Resolve one absolute path at the exact commit in the route. An absent binding returns no
/// resource, while an unknown commit is an error.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResolvePathRequest {
    /// Contract field path.
    #[serde(rename = "path")]
    pub path: NamespacePath,
}
impl<'de> DeserializeStrict<'de> for ResolvePathRequest {
    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<NamespacePath>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self { path: wire.path.0 })
    }
}

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

/// Resolve 1 through 1000 absolute paths at one immutable commit, retaining request order and
/// duplicate paths.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResolvePathsRequest {
    /// Contract field paths.
    #[serde(rename = "paths")]
    pub paths: Vec<NamespacePath>,
}
impl<'de> DeserializeStrict<'de> for ResolvePathsRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "paths")]
            paths: Strict<Vec<NamespacePath>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            paths: wire.paths.0,
        })
    }
}

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

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

/// ResolvedPath contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResolvedPath {
    /// Contract field path.
    #[serde(rename = "path")]
    pub path: NamespacePath,
    /// Contract field resource.
    #[serde(rename = "resource")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource: Option<ResourceState>,
}
impl<'de> DeserializeStrict<'de> for ResolvedPath {
    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<NamespacePath>,
            #[serde(rename = "resource")]
            #[serde(default)]
            resource: Strict<Option<ResourceState>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            path: wire.path.0,
            resource: wire.resource.0,
        })
    }
}

/// One submitted resource-map operation. A request must contain at most one entry for each resource
/// identity across all variants. Assertions participate in atomic conflict checking without
/// changing the resource map.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ResourceChange {
    /// A known union arm.
    Advance(AdvanceResourceChange),
    /// A known union arm.
    Assert(AssertResourceChange),
    /// A known union arm.
    Create(CreateResourceChange),
    /// A known union arm.
    Retire(RetireResourceChange),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for ResourceChange {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Advance(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("advance".into()));
                object.insert(
                    "advance".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Assert(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("assert".into()));
                object.insert(
                    "assert".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Create(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("create".into()));
                object.insert(
                    "create".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Retire(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("retire".into()));
                object.insert(
                    "retire".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 ResourceChange {
    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 {
            "advance" => Ok(Self::Advance(
                serde_json::from_value(
                    value
                        .get("advance")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "assert" => Ok(Self::Assert(
                serde_json::from_value(
                    value
                        .get("assert")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "create" => Ok(Self::Create(
                serde_json::from_value(
                    value
                        .get("create")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "retire" => Ok(Self::Retire(
                serde_json::from_value(
                    value
                        .get("retire")
                        .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 ResourceChange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "advance")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "advance")]
            value: Strict<AdvanceResourceChange>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "assert")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "assert")]
            value: Strict<AssertResourceChange>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "create")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "create")]
            value: Strict<CreateResourceChange>,
        }
        #[derive(Deserialize)]
        enum __Tag3 {
            #[serde(rename = "retire")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm3 {
            #[serde(rename = "type")]
            _tag: __Tag3,
            #[serde(rename = "retire")]
            value: Strict<RetireResourceChange>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Advance(Box<__Arm0>),
            Assert(Box<__Arm1>),
            Create(Box<__Arm2>),
            Retire(Box<__Arm3>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Advance(arm) => Self::Advance(arm.value.0),
            __Known::Assert(arm) => Self::Assert(arm.value.0),
            __Known::Create(arm) => Self::Create(arm.value.0),
            __Known::Retire(arm) => Self::Retire(arm.value.0),
        })
    }
}

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

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

/// Immutable registration metadata. namespaceRoot, when present, is an owning resource root
/// containing every binding. namespaceManaged declares producer-owned canonical bindings that
/// cannot be renamed, removed, or aliased. False must be supplied explicitly.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResourceDescriptor {
    /// Contract field kind.
    #[serde(rename = "kind")]
    pub kind: ResourceKind,
    /// Contract field namespaceManaged.
    #[serde(rename = "namespaceManaged")]
    pub namespace_managed: bool,
    /// Contract field namespaceRoot.
    #[serde(rename = "namespaceRoot")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub namespace_root: Option<ResourceId>,
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    pub resource_id: ResourceId,
    /// Contract field service.
    #[serde(rename = "service")]
    pub service: ResourceServiceId,
}
impl<'de> DeserializeStrict<'de> for ResourceDescriptor {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "kind")]
            kind: Strict<ResourceKind>,
            #[serde(rename = "namespaceManaged")]
            namespace_managed: Strict<bool>,
            #[serde(rename = "namespaceRoot")]
            #[serde(default)]
            namespace_root: Strict<Option<ResourceId>>,
            #[serde(rename = "resourceId")]
            resource_id: Strict<ResourceId>,
            #[serde(rename = "service")]
            service: Strict<ResourceServiceId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            kind: wire.kind.0,
            namespace_managed: wire.namespace_managed.0,
            namespace_root: wire.namespace_root.0,
            resource_id: wire.resource_id.0,
            service: wire.service.0,
        })
    }
}

/// Stable UUIDv4 identity allocated by a resource service.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ResourceId(pub Uuid);
impl std::fmt::Display for ResourceId {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for ResourceId {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<Uuid>::deserialize(deserializer)?.0))
    }
}

/// Opaque resource kind, at most 64 UTF-8 bytes. Catalog does not enumerate table engines, dataset
/// kinds, or future resource types.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ResourceKind(pub String);
impl std::fmt::Display for ResourceKind {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for ResourceKind {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
    }
}

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

/// Owning resource participant supplies a semantic replacement for these exact base, target, and
/// source versions. It does not resolve namespace conflicts or permit an arbitrary stale-head
/// overwrite.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResourceMergeResolution {
    /// Contract field base.
    #[serde(rename = "base")]
    pub base: VersionId,
    /// Contract field ours.
    #[serde(rename = "ours")]
    pub ours: VersionId,
    /// Contract field replacement.
    #[serde(rename = "replacement")]
    pub replacement: VersionId,
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    pub resource_id: ResourceId,
    /// Contract field theirs.
    #[serde(rename = "theirs")]
    pub theirs: VersionId,
}
impl<'de> DeserializeStrict<'de> for ResourceMergeResolution {
    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<VersionId>,
            #[serde(rename = "ours")]
            ours: Strict<VersionId>,
            #[serde(rename = "replacement")]
            replacement: Strict<VersionId>,
            #[serde(rename = "resourceId")]
            resource_id: Strict<ResourceId>,
            #[serde(rename = "theirs")]
            theirs: Strict<VersionId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            base: wire.base.0,
            ours: wire.ours.0,
            replacement: wire.replacement.0,
            resource_id: wire.resource_id.0,
            theirs: wire.theirs.0,
        })
    }
}

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

/// Opaque owning resource service identifier, at most 64 UTF-8 bytes.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ResourceServiceId(pub String);
impl std::fmt::Display for ResourceServiceId {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for ResourceServiceId {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
    }
}

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

/// Compare the live version with expected and retire the resource. Namespace constraints must
/// permit retirement.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RetireResourceChange {
    /// Contract field expected.
    #[serde(rename = "expected")]
    pub expected: VersionId,
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    pub resource_id: ResourceId,
}
impl<'de> DeserializeStrict<'de> for RetireResourceChange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "expected")]
            expected: Strict<VersionId>,
            #[serde(rename = "resourceId")]
            resource_id: Strict<ResourceId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            expected: wire.expected.0,
            resource_id: wire.resource_id.0,
        })
    }
}

/// RetiredTargetConstraint contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RetiredTargetConstraint {
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: NamespaceSegment,
    /// Contract field parent.
    #[serde(rename = "parent")]
    pub parent: NamespaceParent,
    /// Contract field resourceId.
    #[serde(rename = "resourceId")]
    pub resource_id: ResourceId,
}
impl<'de> DeserializeStrict<'de> for RetiredTargetConstraint {
    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<NamespaceSegment>,
            #[serde(rename = "parent")]
            parent: Strict<NamespaceParent>,
            #[serde(rename = "resourceId")]
            resource_id: Strict<ResourceId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            name: wire.name.0,
            parent: wire.parent.0,
            resource_id: wire.resource_id.0,
        })
    }
}

/// RevertConflict contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RevertConflict {
    /// Contract field constraints.
    #[serde(rename = "constraints")]
    pub constraints: Vec<NamespaceConstraintConflict>,
    /// Contract field currentCommitId.
    #[serde(rename = "currentCommitId")]
    pub current_commit_id: CommitId,
    /// Contract field namespace.
    #[serde(rename = "namespace")]
    pub namespace: Vec<NamespaceConflict>,
    /// Contract field resources.
    #[serde(rename = "resources")]
    pub resources: Vec<ResourceConflict>,
    /// Contract field revertedCommitId.
    #[serde(rename = "revertedCommitId")]
    pub reverted_commit_id: CommitId,
}
impl<'de> DeserializeStrict<'de> for RevertConflict {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "constraints")]
            constraints: Strict<Vec<NamespaceConstraintConflict>>,
            #[serde(rename = "currentCommitId")]
            current_commit_id: Strict<CommitId>,
            #[serde(rename = "namespace")]
            namespace: Strict<Vec<NamespaceConflict>>,
            #[serde(rename = "resources")]
            resources: Strict<Vec<ResourceConflict>>,
            #[serde(rename = "revertedCommitId")]
            reverted_commit_id: Strict<CommitId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            constraints: wire.constraints.0,
            current_commit_id: wire.current_commit_id.0,
            namespace: wire.namespace.0,
            resources: wire.resources.0,
            reverted_commit_id: wire.reverted_commit_id.0,
        })
    }
}

/// Apply the inverse delta of commitId to a current target branch. mainlineParent is one-based and
/// required for a merge commit. dryRun defaults to false. The original commit remains immutable;
/// publication creates a successor of the target head. Message and retry bounds match
/// PublishRequest.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RevertRequest {
    /// Contract field commitId.
    #[serde(rename = "commitId")]
    pub commit_id: CommitId,
    /// Contract field dryRun.
    #[serde(rename = "dryRun")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dry_run: Option<bool>,
    /// Contract field expectedTargetCommitId.
    #[serde(rename = "expectedTargetCommitId")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expected_target_commit_id: Option<CommitId>,
    /// Contract field idempotencyKey.
    #[serde(rename = "idempotencyKey")]
    pub idempotency_key: IdempotencyKey,
    /// Contract field mainlineParent.
    #[serde(rename = "mainlineParent")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mainline_parent: Option<u32>,
    /// Contract field message.
    #[serde(rename = "message")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    /// Contract field targetBranchId.
    #[serde(rename = "targetBranchId")]
    pub target_branch_id: BranchId,
    /// Contract field transactionId.
    #[serde(rename = "transactionId")]
    pub transaction_id: TransactionId,
}
impl<'de> DeserializeStrict<'de> for RevertRequest {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "commitId")]
            commit_id: Strict<CommitId>,
            #[serde(rename = "dryRun")]
            #[serde(default)]
            dry_run: Strict<Option<bool>>,
            #[serde(rename = "expectedTargetCommitId")]
            #[serde(default)]
            expected_target_commit_id: Strict<Option<CommitId>>,
            #[serde(rename = "idempotencyKey")]
            idempotency_key: Strict<IdempotencyKey>,
            #[serde(rename = "mainlineParent")]
            #[serde(default)]
            mainline_parent: Strict<Option<u32>>,
            #[serde(rename = "message")]
            #[serde(default)]
            message: Strict<Option<String>>,
            #[serde(rename = "targetBranchId")]
            target_branch_id: Strict<BranchId>,
            #[serde(rename = "transactionId")]
            transaction_id: Strict<TransactionId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            commit_id: wire.commit_id.0,
            dry_run: wire.dry_run.0,
            expected_target_commit_id: wire.expected_target_commit_id.0,
            idempotency_key: wire.idempotency_key.0,
            mainline_parent: wire.mainline_parent.0,
            message: wire.message.0,
            target_branch_id: wire.target_branch_id.0,
            transaction_id: wire.transaction_id.0,
        })
    }
}

/// RevertResponse contract value.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum RevertResponse {
    /// A known union arm.
    Conflict(RevertConflict),
    /// A known union arm.
    Published(Reverted),
    /// A known union arm.
    Revertible(Revertible),
    /// An unknown discriminator and its complete wire object.
    Unknown { tag: String, value: Value },
}
impl Serialize for RevertResponse {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Conflict(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("conflict".into()));
                object.insert(
                    "conflict".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Published(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("published".into()));
                object.insert(
                    "published".into(),
                    serde_json::to_value(value).map_err(serde::ser::Error::custom)?,
                );
                Value::Object(object).serialize(serializer)
            }
            Self::Revertible(value) => {
                let mut object = serde_json::Map::new();
                object.insert("type".into(), Value::String("revertible".into()));
                object.insert(
                    "revertible".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 RevertResponse {
    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 {
            "conflict" => Ok(Self::Conflict(
                serde_json::from_value(
                    value
                        .get("conflict")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "published" => Ok(Self::Published(
                serde_json::from_value(
                    value
                        .get("published")
                        .cloned()
                        .ok_or_else(|| serde::de::Error::custom("union requires matching arm"))?,
                )
                .map_err(serde::de::Error::custom)?,
            )),
            "revertible" => Ok(Self::Revertible(
                serde_json::from_value(
                    value
                        .get("revertible")
                        .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 RevertResponse {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        enum __Tag0 {
            #[serde(rename = "conflict")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm0 {
            #[serde(rename = "type")]
            _tag: __Tag0,
            #[serde(rename = "conflict")]
            value: Strict<RevertConflict>,
        }
        #[derive(Deserialize)]
        enum __Tag1 {
            #[serde(rename = "published")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm1 {
            #[serde(rename = "type")]
            _tag: __Tag1,
            #[serde(rename = "published")]
            value: Strict<Reverted>,
        }
        #[derive(Deserialize)]
        enum __Tag2 {
            #[serde(rename = "revertible")]
            Value,
        }
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Arm2 {
            #[serde(rename = "type")]
            _tag: __Tag2,
            #[serde(rename = "revertible")]
            value: Strict<Revertible>,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum __Known {
            Conflict(Box<__Arm0>),
            Published(Box<__Arm1>),
            Revertible(Box<__Arm2>),
        }
        Ok(match __Known::deserialize(deserializer)? {
            __Known::Conflict(arm) => Self::Conflict(arm.value.0),
            __Known::Published(arm) => Self::Published(arm.value.0),
            __Known::Revertible(arm) => Self::Revertible(arm.value.0),
        })
    }
}

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

/// Revertible contract value.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Revertible {
    /// Contract field namespaceChangeCount.
    #[serde(rename = "namespaceChangeCount")]
    pub namespace_change_count: u32,
    /// Contract field parentCommitId.
    #[serde(rename = "parentCommitId")]
    pub parent_commit_id: CommitId,
    /// Contract field resourceChangeCount.
    #[serde(rename = "resourceChangeCount")]
    pub resource_change_count: u32,
    /// Contract field revertedCommitId.
    #[serde(rename = "revertedCommitId")]
    pub reverted_commit_id: CommitId,
    /// Contract field targetCommitId.
    #[serde(rename = "targetCommitId")]
    pub target_commit_id: CommitId,
}
impl<'de> DeserializeStrict<'de> for Revertible {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "namespaceChangeCount")]
            namespace_change_count: Strict<u32>,
            #[serde(rename = "parentCommitId")]
            parent_commit_id: Strict<CommitId>,
            #[serde(rename = "resourceChangeCount")]
            resource_change_count: Strict<u32>,
            #[serde(rename = "revertedCommitId")]
            reverted_commit_id: Strict<CommitId>,
            #[serde(rename = "targetCommitId")]
            target_commit_id: Strict<CommitId>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            namespace_change_count: wire.namespace_change_count.0,
            parent_commit_id: wire.parent_commit_id.0,
            resource_change_count: wire.resource_change_count.0,
            reverted_commit_id: wire.reverted_commit_id.0,
            target_commit_id: wire.target_commit_id.0,
        })
    }
}

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

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

/// Immutable project state has two collections. Resource entries precede namespace entries in a
/// canonical traversal, ordered respectively by resource identity and canonical parent/name domain.
/// pageSize bounds the combined number of entries. Absence of nextPageToken terminates traversal;
/// pages may contain either or both collections. Only page iteration is generated, so neither
/// collection silently disappears.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct StatePage {
    /// Contract field commitId.
    #[serde(rename = "commitId")]
    pub commit_id: CommitId,
    /// Contract field namespace.
    #[serde(rename = "namespace")]
    pub namespace: Vec<StateNamespaceEntry>,
    /// Contract field nextPageToken.
    #[serde(rename = "nextPageToken")]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<PageToken>,
    /// Contract field resources.
    #[serde(rename = "resources")]
    pub resources: Vec<ResourceState>,
}
impl<'de> DeserializeStrict<'de> for StatePage {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "commitId")]
            commit_id: Strict<CommitId>,
            #[serde(rename = "namespace")]
            namespace: Strict<Vec<StateNamespaceEntry>>,
            #[serde(rename = "nextPageToken")]
            #[serde(default)]
            next_page_token: Strict<Option<PageToken>>,
            #[serde(rename = "resources")]
            resources: Strict<Vec<ResourceState>>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            commit_id: wire.commit_id.0,
            namespace: wire.namespace.0,
            next_page_token: wire.next_page_token.0,
            resources: wire.resources.0,
        })
    }
}

/// An immutable named commit reference; this API does not move, rename, or delete tags.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Tag {
    /// Contract field actor.
    #[serde(rename = "actor")]
    pub actor: ActorId,
    /// Contract field commitId.
    #[serde(rename = "commitId")]
    pub commit_id: CommitId,
    /// Contract field createdAtMicros.
    #[serde(rename = "createdAtMicros")]
    pub created_at_micros: SafeLong,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: TagName,
}
impl<'de> DeserializeStrict<'de> for Tag {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "actor")]
            actor: Strict<ActorId>,
            #[serde(rename = "commitId")]
            commit_id: Strict<CommitId>,
            #[serde(rename = "createdAtMicros")]
            created_at_micros: Strict<SafeLong>,
            #[serde(rename = "name")]
            name: Strict<TagName>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            actor: wire.actor.0,
            commit_id: wire.commit_id.0,
            created_at_micros: wire.created_at_micros.0,
            name: wire.name.0,
        })
    }
}

/// Immutable tag name with the same syntax and bounds as BranchName.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct TagName(pub String);
impl std::fmt::Display for TagName {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for TagName {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<String>::deserialize(deserializer)?.0))
    }
}

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

/// Caller-allocated UUIDv7 publication identity used to recover an uncertain result within a
/// project and authenticated actor scope.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct TransactionId(pub Uuid);
impl std::fmt::Display for TransactionId {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for TransactionId {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<Uuid>::deserialize(deserializer)?.0))
    }
}

/// Compare and remove a concrete binding.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct UnbindNamespaceChange {
    /// Contract field expected.
    #[serde(rename = "expected")]
    pub expected: ResourceId,
    /// Contract field name.
    #[serde(rename = "name")]
    pub name: NamespaceSegment,
    /// Contract field parent.
    #[serde(rename = "parent")]
    pub parent: NamespaceParent,
}
impl<'de> DeserializeStrict<'de> for UnbindNamespaceChange {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct __Wire {
            #[serde(rename = "expected")]
            expected: Strict<ResourceId>,
            #[serde(rename = "name")]
            name: Strict<NamespaceSegment>,
            #[serde(rename = "parent")]
            parent: Strict<NamespaceParent>,
        }
        let wire = __Wire::deserialize(deserializer)?;
        Ok(Self {
            expected: wire.expected.0,
            name: wire.name.0,
            parent: wire.parent.0,
        })
    }
}

/// Immutable UUIDv7 resource version allocated by its owning service.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct VersionId(pub Uuid);
impl std::fmt::Display for VersionId {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(formatter)
    }
}
impl<'de> DeserializeStrict<'de> for VersionId {
    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        Ok(Self(Strict::<Uuid>::deserialize(deserializer)?.0))
    }
}

/// Typed errors declared by this service contract.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CatalogError {
    /// Catalog:AmbiguousMergeBase.
    AmbiguousMergeBase { count: u32 },
    /// Catalog:BranchNotFound.
    BranchNotFound { branch: String },
    /// Catalog:CatalogLimitExceeded.
    CatalogLimitExceeded {
        maximum_entries: SafeUnsignedLong,
        namespace_count: SafeUnsignedLong,
        resource_count: SafeUnsignedLong,
    },
    /// Catalog:CommitNotFound.
    CommitNotFound { commit_id: String },
    /// Catalog:CommitTraversalLimitExceeded.
    CommitTraversalLimitExceeded { maximum_commits: SafeUnsignedLong },
    /// Catalog:IdempotencyKeyReused.
    IdempotencyKeyReused {},
    /// Catalog:InvalidArgument.
    InvalidArgument { reason: String },
    /// Catalog:InvalidPageToken.
    InvalidPageToken { reason: String },
    /// Catalog:NameConflict.
    NameConflict { name: String },
    /// Catalog:NotFound.
    NotFound { resource: String },
    /// Catalog:OperationInputMismatch.
    OperationInputMismatch { operation_id: String },
    /// Catalog:ResourceNotFound.
    ResourceNotFound { resource_id: String },
    /// Catalog:StaleHead.
    StaleHead { current: String, expected: String },
    /// Catalog:TagNotFound.
    TagNotFound { tag: String },
    /// Catalog:TransactionBaseNotAncestor.
    TransactionBaseNotAncestor { base: String, head: String },
}
impl CatalogError {
    /// HTTP status for this declared error.
    pub fn status(&self) -> u16 {
        match self {
            Self::AmbiguousMergeBase { .. } => 412,
            Self::BranchNotFound { .. } => 404,
            Self::CatalogLimitExceeded { .. } => 412,
            Self::CommitNotFound { .. } => 404,
            Self::CommitTraversalLimitExceeded { .. } => 412,
            Self::IdempotencyKeyReused { .. } => 409,
            Self::InvalidArgument { .. } => 400,
            Self::InvalidPageToken { .. } => 400,
            Self::NameConflict { .. } => 409,
            Self::NotFound { .. } => 404,
            Self::OperationInputMismatch { .. } => 409,
            Self::ResourceNotFound { .. } => 404,
            Self::StaleHead { .. } => 409,
            Self::TagNotFound { .. } => 404,
            Self::TransactionBaseNotAncestor { .. } => 412,
        }
    }
    /// Serialize only contract-declared error parameters.
    pub fn envelope(&self, instance: String) -> ErrorEnvelope {
        match self {
            Self::AmbiguousMergeBase { count } => {
                let mut envelope = ErrorEnvelope::new(
                    "FAILED_PRECONDITION",
                    "Catalog:AmbiguousMergeBase",
                    instance,
                );
                envelope
                    .parameters
                    .insert("count".into(), count.to_string());
                envelope
            }
            Self::BranchNotFound { branch } => {
                let mut envelope =
                    ErrorEnvelope::new("NOT_FOUND", "Catalog:BranchNotFound", instance);
                envelope
                    .parameters
                    .insert("branch".into(), branch.to_string());
                envelope
            }
            Self::CatalogLimitExceeded {
                maximum_entries,
                namespace_count,
                resource_count,
            } => {
                let mut envelope = ErrorEnvelope::new(
                    "FAILED_PRECONDITION",
                    "Catalog:CatalogLimitExceeded",
                    instance,
                );
                envelope
                    .parameters
                    .insert("maximumEntries".into(), maximum_entries.to_string());
                envelope
                    .parameters
                    .insert("namespaceCount".into(), namespace_count.to_string());
                envelope
                    .parameters
                    .insert("resourceCount".into(), resource_count.to_string());
                envelope
            }
            Self::CommitNotFound { commit_id } => {
                let mut envelope =
                    ErrorEnvelope::new("NOT_FOUND", "Catalog:CommitNotFound", instance);
                envelope
                    .parameters
                    .insert("commitId".into(), commit_id.to_string());
                envelope
            }
            Self::CommitTraversalLimitExceeded { maximum_commits } => {
                let mut envelope = ErrorEnvelope::new(
                    "FAILED_PRECONDITION",
                    "Catalog:CommitTraversalLimitExceeded",
                    instance,
                );
                envelope
                    .parameters
                    .insert("maximumCommits".into(), maximum_commits.to_string());
                envelope
            }
            Self::IdempotencyKeyReused {} => {
                ErrorEnvelope::new("CONFLICT", "Catalog:IdempotencyKeyReused", instance)
            }
            Self::InvalidArgument { reason } => {
                let mut envelope =
                    ErrorEnvelope::new("INVALID_ARGUMENT", "Catalog:InvalidArgument", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::InvalidPageToken { reason } => {
                let mut envelope =
                    ErrorEnvelope::new("INVALID_ARGUMENT", "Catalog:InvalidPageToken", instance);
                envelope
                    .parameters
                    .insert("reason".into(), reason.to_string());
                envelope
            }
            Self::NameConflict { name } => {
                let mut envelope = ErrorEnvelope::new("CONFLICT", "Catalog:NameConflict", instance);
                envelope.parameters.insert("name".into(), name.to_string());
                envelope
            }
            Self::NotFound { resource } => {
                let mut envelope = ErrorEnvelope::new("NOT_FOUND", "Catalog:NotFound", instance);
                envelope
                    .parameters
                    .insert("resource".into(), resource.to_string());
                envelope
            }
            Self::OperationInputMismatch { operation_id } => {
                let mut envelope =
                    ErrorEnvelope::new("CONFLICT", "Catalog:OperationInputMismatch", instance);
                envelope
                    .parameters
                    .insert("operationId".into(), operation_id.to_string());
                envelope
            }
            Self::ResourceNotFound { resource_id } => {
                let mut envelope =
                    ErrorEnvelope::new("NOT_FOUND", "Catalog:ResourceNotFound", instance);
                envelope
                    .parameters
                    .insert("resourceId".into(), resource_id.to_string());
                envelope
            }
            Self::StaleHead { current, expected } => {
                let mut envelope = ErrorEnvelope::new("CONFLICT", "Catalog:StaleHead", instance);
                envelope
                    .parameters
                    .insert("current".into(), current.to_string());
                envelope
                    .parameters
                    .insert("expected".into(), expected.to_string());
                envelope
            }
            Self::TagNotFound { tag } => {
                let mut envelope = ErrorEnvelope::new("NOT_FOUND", "Catalog:TagNotFound", instance);
                envelope.parameters.insert("tag".into(), tag.to_string());
                envelope
            }
            Self::TransactionBaseNotAncestor { base, head } => {
                let mut envelope = ErrorEnvelope::new(
                    "FAILED_PRECONDITION",
                    "Catalog:TransactionBaseNotAncestor",
                    instance,
                );
                envelope.parameters.insert("base".into(), base.to_string());
                envelope.parameters.insert("head".into(), head.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() {
            "Catalog:AmbiguousMergeBase" => {
                if envelope.error_code != "FAILED_PRECONDITION" {
                    return None;
                }
                let count = envelope.parameters.get("count")?.parse::<u32>().ok()?;
                Some(Self::AmbiguousMergeBase { count })
            }
            "Catalog:BranchNotFound" => {
                if envelope.error_code != "NOT_FOUND" {
                    return None;
                }
                let branch = envelope.parameters.get("branch")?.clone();
                Some(Self::BranchNotFound { branch })
            }
            "Catalog:CatalogLimitExceeded" => {
                if envelope.error_code != "FAILED_PRECONDITION" {
                    return None;
                }
                let maximum_entries = envelope
                    .parameters
                    .get("maximumEntries")?
                    .parse::<SafeUnsignedLong>()
                    .ok()?;
                let namespace_count = envelope
                    .parameters
                    .get("namespaceCount")?
                    .parse::<SafeUnsignedLong>()
                    .ok()?;
                let resource_count = envelope
                    .parameters
                    .get("resourceCount")?
                    .parse::<SafeUnsignedLong>()
                    .ok()?;
                Some(Self::CatalogLimitExceeded {
                    maximum_entries,
                    namespace_count,
                    resource_count,
                })
            }
            "Catalog:CommitNotFound" => {
                if envelope.error_code != "NOT_FOUND" {
                    return None;
                }
                let commit_id = envelope.parameters.get("commitId")?.clone();
                Some(Self::CommitNotFound { commit_id })
            }
            "Catalog:CommitTraversalLimitExceeded" => {
                if envelope.error_code != "FAILED_PRECONDITION" {
                    return None;
                }
                let maximum_commits = envelope
                    .parameters
                    .get("maximumCommits")?
                    .parse::<SafeUnsignedLong>()
                    .ok()?;
                Some(Self::CommitTraversalLimitExceeded { maximum_commits })
            }
            "Catalog:IdempotencyKeyReused" => {
                if envelope.error_code != "CONFLICT" {
                    return None;
                }
                Some(Self::IdempotencyKeyReused {})
            }
            "Catalog:InvalidArgument" => {
                if envelope.error_code != "INVALID_ARGUMENT" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::InvalidArgument { reason })
            }
            "Catalog:InvalidPageToken" => {
                if envelope.error_code != "INVALID_ARGUMENT" {
                    return None;
                }
                let reason = envelope.parameters.get("reason")?.clone();
                Some(Self::InvalidPageToken { reason })
            }
            "Catalog:NameConflict" => {
                if envelope.error_code != "CONFLICT" {
                    return None;
                }
                let name = envelope.parameters.get("name")?.clone();
                Some(Self::NameConflict { name })
            }
            "Catalog:NotFound" => {
                if envelope.error_code != "NOT_FOUND" {
                    return None;
                }
                let resource = envelope.parameters.get("resource")?.clone();
                Some(Self::NotFound { resource })
            }
            "Catalog:OperationInputMismatch" => {
                if envelope.error_code != "CONFLICT" {
                    return None;
                }
                let operation_id = envelope.parameters.get("operationId")?.clone();
                Some(Self::OperationInputMismatch { operation_id })
            }
            "Catalog:ResourceNotFound" => {
                if envelope.error_code != "NOT_FOUND" {
                    return None;
                }
                let resource_id = envelope.parameters.get("resourceId")?.clone();
                Some(Self::ResourceNotFound { resource_id })
            }
            "Catalog:StaleHead" => {
                if envelope.error_code != "CONFLICT" {
                    return None;
                }
                let current = envelope.parameters.get("current")?.clone();
                let expected = envelope.parameters.get("expected")?.clone();
                Some(Self::StaleHead { current, expected })
            }
            "Catalog:TagNotFound" => {
                if envelope.error_code != "NOT_FOUND" {
                    return None;
                }
                let tag = envelope.parameters.get("tag")?.clone();
                Some(Self::TagNotFound { tag })
            }
            "Catalog:TransactionBaseNotAncestor" => {
                if envelope.error_code != "FAILED_PRECONDITION" {
                    return None;
                }
                let base = envelope.parameters.get("base")?.clone();
                let head = envelope.parameters.get("head")?.clone();
                Some(Self::TransactionBaseNotAncestor { base, head })
            }
            _ => None,
        }
    }
}
impl Display for CatalogError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::AmbiguousMergeBase { count } => {
                write!(formatter, "Catalog:AmbiguousMergeBase (count: {})", count)
            }
            Self::BranchNotFound { branch } => {
                write!(formatter, "Catalog:BranchNotFound (branch: {})", branch)
            }
            Self::CatalogLimitExceeded {
                maximum_entries,
                namespace_count,
                resource_count,
            } => write!(
                formatter,
                "Catalog:CatalogLimitExceeded (maximumEntries: {}, namespaceCount: {}, resourceCount: {})",
                maximum_entries, namespace_count, resource_count
            ),
            Self::CommitNotFound { commit_id } => write!(
                formatter,
                "Catalog:CommitNotFound (commitId: {})",
                commit_id
            ),
            Self::CommitTraversalLimitExceeded { maximum_commits } => write!(
                formatter,
                "Catalog:CommitTraversalLimitExceeded (maximumCommits: {})",
                maximum_commits
            ),
            Self::IdempotencyKeyReused {} => formatter.write_str("Catalog:IdempotencyKeyReused"),
            Self::InvalidArgument { reason } => {
                write!(formatter, "Catalog:InvalidArgument (reason: {})", reason)
            }
            Self::InvalidPageToken { reason } => {
                write!(formatter, "Catalog:InvalidPageToken (reason: {})", reason)
            }
            Self::NameConflict { name } => {
                write!(formatter, "Catalog:NameConflict (name: {})", name)
            }
            Self::NotFound { resource } => {
                write!(formatter, "Catalog:NotFound (resource: {})", resource)
            }
            Self::OperationInputMismatch { operation_id } => write!(
                formatter,
                "Catalog:OperationInputMismatch (operationId: {})",
                operation_id
            ),
            Self::ResourceNotFound { resource_id } => write!(
                formatter,
                "Catalog:ResourceNotFound (resourceId: {})",
                resource_id
            ),
            Self::StaleHead { current, expected } => write!(
                formatter,
                "Catalog:StaleHead (current: {}, expected: {})",
                current, expected
            ),
            Self::TagNotFound { tag } => write!(formatter, "Catalog:TagNotFound (tag: {})", tag),
            Self::TransactionBaseNotAncestor { base, head } => write!(
                formatter,
                "Catalog:TransactionBaseNotAncestor (base: {}, head: {})",
                base, head
            ),
        }
    }
}
impl StdError for CatalogError {}
impl ServiceError for CatalogError {
    fn to_envelope(&self, instance: String) -> ErrorEnvelope {
        Self::envelope(self, instance)
    }
    fn from_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
        Self::decode_envelope(envelope)
    }
}
#[automatically_derived]
impl Default for ListBranchesRequest {
    fn default() -> Self {
        Self {
            include_deleted: None,
            page_size: None,
            page_token: None,
        }
    }
}
#[automatically_derived]
impl Default for ListTagsRequest {
    fn default() -> Self {
        Self {
            page_size: None,
            page_token: None,
        }
    }
}
#[automatically_derived]
impl Default for ReadRefEventsRequest {
    fn default() -> Self {
        Self {
            page_size: None,
            page_token: None,
        }
    }
}
#[automatically_derived]
impl Default for ReadStateRequest {
    fn default() -> Self {
        Self {
            page_size: None,
            page_token: None,
        }
    }
}