// Copyright (c) 2026 CoReason, Inc
// Licensed under the Prosperity Public License 3.0
// https://github.com/CoReason-AI/coreason-manifest
//
// AUTO-GENERATED — DO NOT EDIT. Regenerate via:
//   uv run python scripts/generate_cross_language_bindings.py

#![allow(non_snake_case)]
#![allow(non_camel_case_types)]
#![allow(clippy::redundant_closure_call)]
#![allow(clippy::needless_lifetimes)]
#![allow(clippy::match_single_binding)]
#![allow(clippy::clone_on_copy)]

#[doc = r" Error types."]
pub mod error {
    #[doc = r" Error from a `TryFrom` or `FromStr` implementation."]
    pub struct ConversionError(::std::borrow::Cow<'static, str>);
    impl ::std::error::Error for ConversionError {}
    impl ::std::fmt::Display for ConversionError {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
            ::std::fmt::Display::fmt(&self.0, f)
        }
    }
    impl ::std::fmt::Debug for ConversionError {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
            ::std::fmt::Debug::fmt(&self.0, f)
        }
    }
    impl From<&'static str> for ConversionError {
        fn from(value: &'static str) -> Self {
            Self(value.into())
        }
    }
    impl From<String> for ConversionError {
        fn from(value: String) -> Self {
            Self(value.into())
        }
    }
}
#[doc = "The rigid silicon precision format required to execute this node's neural circuits."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Accelerator Type\","]
#[doc = "  \"description\": \"The rigid silicon precision format required to execute this node's neural circuits.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AcceleratorType(::std::string::String);
impl ::std::ops::Deref for AcceleratorType {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AcceleratorType> for ::std::string::String {
    fn from(value: AcceleratorType) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AcceleratorType {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^urn:coreason:.*$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^urn:coreason:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AcceleratorType {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AcceleratorType {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AcceleratorType {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AcceleratorType {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SHA-256 hash of the accessibility tree defining Exogenous Perturbations to the state space."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Accessibility Tree Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the accessibility tree defining Exogenous Perturbations to the state space.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AccessibilityTreeHash(::std::string::String);
impl ::std::ops::Deref for AccessibilityTreeHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AccessibilityTreeHash> for ::std::string::String {
    fn from(value: AccessibilityTreeHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AccessibilityTreeHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AccessibilityTreeHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AccessibilityTreeHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AccessibilityTreeHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AccessibilityTreeHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The specific kinematic interaction paradigm."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Action Class\","]
#[doc = "  \"description\": \"The specific kinematic interaction paradigm.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"click\","]
#[doc = "    \"double_click\","]
#[doc = "    \"drag_and_drop\","]
#[doc = "    \"scroll\","]
#[doc = "    \"hover\","]
#[doc = "    \"keystroke\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ActionClass {
    #[serde(rename = "click")]
    Click,
    #[serde(rename = "double_click")]
    DoubleClick,
    #[serde(rename = "drag_and_drop")]
    DragAndDrop,
    #[serde(rename = "scroll")]
    Scroll,
    #[serde(rename = "hover")]
    Hover,
    #[serde(rename = "keystroke")]
    Keystroke,
}
impl ::std::fmt::Display for ActionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Click => f.write_str("click"),
            Self::DoubleClick => f.write_str("double_click"),
            Self::DragAndDrop => f.write_str("drag_and_drop"),
            Self::Scroll => f.write_str("scroll"),
            Self::Hover => f.write_str("hover"),
            Self::Keystroke => f.write_str("keystroke"),
        }
    }
}
impl ::std::str::FromStr for ActionClass {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "click" => Ok(Self::Click),
            "double_click" => Ok(Self::DoubleClick),
            "drag_and_drop" => Ok(Self::DragAndDrop),
            "scroll" => Ok(Self::Scroll),
            "hover" => Ok(Self::Hover),
            "keystroke" => Ok(Self::Keystroke),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ActionClass {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ActionClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ActionClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The action to take when an epistemic gap is detected."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Action On Gap\","]
#[doc = "  \"description\": \"The action to take when an epistemic gap is detected.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"fail\","]
#[doc = "    \"probe\","]
#[doc = "    \"clarify\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ActionOnGap {
    #[serde(rename = "fail")]
    Fail,
    #[serde(rename = "probe")]
    Probe,
    #[serde(rename = "clarify")]
    Clarify,
}
impl ::std::fmt::Display for ActionOnGap {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Fail => f.write_str("fail"),
            Self::Probe => f.write_str("probe"),
            Self::Clarify => f.write_str("clarify"),
        }
    }
}
impl ::std::str::FromStr for ActionOnGap {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "fail" => Ok(Self::Fail),
            "probe" => Ok(Self::Probe),
            "clarify" => Ok(Self::Clarify),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ActionOnGap {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ActionOnGap {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ActionOnGap {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The deterministic action the orchestrator must take if a firewall rule is violated."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Action On Violation\","]
#[doc = "  \"description\": \"The deterministic action the orchestrator must take if a firewall rule is violated.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"drop\","]
#[doc = "    \"quarantine\","]
#[doc = "    \"redact\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ActionOnViolation {
    #[serde(rename = "drop")]
    Drop,
    #[serde(rename = "quarantine")]
    Quarantine,
    #[serde(rename = "redact")]
    Redact,
}
impl ::std::fmt::Display for ActionOnViolation {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Drop => f.write_str("drop"),
            Self::Quarantine => f.write_str("quarantine"),
            Self::Redact => f.write_str("redact"),
        }
    }
}
impl ::std::str::FromStr for ActionOnViolation {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "drop" => Ok(Self::Drop),
            "quarantine" => Ok(Self::Quarantine),
            "redact" => Ok(Self::Redact),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ActionOnViolation {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ActionOnViolation {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ActionOnViolation {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The unique identifier for this curated environment of tools."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Action Space Cid\","]
#[doc = "  \"description\": \"The unique identifier for this curated environment of tools.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ActionSpaceCid(::std::string::String);
impl ::std::ops::Deref for ActionSpaceCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ActionSpaceCid> for ::std::string::String {
    fn from(value: ActionSpaceCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ActionSpaceCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ActionSpaceCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ActionSpaceCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ActionSpaceCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ActionSpaceCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes a hardware-level Representation Engineering (RepE) directive to mechanically manipulate latent dimensions via forward-pass tensor injection. Execution of this policy is strictly delegated to the external `TransformerLens` substrate to preserve the Hollow Data Plane constraints.\n\nCAUSAL AFFORDANCE: Physically forces an additive, ablation, or clamping operation onto the model's residual stream at specific `target_hook_points`, steering the generator away from unstable hallucination geometries prior to token projection.\n\nEPISTEMIC BOUNDS: Cryptographically locked by `steering_vector_hash` (SHA-256 pattern `^[a-f0-9]{64}$`). `scaling_factor` is bounded above (`le=100.0`) but unbounded below, permitting negative magnitudes for ablation. The `@model_validator` deterministically sorts `target_hook_points`.\n\nMCP ROUTING TRIGGERS: Representation Engineering, RepE, Activation Steering, Residual Stream Ablation, Concept Vectors, TransformerLens, SAELens"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ActivationSteeringContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes a hardware-level Representation Engineering (RepE) directive to mechanically manipulate latent dimensions via forward-pass tensor injection. Execution of this policy is strictly delegated to the external `TransformerLens` substrate to preserve the Hollow Data Plane constraints.\\n\\nCAUSAL AFFORDANCE: Physically forces an additive, ablation, or clamping operation onto the model's residual stream at specific `target_hook_points`, steering the generator away from unstable hallucination geometries prior to token projection.\\n\\nEPISTEMIC BOUNDS: Cryptographically locked by `steering_vector_hash` (SHA-256 pattern `^[a-f0-9]{64}$`). `scaling_factor` is bounded above (`le=100.0`) but unbounded below, permitting negative magnitudes for ablation. The `@model_validator` deterministically sorts `target_hook_points`.\\n\\nMCP ROUTING TRIGGERS: Representation Engineering, RepE, Activation Steering, Residual Stream Ablation, Concept Vectors, TransformerLens, SAELens\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"scaling_factor\","]
#[doc = "    \"steering_vector_hash\","]
#[doc = "    \"target_hook_points\","]
#[doc = "    \"vector_modality\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"scaling_factor\": {"]
#[doc = "      \"title\": \"Scaling Factor\","]
#[doc = "      \"description\": \"The mathematical magnitude/strength of the injection (can be negative for ablation).\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 100.0"]
#[doc = "    },"]
#[doc = "    \"steering_vector_hash\": {"]
#[doc = "      \"title\": \"Steering Vector Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the extracted RepE control tensor (e.g., the 'caution' vector).\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"target_hook_points\": {"]
#[doc = "      \"title\": \"Target Hook Points\","]
#[doc = "      \"description\": \"The specific TransformerLens hook points (e.g., 'blocks.12.hook_resid_post') where this vector must be applied.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 256,"]
#[doc = "        \"minLength\": 1,"]
#[doc = "        \"pattern\": \"^[a-zA-Z0-9_.]+$\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"vector_modality\": {"]
#[doc = "      \"title\": \"Vector Modality\","]
#[doc = "      \"description\": \"The tensor operation to perform: add the vector, subtract it, or clamp activations to its bounds.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"additive\","]
#[doc = "        \"ablation\","]
#[doc = "        \"clamping\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ActivationSteeringContract {
    #[doc = "The mathematical magnitude/strength of the injection (can be negative for ablation)."]
    pub scaling_factor: f64,
    #[doc = "The SHA-256 hash of the extracted RepE control tensor (e.g., the 'caution' vector)."]
    pub steering_vector_hash: SteeringVectorHash,
    #[doc = "The specific TransformerLens hook points (e.g., 'blocks.12.hook_resid_post') where this vector must be applied."]
    pub target_hook_points: ::std::vec::Vec<TargetHookPointsItem>,
    #[doc = "The tensor operation to perform: add the vector, subtract it, or clamp activations to its bounds."]
    pub vector_modality: VectorModality,
}
impl ActivationSteeringContract {
    pub fn builder() -> builder::ActivationSteeringContract {
        Default::default()
    }
}
#[doc = "A pointer to the CapabilityForgeTopologyManifest currently executing."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Active Forge Cid\","]
#[doc = "  \"description\": \"A pointer to the CapabilityForgeTopologyManifest currently executing.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ActiveForgeCid(::std::string::String);
impl ::std::ops::Deref for ActiveForgeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ActiveForgeCid> for ::std::string::String {
    fn from(value: ActiveForgeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ActiveForgeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ActiveForgeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ActiveForgeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ActiveForgeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ActiveForgeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the formal Fristonian Active Inference policy for an autonomous agent, mandating the minimization of Expected Free Energy through targeted epistemic foraging. As a ...Contract suffix, this object defines rigid mathematical boundaries.\n\nCAUSAL AFFORDANCE: Unlocks kinetic tool execution strictly for the purpose of empirical observation, routing compute to maximize epistemic certainty (Shannon Information Gain) regarding a specific hypothesis to collapse the probability wave.\n\nEPISTEMIC BOUNDS: Mathematically constrained by expected_information_gain (a continuous float bounded between ge=0.0 and le=1.0 representing Shannon entropy reduction) and an economic execution_cost_budget_magnitude cap (ge=0, le=18446744073709551615) to prevent thermodynamic runaway.\n\nMCP ROUTING TRIGGERS: Active Inference, Expected Free Energy, Epistemic Foraging, Fristonian Mechanics, Shannon Entropy Reduction"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ActiveInferenceContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the formal Fristonian Active Inference policy for an autonomous agent, mandating the minimization of Expected Free Energy through targeted epistemic foraging. As a ...Contract suffix, this object defines rigid mathematical boundaries.\\n\\nCAUSAL AFFORDANCE: Unlocks kinetic tool execution strictly for the purpose of empirical observation, routing compute to maximize epistemic certainty (Shannon Information Gain) regarding a specific hypothesis to collapse the probability wave.\\n\\nEPISTEMIC BOUNDS: Mathematically constrained by expected_information_gain (a continuous float bounded between ge=0.0 and le=1.0 representing Shannon entropy reduction) and an economic execution_cost_budget_magnitude cap (ge=0, le=18446744073709551615) to prevent thermodynamic runaway.\\n\\nMCP ROUTING TRIGGERS: Active Inference, Expected Free Energy, Epistemic Foraging, Fristonian Mechanics, Shannon Entropy Reduction\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"execution_cost_budget_magnitude\","]
#[doc = "    \"expected_information_gain\","]
#[doc = "    \"selected_tool_name\","]
#[doc = "    \"target_condition_cid\","]
#[doc = "    \"target_hypothesis_cid\","]
#[doc = "    \"task_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"execution_cost_budget_magnitude\": {"]
#[doc = "      \"title\": \"Execution Cost Budget Magnitude\","]
#[doc = "      \"description\": \"The maximum economic expenditure authorized to run this specific scientific test.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"expected_information_gain\": {"]
#[doc = "      \"title\": \"Expected Information Gain\","]
#[doc = "      \"description\": \"The mathematically estimated reduction in Epistemic Uncertainty (entropy) this tool call will yield.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"selected_tool_name\": {"]
#[doc = "      \"title\": \"Selected Tool Name\","]
#[doc = "      \"description\": \"The exact tool from the CognitiveActionSpaceManifest allocated for this experiment.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"target_condition_cid\": {"]
#[doc = "      \"title\": \"Target Condition Cid\","]
#[doc = "      \"description\": \"The specific FalsificationContract being tested.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_hypothesis_cid\": {"]
#[doc = "      \"title\": \"Target Hypothesis Cid\","]
#[doc = "      \"description\": \"The HypothesisGenerationEvent this task is attempting to falsify.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"task_cid\": {"]
#[doc = "      \"title\": \"Task Cid\","]
#[doc = "      \"description\": \"Unique identifier for this active inference execution.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ActiveInferenceContract {
    #[doc = "The maximum economic expenditure authorized to run this specific scientific test."]
    pub execution_cost_budget_magnitude: u64,
    #[doc = "The mathematically estimated reduction in Epistemic Uncertainty (entropy) this tool call will yield."]
    pub expected_information_gain: f64,
    #[doc = "The exact tool from the CognitiveActionSpaceManifest allocated for this experiment."]
    pub selected_tool_name: SelectedToolName,
    #[doc = "The specific FalsificationContract being tested."]
    pub target_condition_cid: TargetConditionCid,
    #[doc = "The HypothesisGenerationEvent this task is attempting to falsify."]
    pub target_hypothesis_cid: TargetHypothesisCid,
    #[doc = "Unique identifier for this active inference execution."]
    pub task_cid: TaskCid,
}
impl ActiveInferenceContract {
    pub fn builder() -> builder::ActiveInferenceContract {
        Default::default()
    }
}
#[doc = "The physical contravariant type string encountered at the structural fracture point."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Actual Type Geometry\","]
#[doc = "  \"description\": \"The physical contravariant type string encountered at the structural fracture point.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ActualTypeGeometry(::std::string::String);
impl ::std::ops::Deref for ActualTypeGeometry {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ActualTypeGeometry> for ::std::string::String {
    fn from(value: ActualTypeGeometry) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ActualTypeGeometry {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ActualTypeGeometry {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ActualTypeGeometry {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ActualTypeGeometry {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ActualTypeGeometry {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Unique identifier for the requested LoRA adapter."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Adapter Cid\","]
#[doc = "  \"description\": \"Unique identifier for the requested LoRA adapter.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AdapterCid(::std::string::String);
impl ::std::ops::Deref for AdapterCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AdapterCid> for ::std::string::String {
    fn from(value: AdapterCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AdapterCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AdapterCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AdapterCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AdapterCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AdapterCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Social Choice Theory to resolve the Condorcet Paradox. Triggers a Mixed-Initiative forced resolution to break an epistemic deadlock within a Council topology.\n\nCAUSAL AFFORDANCE: Halts the active execution DAG and forces an external oracle (human or system) to act as a Dictatorial tie-breaker, definitively collapsing the probability wave of competing claims in a Multi-Criteria Decision Analysis (MCDA) framework.\n\nEPISTEMIC BOUNDS: The state space is bounded by `deadlocked_claims` (`min_length=2, max_length=86400000`). The `resolution_schema` is mathematically bounded against recursive JSON-bombing by the `enforce_payload_topology` hook, physically preventing Automata Intersection deadlocks.\n\nMCP ROUTING TRIGGERS: Social Choice Theory, Condorcet Paradox, MCDA Deadlock, Dictatorial Resolution, Tie-Breaking Heuristic"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AdjudicationIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Social Choice Theory to resolve the Condorcet Paradox. Triggers a Mixed-Initiative forced resolution to break an epistemic deadlock within a Council topology.\\n\\nCAUSAL AFFORDANCE: Halts the active execution DAG and forces an external oracle (human or system) to act as a Dictatorial tie-breaker, definitively collapsing the probability wave of competing claims in a Multi-Criteria Decision Analysis (MCDA) framework.\\n\\nEPISTEMIC BOUNDS: The state space is bounded by `deadlocked_claims` (`min_length=2, max_length=86400000`). The `resolution_schema` is mathematically bounded against recursive JSON-bombing by the `enforce_payload_topology` hook, physically preventing Automata Intersection deadlocks.\\n\\nMCP ROUTING TRIGGERS: Social Choice Theory, Condorcet Paradox, MCDA Deadlock, Dictatorial Resolution, Tie-Breaking Heuristic\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"deadlocked_claims\","]
#[doc = "    \"resolution_schema\","]
#[doc = "    \"timeout_action\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"deadlocked_claims\": {"]
#[doc = "      \"title\": \"Deadlocked Claims\","]
#[doc = "      \"description\": \"The conflicting claim IDs or proposals the human must choose between.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 86400000,"]
#[doc = "      \"minItems\": 2"]
#[doc = "    },"]
#[doc = "    \"resolution_schema\": {"]
#[doc = "      \"title\": \"Resolution Schema\","]
#[doc = "      \"description\": \"The strict JSON Schema for the tie-breaking response (usually an enum of the deadlocked_claims).\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"timeout_action\": {"]
#[doc = "      \"title\": \"Timeout Action\","]
#[doc = "      \"description\": \"The action to take if the oracle is unresponsive.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"rollback\","]
#[doc = "        \"proceed_default\","]
#[doc = "        \"terminate\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for breaking deadlocks within a CouncilTopologyManifest.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"forced_adjudication\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AdjudicationIntent {
    #[doc = "The conflicting claim IDs or proposals the human must choose between."]
    pub deadlocked_claims: ::std::vec::Vec<DeadlockedClaimsItem>,
    #[doc = "The strict JSON Schema for the tie-breaking response (usually an enum of the deadlocked_claims)."]
    pub resolution_schema: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "The action to take if the oracle is unresponsive."]
    pub timeout_action: TimeoutAction,
    #[doc = "Discriminator for breaking deadlocks within a CouncilTopologyManifest."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl AdjudicationIntent {
    pub fn builder() -> builder::AdjudicationIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the\ndefinitive collapse of an MCDA evaluation, acting as a verified Outcome Reward Model\n(ORM) signal. As a ...Receipt suffix, this is an append-only coordinate on the\nMerkle-DAG.\n\nCAUSAL AFFORDANCE: Commits the calculated score and boolean passed verdict to the\nEpistemic Ledger, permanently binding the deterministic evaluation to the specific\ntarget_node_cid (NodeCIDState) and authorizing downstream policy updates.\n\nEPISTEMIC BOUNDS: The evaluation outcome is strictly bounded to an integer score\n(ge=0, le=100). The underlying deductive proof (reasoning) is physically capped at\nmax_length=2000. The entire receipt is cryptographically locked to the originating\nrubric_cid CID (128-char regex).\n\nMCP ROUTING TRIGGERS: Cryptographic Verdict, Deterministic Proof, Grading Execution,\nEpistemic Commitment, Audit Trail"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AdjudicationReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the\\ndefinitive collapse of an MCDA evaluation, acting as a verified Outcome Reward Model\\n(ORM) signal. As a ...Receipt suffix, this is an append-only coordinate on the\\nMerkle-DAG.\\n\\nCAUSAL AFFORDANCE: Commits the calculated score and boolean passed verdict to the\\nEpistemic Ledger, permanently binding the deterministic evaluation to the specific\\ntarget_node_cid (NodeCIDState) and authorizing downstream policy updates.\\n\\nEPISTEMIC BOUNDS: The evaluation outcome is strictly bounded to an integer score\\n(ge=0, le=100). The underlying deductive proof (reasoning) is physically capped at\\nmax_length=2000. The entire receipt is cryptographically locked to the originating\\nrubric_cid CID (128-char regex).\\n\\nMCP ROUTING TRIGGERS: Cryptographic Verdict, Deterministic Proof, Grading Execution,\\nEpistemic Commitment, Audit Trail\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"passed\","]
#[doc = "    \"reasoning\","]
#[doc = "    \"rubric_cid\","]
#[doc = "    \"score\","]
#[doc = "    \"target_node_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"passed\": {"]
#[doc = "      \"title\": \"Passed\","]
#[doc = "      \"description\": \"Indicates whether the evaluation passed the threshold.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"reasoning\": {"]
#[doc = "      \"title\": \"Reasoning\","]
#[doc = "      \"description\": \"The deterministic logical proof justifying the final verdict and mathematical score.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"rubric_cid\": {"]
#[doc = "      \"title\": \"Rubric Cid\","]
#[doc = "      \"description\": \"The cryptographic pointer to the rubric dictating adjudication.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"score\": {"]
#[doc = "      \"title\": \"Score\","]
#[doc = "      \"description\": \"The final score assigned based on the rubric.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 100.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"description\": \"The deterministic capability pointer representing the node that was evaluated.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"adjudication_receipt\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AdjudicationReceipt {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "Indicates whether the evaluation passed the threshold."]
    pub passed: bool,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The deterministic logical proof justifying the final verdict and mathematical score."]
    pub reasoning: Reasoning,
    #[doc = "The cryptographic pointer to the rubric dictating adjudication."]
    pub rubric_cid: RubricCid,
    #[doc = "The final score assigned based on the rubric."]
    pub score: i64,
    #[doc = "The deterministic capability pointer representing the node that was evaluated."]
    pub target_node_cid: NodeCidState,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl AdjudicationReceipt {
    pub fn builder() -> builder::AdjudicationReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes an Aggregation Function for Multi-Criteria Decision\nAnalysis (MCDA), compiling multiple utility dimensions into a definitive evaluation\nboundary for the swarm. As a ...Profile suffix, this defines a rigid mathematical\nboundary.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator's verification engine on how to\ncalculate the total weighted score of a generated trajectory, triggering a\ndeterministic boolean pass/fail gate based on the aggregate sum.\n\nEPISTEMIC BOUNDS: The success condition is mathematically locked by passing_threshold\n(ge=0.0, le=100.0). The rubric_cid is a 128-char CID anchor. The @model_validator\nsort_arrays deterministically sorts the criteria array by criterion_cid, guaranteeing\ninvariant RFC 8785 canonical hashing.\n\nMCP ROUTING TRIGGERS: Evaluation Manifold, Threshold Gating, Deterministic Rubric,\nRFC 8785 Canonicalization, Binary State Transition"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AdjudicationRubricProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes an Aggregation Function for Multi-Criteria Decision\\nAnalysis (MCDA), compiling multiple utility dimensions into a definitive evaluation\\nboundary for the swarm. As a ...Profile suffix, this defines a rigid mathematical\\nboundary.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator's verification engine on how to\\ncalculate the total weighted score of a generated trajectory, triggering a\\ndeterministic boolean pass/fail gate based on the aggregate sum.\\n\\nEPISTEMIC BOUNDS: The success condition is mathematically locked by passing_threshold\\n(ge=0.0, le=100.0). The rubric_cid is a 128-char CID anchor. The @model_validator\\nsort_arrays deterministically sorts the criteria array by criterion_cid, guaranteeing\\ninvariant RFC 8785 canonical hashing.\\n\\nMCP ROUTING TRIGGERS: Evaluation Manifold, Threshold Gating, Deterministic Rubric,\\nRFC 8785 Canonicalization, Binary State Transition\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"criteria\","]
#[doc = "    \"passing_threshold\","]
#[doc = "    \"rubric_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"criteria\": {"]
#[doc = "      \"title\": \"Criteria\","]
#[doc = "      \"description\": \"The explicit array of strict evaluation criteria defining the rubric.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/GradingCriterionProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"passing_threshold\": {"]
#[doc = "      \"title\": \"Passing Threshold\","]
#[doc = "      \"description\": \"The absolute mathematical lower-bound scalar required to authorize execution.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 100.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"rubric_cid\": {"]
#[doc = "      \"title\": \"Rubric Cid\","]
#[doc = "      \"description\": \"Unique identifier for the rubric.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AdjudicationRubricProfile {
    #[doc = "The explicit array of strict evaluation criteria defining the rubric."]
    pub criteria: ::std::vec::Vec<GradingCriterionProfile>,
    #[doc = "The absolute mathematical lower-bound scalar required to authorize execution."]
    pub passing_threshold: f64,
    #[doc = "Unique identifier for the rubric."]
    pub rubric_cid: RubricCid,
}
impl AdjudicationRubricProfile {
    pub fn builder() -> builder::AdjudicationRubricProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A Zero-Cost Macro abstraction that mathematically projects a Zero-Sum Minimax game into a rigid Red/Blue team CouncilTopologyManifest. As a ...Manifest suffix, this defines a frozen coordinate of a topological structure.\n\nCAUSAL AFFORDANCE: Deterministically compiles into a fully bounded Council topology, forcing the generative router to evaluate claims through adversarial debate before the orchestrator resolves equilibrium via the designated market rules.\n\nEPISTEMIC BOUNDS: The @model_validator verify_disjoint_sets mathematically guarantees that blue_team_cids, red_team_cids, and the adjudicator_cid are strictly disjoint to prevent self-dealing or topological paradoxes. Arrays are deterministically sorted to preserve RFC 8785 canonical hashes.\n\nMCP ROUTING TRIGGERS: Zero-Sum Minimax Game, Red Team vs Blue Team, Macro Abstraction, Generative Adversarial Networks, Topological Compilation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AdversarialMarketTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A Zero-Cost Macro abstraction that mathematically projects a Zero-Sum Minimax game into a rigid Red/Blue team CouncilTopologyManifest. As a ...Manifest suffix, this defines a frozen coordinate of a topological structure.\\n\\nCAUSAL AFFORDANCE: Deterministically compiles into a fully bounded Council topology, forcing the generative router to evaluate claims through adversarial debate before the orchestrator resolves equilibrium via the designated market rules.\\n\\nEPISTEMIC BOUNDS: The @model_validator verify_disjoint_sets mathematically guarantees that blue_team_cids, red_team_cids, and the adjudicator_cid are strictly disjoint to prevent self-dealing or topological paradoxes. Arrays are deterministically sorted to preserve RFC 8785 canonical hashes.\\n\\nMCP ROUTING TRIGGERS: Zero-Sum Minimax Game, Red Team vs Blue Team, Macro Abstraction, Generative Adversarial Networks, Topological Compilation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"adjudicator_cid\","]
#[doc = "    \"blue_team_cids\","]
#[doc = "    \"market_rules\","]
#[doc = "    \"red_team_cids\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"adjudicator_cid\": {"]
#[doc = "      \"description\": \"The neutral node responsible for synthesizing the market resolution.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"blue_team_cids\": {"]
#[doc = "      \"title\": \"Blue Team Cids\","]
#[doc = "      \"description\": \"Nodes assigned to the Blue Team.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"market_rules\": {"]
#[doc = "      \"description\": \"The mathematical AMM rules for the debate.\","]
#[doc = "      \"$ref\": \"#/$defs/PredictionMarketPolicy\""]
#[doc = "    },"]
#[doc = "    \"red_team_cids\": {"]
#[doc = "      \"title\": \"Red Team Cids\","]
#[doc = "      \"description\": \"Nodes assigned to the Red Team.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for adversarial macro.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"macro_adversarial\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AdversarialMarketTopologyManifest {
    #[doc = "The neutral node responsible for synthesizing the market resolution."]
    pub adjudicator_cid: NodeCidState,
    #[doc = "Nodes assigned to the Blue Team."]
    pub blue_team_cids: ::std::vec::Vec<NodeCidState>,
    #[doc = "The mathematical AMM rules for the debate."]
    pub market_rules: PredictionMarketPolicy,
    #[doc = "Nodes assigned to the Red Team."]
    pub red_team_cids: ::std::vec::Vec<NodeCidState>,
    #[doc = "Discriminator for adversarial macro."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl AdversarialMarketTopologyManifest {
    pub fn builder() -> builder::AdversarialMarketTopologyManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Serves as the definitive Artificial Intelligence Bill of Materials (AI-BOM), mapping the agent's exact training provenance and capability matrix onto the Merkle-DAG.\n\nCAUSAL AFFORDANCE: Establishes the agent's physical identity passport, authorizing the orchestrator to mount the node into a swarm topology only if its `training_lineage_hash` satisfies the zero-trust alignment policy.\n\nEPISTEMIC BOUNDS: Supply-chain vulnerabilities are mathematically severed by anchoring `training_lineage_hash` and `capability_merkle_root` to immutable SHA-256 bounds (`^[a-f0-9]{64}$`). The `@model_validator` deterministically sorts `credential_presentations` by `issuer_did` for RFC 8785 canonical hashing.\n\nMCP ROUTING TRIGGERS: AI-BOM, Merkle-DAG Provenance, Supply-Chain Security, Cryptographic Passport, Deterministic Sorting"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AgentAttestationReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Serves as the definitive Artificial Intelligence Bill of Materials (AI-BOM), mapping the agent's exact training provenance and capability matrix onto the Merkle-DAG.\\n\\nCAUSAL AFFORDANCE: Establishes the agent's physical identity passport, authorizing the orchestrator to mount the node into a swarm topology only if its `training_lineage_hash` satisfies the zero-trust alignment policy.\\n\\nEPISTEMIC BOUNDS: Supply-chain vulnerabilities are mathematically severed by anchoring `training_lineage_hash` and `capability_merkle_root` to immutable SHA-256 bounds (`^[a-f0-9]{64}$`). The `@model_validator` deterministically sorts `credential_presentations` by `issuer_did` for RFC 8785 canonical hashing.\\n\\nMCP ROUTING TRIGGERS: AI-BOM, Merkle-DAG Provenance, Supply-Chain Security, Cryptographic Passport, Deterministic Sorting\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"capability_merkle_root\","]
#[doc = "    \"developer_signature\","]
#[doc = "    \"training_lineage_hash\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"capability_merkle_root\": {"]
#[doc = "      \"title\": \"Capability Merkle Root\","]
#[doc = "      \"description\": \"The SHA-256 Merkle root of the agent's verified semantic capabilities.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"credential_presentations\": {"]
#[doc = "      \"title\": \"Credential Presentations\","]
#[doc = "      \"description\": \"The wallet of selective disclosure credentials proving the agent's identity, clearance, and budget authorization.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/VerifiableCredentialPresentationReceipt\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"developer_signature\": {"]
#[doc = "      \"title\": \"Developer Signature\","]
#[doc = "      \"description\": \"The cryptographic signature of the developer/vendor.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"training_lineage_hash\": {"]
#[doc = "      \"title\": \"Training Lineage Hash\","]
#[doc = "      \"description\": \"The exact SHA-256 Merkle root of the agent's training lineage.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AgentAttestationReceipt {
    #[doc = "The SHA-256 Merkle root of the agent's verified semantic capabilities."]
    pub capability_merkle_root: CapabilityMerkleRoot,
    #[doc = "The wallet of selective disclosure credentials proving the agent's identity, clearance, and budget authorization."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub credential_presentations: ::std::vec::Vec<VerifiableCredentialPresentationReceipt>,
    #[doc = "The cryptographic signature of the developer/vendor."]
    pub developer_signature: DeveloperSignature,
    #[doc = "The exact SHA-256 Merkle root of the agent's training lineage."]
    pub training_lineage_hash: TrainingLineageHash,
}
impl AgentAttestationReceipt {
    pub fn builder() -> builder::AgentAttestationReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents a probabilistic agentic bid in a multi-objective optimization market, factoring in projected compute latency, carbon constraints, and internal epistemic certainty.\n\nCAUSAL AFFORDANCE: Injects a competitive trajectory into the AuctionState order book, seeking authorization from the orchestrator to execute a specific TaskAnnouncementIntent branch.\n\nEPISTEMIC BOUNDS: Geometrically bounded by `estimated_cost_magnitude` (`le=18446744073709551615`), `estimated_latency_ms` (`le=18446744073709551615, ge=0`), `estimated_carbon_gco2eq` (`le=18446744073709551615.0, ge=0.0`), and `confidence_score` (`ge=0.0, le=1.0`). `agent_cid` is a 128-char CID.\n\nMCP ROUTING TRIGGERS: Expected Utility Theory, Multi-Objective Optimization, Epistemic Certainty, Spot Market Bid, Cost Estimation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AgentBidIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents a probabilistic agentic bid in a multi-objective optimization market, factoring in projected compute latency, carbon constraints, and internal epistemic certainty.\\n\\nCAUSAL AFFORDANCE: Injects a competitive trajectory into the AuctionState order book, seeking authorization from the orchestrator to execute a specific TaskAnnouncementIntent branch.\\n\\nEPISTEMIC BOUNDS: Geometrically bounded by `estimated_cost_magnitude` (`le=18446744073709551615`), `estimated_latency_ms` (`le=18446744073709551615, ge=0`), `estimated_carbon_gco2eq` (`le=18446744073709551615.0, ge=0.0`), and `confidence_score` (`ge=0.0, le=1.0`). `agent_cid` is a 128-char CID.\\n\\nMCP ROUTING TRIGGERS: Expected Utility Theory, Multi-Objective Optimization, Epistemic Certainty, Spot Market Bid, Cost Estimation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"agent_cid\","]
#[doc = "    \"confidence_score\","]
#[doc = "    \"estimated_carbon_gco2eq\","]
#[doc = "    \"estimated_cost_magnitude\","]
#[doc = "    \"estimated_latency_ms\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"agent_cid\": {"]
#[doc = "      \"title\": \"Agent Cid\","]
#[doc = "      \"description\": \"The NodeCIDState of the bidder.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"confidence_score\": {"]
#[doc = "      \"title\": \"Confidence Score\","]
#[doc = "      \"description\": \"The node's epistemic certainty of success.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"estimated_carbon_gco2eq\": {"]
#[doc = "      \"title\": \"Estimated Carbon Gco2Eq\","]
#[doc = "      \"description\": \"The agent's mathematical projection of the environmental cost to execute this inference task.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"estimated_cost_magnitude\": {"]
#[doc = "      \"title\": \"Estimated Cost Magnitude\","]
#[doc = "      \"description\": \"The node's calculated cost to fulfill the task.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"estimated_latency_ms\": {"]
#[doc = "      \"title\": \"Estimated Latency Ms\","]
#[doc = "      \"description\": \"The node's estimated time to completion.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The discriminative topological boundary for agent bid intents.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"agent_bid\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AgentBidIntent {
    #[doc = "The NodeCIDState of the bidder."]
    pub agent_cid: AgentCid,
    #[doc = "The node's epistemic certainty of success."]
    pub confidence_score: f64,
    #[doc = "The agent's mathematical projection of the environmental cost to execute this inference task."]
    pub estimated_carbon_gco2eq: f64,
    #[doc = "The node's calculated cost to fulfill the task."]
    pub estimated_cost_magnitude: u64,
    #[doc = "The node's estimated time to completion."]
    pub estimated_latency_ms: u64,
    #[doc = "The discriminative topological boundary for agent bid intents."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl AgentBidIntent {
    pub fn builder() -> builder::AgentBidIntent {
        Default::default()
    }
}
#[doc = "The NodeCIDState of the bidder."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Agent Cid\","]
#[doc = "  \"description\": \"The NodeCIDState of the bidder.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AgentCid(::std::string::String);
impl ::std::ops::Deref for AgentCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AgentCid> for ::std::string::String {
    fn from(value: AgentCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AgentCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AgentCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AgentCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AgentCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AgentCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`AgentRole`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Agent Role\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"generator\","]
#[doc = "    \"critic\","]
#[doc = "    \"synthesizer\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum AgentRole {
    #[serde(rename = "generator")]
    Generator,
    #[serde(rename = "critic")]
    Critic,
    #[serde(rename = "synthesizer")]
    Synthesizer,
}
impl ::std::fmt::Display for AgentRole {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Generator => f.write_str("generator"),
            Self::Critic => f.write_str("critic"),
            Self::Synthesizer => f.write_str("synthesizer"),
        }
    }
}
impl ::std::str::FromStr for AgentRole {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "generator" => Ok(Self::Generator),
            "critic" => Ok(Self::Critic),
            "synthesizer" => Ok(Self::Synthesizer),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for AgentRole {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AgentRole {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AgentRole {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The mathematical operator applying to the value."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Algebraic Operator\","]
#[doc = "  \"description\": \"The mathematical operator applying to the value.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"eq\","]
#[doc = "    \"lt\","]
#[doc = "    \"le\","]
#[doc = "    \"gt\","]
#[doc = "    \"ge\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum AlgebraicOperator {
    #[serde(rename = "eq")]
    Eq,
    #[serde(rename = "lt")]
    Lt,
    #[serde(rename = "le")]
    Le,
    #[serde(rename = "gt")]
    Gt,
    #[serde(rename = "ge")]
    Ge,
}
impl ::std::fmt::Display for AlgebraicOperator {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Eq => f.write_str("eq"),
            Self::Lt => f.write_str("lt"),
            Self::Le => f.write_str("le"),
            Self::Gt => f.write_str("gt"),
            Self::Ge => f.write_str("ge"),
        }
    }
}
impl ::std::str::FromStr for AlgebraicOperator {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "eq" => Ok(Self::Eq),
            "lt" => Ok(Self::Lt),
            "le" => Ok(Self::Le),
            "gt" => Ok(Self::Gt),
            "ge" => Ok(Self::Ge),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for AlgebraicOperator {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AlgebraicOperator {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AlgebraicOperator {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Mathematically bounds a specific target property using strict Liquid Type (Refinement Type) declarations.\n\n    CAUSAL AFFORDANCE: Establishes a definitive algebraic constraint against an instantiated variable, forcing the formal verifier to evaluate conditions mathematically prior to downstream deployment.\n\n    EPISTEMIC BOUNDS: Bounding variables and mathematical predicates are rigidly clamped to a maximum string geometry of 2000 characters to prevent polynomial regex execution attacks.\n\n    MCP ROUTING TRIGGERS: Liquid Types, Refinement Types, Algebraic Constraint, Mathematical Predicate, Bounded Property"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AlgebraicRefinementContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Mathematically bounds a specific target property using strict Liquid Type (Refinement Type) declarations.\\n\\n    CAUSAL AFFORDANCE: Establishes a definitive algebraic constraint against an instantiated variable, forcing the formal verifier to evaluate conditions mathematically prior to downstream deployment.\\n\\n    EPISTEMIC BOUNDS: Bounding variables and mathematical predicates are rigidly clamped to a maximum string geometry of 2000 characters to prevent polynomial regex execution attacks.\\n\\n    MCP ROUTING TRIGGERS: Liquid Types, Refinement Types, Algebraic Constraint, Mathematical Predicate, Bounded Property\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"mathematical_predicate\","]
#[doc = "    \"target_property\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"mathematical_predicate\": {"]
#[doc = "      \"title\": \"Mathematical Predicate\","]
#[doc = "      \"description\": \"The formal algebraic representation vector utilized to define physical bounds (e.g., x > 0 and x < 100).\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"target_property\": {"]
#[doc = "      \"title\": \"Target Property\","]
#[doc = "      \"description\": \"The specific localized node schema key undergoing rigorous mathematical bounding.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AlgebraicRefinementContract {
    #[doc = "The formal algebraic representation vector utilized to define physical bounds (e.g., x > 0 and x < 100)."]
    pub mathematical_predicate: MathematicalPredicate,
    #[doc = "The specific localized node schema key undergoing rigorous mathematical bounding."]
    pub target_property: TargetProperty,
}
impl AlgebraicRefinementContract {
    pub fn builder() -> builder::AlgebraicRefinementContract {
        Default::default()
    }
}
#[doc = "`AllowedCausalRelationshipsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"causes\","]
#[doc = "    \"confounds\","]
#[doc = "    \"correlates_with\","]
#[doc = "    \"undirected\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum AllowedCausalRelationshipsItem {
    #[serde(rename = "causes")]
    Causes,
    #[serde(rename = "confounds")]
    Confounds,
    #[serde(rename = "correlates_with")]
    CorrelatesWith,
    #[serde(rename = "undirected")]
    Undirected,
}
impl ::std::fmt::Display for AllowedCausalRelationshipsItem {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Causes => f.write_str("causes"),
            Self::Confounds => f.write_str("confounds"),
            Self::CorrelatesWith => f.write_str("correlates_with"),
            Self::Undirected => f.write_str("undirected"),
        }
    }
}
impl ::std::str::FromStr for AllowedCausalRelationshipsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "causes" => Ok(Self::Causes),
            "confounds" => Ok(Self::Confounds),
            "correlates_with" => Ok(Self::CorrelatesWith),
            "undirected" => Ok(Self::Undirected),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for AllowedCausalRelationshipsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AllowedCausalRelationshipsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AllowedCausalRelationshipsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`AllowedEvidenceDomainsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AllowedEvidenceDomainsItem(::std::string::String);
impl ::std::ops::Deref for AllowedEvidenceDomainsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AllowedEvidenceDomainsItem> for ::std::string::String {
    fn from(value: AllowedEvidenceDomainsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AllowedEvidenceDomainsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AllowedEvidenceDomainsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AllowedEvidenceDomainsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AllowedEvidenceDomainsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AllowedEvidenceDomainsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`AllowedFieldsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AllowedFieldsItem(::std::string::String);
impl ::std::ops::Deref for AllowedFieldsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AllowedFieldsItem> for ::std::string::String {
    fn from(value: AllowedFieldsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AllowedFieldsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AllowedFieldsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AllowedFieldsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AllowedFieldsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AllowedFieldsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`AllowedPassiveToolsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AllowedPassiveToolsItem(::std::string::String);
impl ::std::ops::Deref for AllowedPassiveToolsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AllowedPassiveToolsItem> for ::std::string::String {
    fn from(value: AllowedPassiveToolsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AllowedPassiveToolsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AllowedPassiveToolsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AllowedPassiveToolsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AllowedPassiveToolsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AllowedPassiveToolsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`AllowedPromptsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AllowedPromptsItem(::std::string::String);
impl ::std::ops::Deref for AllowedPromptsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AllowedPromptsItem> for ::std::string::String {
    fn from(value: AllowedPromptsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AllowedPromptsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AllowedPromptsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AllowedPromptsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AllowedPromptsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AllowedPromptsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`AllowedResourcesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AllowedResourcesItem(::std::string::String);
impl ::std::ops::Deref for AllowedResourcesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AllowedResourcesItem> for ::std::string::String {
    fn from(value: AllowedResourcesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AllowedResourcesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AllowedResourcesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AllowedResourcesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AllowedResourcesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AllowedResourcesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`AllowedVaultKeysItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AllowedVaultKeysItem(::std::string::String);
impl ::std::ops::Deref for AllowedVaultKeysItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AllowedVaultKeysItem> for ::std::string::String {
    fn from(value: AllowedVaultKeysItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AllowedVaultKeysItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AllowedVaultKeysItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AllowedVaultKeysItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AllowedVaultKeysItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AllowedVaultKeysItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Acts as a unidirectional telemetry pipeline projecting internal swarm kinematics across the Markov Blanket without inducing causal feedback loops.\n\nCAUSAL AFFORDANCE: Emits an ephemeral, 1D representation of the active probability distribution and execution progress to the external UI plane without halting the underlying generative trajectory.\n\nEPISTEMIC BOUNDS: Semantic `status_message` structurally clamped to `max_length=2000`. The continuous `progress` metric bounded by float limits (`le=18446744073709551615.0`) allowing it to represent 0.0-1.0 ratios or exact token counts. The `thermodynamic_burn_rate` is physically bounded (`ge=0.0`), and `epistemic_entropy_score` is normalized (`ge=0.0, le=1.0`).\n\nMCP ROUTING TRIGGERS: Markov Blanket, Ephemeral Projection, Continuous Observability, Kinetic Execution State, UI Telemetry"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AmbientState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Acts as a unidirectional telemetry pipeline projecting internal swarm kinematics across the Markov Blanket without inducing causal feedback loops.\\n\\nCAUSAL AFFORDANCE: Emits an ephemeral, 1D representation of the active probability distribution and execution progress to the external UI plane without halting the underlying generative trajectory.\\n\\nEPISTEMIC BOUNDS: Semantic `status_message` structurally clamped to `max_length=2000`. The continuous `progress` metric bounded by float limits (`le=18446744073709551615.0`) allowing it to represent 0.0-1.0 ratios or exact token counts. The `thermodynamic_burn_rate` is physically bounded (`ge=0.0`), and `epistemic_entropy_score` is normalized (`ge=0.0, le=1.0`).\\n\\nMCP ROUTING TRIGGERS: Markov Blanket, Ephemeral Projection, Continuous Observability, Kinetic Execution State, UI Telemetry\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"status_message\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"epistemic_entropy_score\": {"]
#[doc = "      \"title\": \"Epistemic Entropy Score\","]
#[doc = "      \"description\": \"The normalized Shannon Entropy of the active execution, mapped to UI color gradients (e.g., high entropy = amber warning).\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.0,"]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"progress\": {"]
#[doc = "      \"title\": \"Progress\","]
#[doc = "      \"description\": \"The progress ratio from 0.0 to 1.0, or None if indeterminate.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"status_message\": {"]
#[doc = "      \"title\": \"Status Message\","]
#[doc = "      \"description\": \"The semantic 1D string projection representing the active kinetic execution state.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"thermodynamic_burn_rate\": {"]
#[doc = "      \"title\": \"Thermodynamic Burn Rate\","]
#[doc = "      \"description\": \"The instantaneous token compute cost velocity, mapped to UI emission intensity.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AmbientState {
    #[doc = "The normalized Shannon Entropy of the active execution, mapped to UI color gradients (e.g., high entropy = amber warning)."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_entropy_score: ::std::option::Option<f64>,
    #[doc = "The progress ratio from 0.0 to 1.0, or None if indeterminate."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub progress: ::std::option::Option<f64>,
    #[doc = "The semantic 1D string projection representing the active kinetic execution state."]
    pub status_message: StatusMessage,
    #[doc = "The instantaneous token compute cost velocity, mapped to UI emission intensity."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub thermodynamic_burn_rate: ::std::option::Option<f64>,
}
impl AmbientState {
    pub fn builder() -> builder::AmbientState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AnalogicalMappingTask\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"divergence_temperature_override\","]
#[doc = "    \"required_isomorphisms\","]
#[doc = "    \"source_domain\","]
#[doc = "    \"target_domain\","]
#[doc = "    \"task_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"divergence_temperature_override\": {"]
#[doc = "      \"title\": \"Divergence Temperature Override\","]
#[doc = "      \"description\": \"The specific high-temperature sampling override required to force this creative leap.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 10.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"required_isomorphisms\": {"]
#[doc = "      \"title\": \"Required Isomorphisms\","]
#[doc = "      \"description\": \"The exact number of structural/logical mappings the agent must successfully bridge between the two domains.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"source_domain\": {"]
#[doc = "      \"title\": \"Source Domain\","]
#[doc = "      \"description\": \"The unrelated abstract concept space (e.g., 'thermodynamics', 'mycelial networks').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"target_domain\": {"]
#[doc = "      \"title\": \"Target Domain\","]
#[doc = "      \"description\": \"The actual problem space currently being solved.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"task_cid\": {"]
#[doc = "      \"title\": \"Task Cid\","]
#[doc = "      \"description\": \"Unique identifier for this lateral thinking task.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"analogical_mapping_task\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AnalogicalMappingTask {
    #[doc = "The specific high-temperature sampling override required to force this creative leap."]
    pub divergence_temperature_override: f64,
    #[doc = "The exact number of structural/logical mappings the agent must successfully bridge between the two domains."]
    pub required_isomorphisms: ::std::num::NonZeroU64,
    #[doc = "The unrelated abstract concept space (e.g., 'thermodynamics', 'mycelial networks')."]
    pub source_domain: SourceDomain,
    #[doc = "The actual problem space currently being solved."]
    pub target_domain: TargetDomain,
    #[doc = "Unique identifier for this lateral thinking task."]
    pub task_cid: TaskCid,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl AnalogicalMappingTask {
    pub fn builder() -> builder::AnalogicalMappingTask {
        Default::default()
    }
}
#[doc = "The undeniable SHA-256 hash of the core objective."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Anchor Prompt Hash\","]
#[doc = "  \"description\": \"The undeniable SHA-256 hash of the core objective.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AnchorPromptHash(::std::string::String);
impl ::std::ops::Deref for AnchorPromptHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AnchorPromptHash> for ::std::string::String {
    fn from(value: AnchorPromptHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AnchorPromptHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AnchorPromptHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AnchorPromptHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AnchorPromptHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AnchorPromptHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The scientific tracking standard utilized to establish this reference frame."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Anchor Protocol\","]
#[doc = "  \"description\": \"The scientific tracking standard utilized to establish this reference frame.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"openxr_spatial_anchor\","]
#[doc = "    \"apple_world_anchor\","]
#[doc = "    \"slam_feature_map\","]
#[doc = "    \"relative_virtual\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum AnchorProtocol {
    #[serde(rename = "openxr_spatial_anchor")]
    OpenxrSpatialAnchor,
    #[serde(rename = "apple_world_anchor")]
    AppleWorldAnchor,
    #[serde(rename = "slam_feature_map")]
    SlamFeatureMap,
    #[serde(rename = "relative_virtual")]
    RelativeVirtual,
}
impl ::std::fmt::Display for AnchorProtocol {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::OpenxrSpatialAnchor => f.write_str("openxr_spatial_anchor"),
            Self::AppleWorldAnchor => f.write_str("apple_world_anchor"),
            Self::SlamFeatureMap => f.write_str("slam_feature_map"),
            Self::RelativeVirtual => f.write_str("relative_virtual"),
        }
    }
}
impl ::std::str::FromStr for AnchorProtocol {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "openxr_spatial_anchor" => Ok(Self::OpenxrSpatialAnchor),
            "apple_world_anchor" => Ok(Self::AppleWorldAnchor),
            "slam_feature_map" => Ok(Self::SlamFeatureMap),
            "relative_virtual" => Ok(Self::RelativeVirtual),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for AnchorProtocol {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AnchorProtocol {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AnchorProtocol {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Utilizes Kullback-Leibler (KL) Divergence and Latent Space\nRegularization to establish a mathematically inescapable center of gravity,\npreventing epistemic drift and sycophancy. As a ...Policy suffix, this defines\nrigid structural boundaries globally.\n\nCAUSAL AFFORDANCE: Triggers an immediate SystemFaultEvent or state rollback\nif the orchestrator detects that the swarm's semantic trajectory has\nprobabilistically drifted beyond the authorized cosine distance from its\norigin constraints.\n\nEPISTEMIC BOUNDS: The geometric radius of acceptable divergence is strictly\nclamped by max_semantic_drift (ge=0.0, le=1.0). The origin is\ncryptographically locked to the anchor_prompt_hash (SHA-256 regex\n^[a-f0-9]{64}$).\n\nMCP ROUTING TRIGGERS: Kullback-Leibler Divergence, Latent Regularization,\nSemantic Gravity Well, Epistemic Drift, Trajectory Bounding"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AnchoringPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Utilizes Kullback-Leibler (KL) Divergence and Latent Space\\nRegularization to establish a mathematically inescapable center of gravity,\\npreventing epistemic drift and sycophancy. As a ...Policy suffix, this defines\\nrigid structural boundaries globally.\\n\\nCAUSAL AFFORDANCE: Triggers an immediate SystemFaultEvent or state rollback\\nif the orchestrator detects that the swarm's semantic trajectory has\\nprobabilistically drifted beyond the authorized cosine distance from its\\norigin constraints.\\n\\nEPISTEMIC BOUNDS: The geometric radius of acceptable divergence is strictly\\nclamped by max_semantic_drift (ge=0.0, le=1.0). The origin is\\ncryptographically locked to the anchor_prompt_hash (SHA-256 regex\\n^[a-f0-9]{64}$).\\n\\nMCP ROUTING TRIGGERS: Kullback-Leibler Divergence, Latent Regularization,\\nSemantic Gravity Well, Epistemic Drift, Trajectory Bounding\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"anchor_prompt_hash\","]
#[doc = "    \"max_semantic_drift\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"anchor_prompt_hash\": {"]
#[doc = "      \"title\": \"Anchor Prompt Hash\","]
#[doc = "      \"description\": \"The undeniable SHA-256 hash of the core objective.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"max_semantic_drift\": {"]
#[doc = "      \"title\": \"Max Semantic Drift\","]
#[doc = "      \"description\": \"The maximum allowed cosine deviation from the anchor before the orchestrator forces a state rollback.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AnchoringPolicy {
    #[doc = "The undeniable SHA-256 hash of the core objective."]
    pub anchor_prompt_hash: AnchorPromptHash,
    #[doc = "The maximum allowed cosine deviation from the anchor before the orchestrator forces a state rollback."]
    pub max_semantic_drift: f64,
}
impl AnchoringPolicy {
    pub fn builder() -> builder::AnchoringPolicy {
        Default::default()
    }
}
#[doc = "`AnyActionSpaceCapability`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"oneOf\": ["]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SpatialToolManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/MCPServerManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EphemeralNamespacePartitionState\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicZeroTrustContract\""]
#[doc = "    }"]
#[doc = "  ],"]
#[doc = "  \"discriminator\": {"]
#[doc = "    \"mapping\": {"]
#[doc = "      \"ephemeral_partition\": \"#/$defs/EphemeralNamespacePartitionState\","]
#[doc = "      \"mcp_server\": \"#/$defs/MCPServerManifest\","]
#[doc = "      \"native_tool\": \"#/$defs/SpatialToolManifest\","]
#[doc = "      \"zero_trust_contract\": \"#/$defs/EpistemicZeroTrustContract\""]
#[doc = "    },"]
#[doc = "    \"propertyName\": \"topology_class\""]
#[doc = "  }"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum AnyActionSpaceCapability {
    SpatialToolManifest(SpatialToolManifest),
    McpServerManifest(McpServerManifest),
    EphemeralNamespacePartitionState(EphemeralNamespacePartitionState),
    EpistemicZeroTrustContract(EpistemicZeroTrustContract),
}
impl ::std::convert::From<SpatialToolManifest> for AnyActionSpaceCapability {
    fn from(value: SpatialToolManifest) -> Self {
        Self::SpatialToolManifest(value)
    }
}
impl ::std::convert::From<McpServerManifest> for AnyActionSpaceCapability {
    fn from(value: McpServerManifest) -> Self {
        Self::McpServerManifest(value)
    }
}
impl ::std::convert::From<EphemeralNamespacePartitionState> for AnyActionSpaceCapability {
    fn from(value: EphemeralNamespacePartitionState) -> Self {
        Self::EphemeralNamespacePartitionState(value)
    }
}
impl ::std::convert::From<EpistemicZeroTrustContract> for AnyActionSpaceCapability {
    fn from(value: EpistemicZeroTrustContract) -> Self {
        Self::EpistemicZeroTrustContract(value)
    }
}
#[doc = "`AnyExplorationBranch`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"oneOf\": ["]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/ThoughtBranchState\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/StochasticTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/StrategicThoughtNodeIntent\""]
#[doc = "    }"]
#[doc = "  ],"]
#[doc = "  \"discriminator\": {"]
#[doc = "    \"mapping\": {"]
#[doc = "      \"stochastic_ensemble\": \"#/$defs/StochasticTopologyManifest\","]
#[doc = "      \"strategic_thought_node\": \"#/$defs/StrategicThoughtNodeIntent\","]
#[doc = "      \"thought_branch\": \"#/$defs/ThoughtBranchState\""]
#[doc = "    },"]
#[doc = "    \"propertyName\": \"topology_class\""]
#[doc = "  }"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum AnyExplorationBranch {
    ThoughtBranchState(ThoughtBranchState),
    StochasticTopologyManifest(StochasticTopologyManifest),
    StrategicThoughtNodeIntent(StrategicThoughtNodeIntent),
}
impl ::std::convert::From<ThoughtBranchState> for AnyExplorationBranch {
    fn from(value: ThoughtBranchState) -> Self {
        Self::ThoughtBranchState(value)
    }
}
impl ::std::convert::From<StochasticTopologyManifest> for AnyExplorationBranch {
    fn from(value: StochasticTopologyManifest) -> Self {
        Self::StochasticTopologyManifest(value)
    }
}
impl ::std::convert::From<StrategicThoughtNodeIntent> for AnyExplorationBranch {
    fn from(value: StrategicThoughtNodeIntent) -> Self {
        Self::StrategicThoughtNodeIntent(value)
    }
}
#[doc = "`AnyIntent`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"oneOf\": ["]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/TemporalEdgeInvalidationIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicZeroTrustContract\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EmpiricalFalsificationContract\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/FalsificationContract\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/OntologicalCrosswalkIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/DraftingIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/AdjudicationIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EscalationIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticDiscoveryIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/TaxonomicRestructureIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/LatentProjectionIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/LatentSchemaInferenceIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/HumanDirectiveIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/ContextualSemanticResolutionIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/OntologyDiscoveryIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticMappingHeuristicIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/ContinuousSpatialMutationIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/AgentBidIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/ComputeProvisioningIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/TaskAnnouncementIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/QuarantineIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/InterventionIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/FYIIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/FallbackIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/OverrideIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/ConstitutionalAmendmentIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SpatialKinematicActionIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/System2RemediationIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SubstrateHydrationManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/NeurosymbolicInferenceIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/TopologicalProjectionIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/FormalLogicPremise\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CausalPropagationIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/RDFSerializationIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SPARQLQueryIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/AnalogicalMappingTask\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/BoundedJSONRPCIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicTransmutationTask\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicUpsamplingTask\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/InterventionalCausalTask\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/MCPClientIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/RollbackIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/StateMutationIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/OntologicalNormalizationIntent\""]
#[doc = "    }"]
#[doc = "  ],"]
#[doc = "  \"discriminator\": {"]
#[doc = "    \"mapping\": {"]
#[doc = "      \"agent_bid\": \"#/$defs/AgentBidIntent\","]
#[doc = "      \"analogical_mapping_task\": \"#/$defs/AnalogicalMappingTask\","]
#[doc = "      \"bounded_json_rpc_intent\": \"#/$defs/BoundedJSONRPCIntent\","]
#[doc = "      \"causal_propagation\": \"#/$defs/CausalPropagationIntent\","]
#[doc = "      \"compute_provisioning\": \"#/$defs/ComputeProvisioningIntent\","]
#[doc = "      \"constitutional_amendment\": \"#/$defs/ConstitutionalAmendmentIntent\","]
#[doc = "      \"contextual_semantic_resolution\": \"#/$defs/ContextualSemanticResolutionIntent\","]
#[doc = "      \"continuous_spatial_mutation\": \"#/$defs/ContinuousSpatialMutationIntent\","]
#[doc = "      \"drafting\": \"#/$defs/DraftingIntent\","]
#[doc = "      \"empirical_falsification_contract\": \"#/$defs/EmpiricalFalsificationContract\","]
#[doc = "      \"epistemic_transmutation_task\": \"#/$defs/EpistemicTransmutationTask\","]
#[doc = "      \"epistemic_upsampling_task\": \"#/$defs/EpistemicUpsamplingTask\","]
#[doc = "      \"escalation\": \"#/$defs/EscalationIntent\","]
#[doc = "      \"fallback_intent\": \"#/$defs/FallbackIntent\","]
#[doc = "      \"falsification_contract\": \"#/$defs/FalsificationContract\","]
#[doc = "      \"forced_adjudication\": \"#/$defs/AdjudicationIntent\","]
#[doc = "      \"formal_logic_premise\": \"#/$defs/FormalLogicPremise\","]
#[doc = "      \"fyi\": \"#/$defs/FYIIntent\","]
#[doc = "      \"human_directive\": \"#/$defs/HumanDirectiveIntent\","]
#[doc = "      \"informational\": \"#/$defs/SemanticIntent\","]
#[doc = "      \"interventional_causal_task\": \"#/$defs/InterventionalCausalTask\","]
#[doc = "      \"latent_projection\": \"#/$defs/LatentProjectionIntent\","]
#[doc = "      \"latent_schema_inference\": \"#/$defs/LatentSchemaInferenceIntent\","]
#[doc = "      \"mcp_client_intent\": \"#/$defs/MCPClientIntent\","]
#[doc = "      \"neurosymbolic_inference\": \"#/$defs/NeurosymbolicInferenceIntent\","]
#[doc = "      \"ontological_crosswalk\": \"#/$defs/OntologicalCrosswalkIntent\","]
#[doc = "      \"ontological_normalization\": \"#/$defs/OntologicalNormalizationIntent\","]
#[doc = "      \"ontology_discovery\": \"#/$defs/OntologyDiscoveryIntent\","]
#[doc = "      \"override\": \"#/$defs/OverrideIntent\","]
#[doc = "      \"quarantine_intent\": \"#/$defs/QuarantineIntent\","]
#[doc = "      \"rdf_serialization\": \"#/$defs/RDFSerializationIntent\","]
#[doc = "      \"request\": \"#/$defs/InterventionIntent\","]
#[doc = "      \"rollback_intent\": \"#/$defs/RollbackIntent\","]
#[doc = "      \"semantic_discovery\": \"#/$defs/SemanticDiscoveryIntent\","]
#[doc = "      \"semantic_mapping_proposal\": \"#/$defs/SemanticMappingHeuristicIntent\","]
#[doc = "      \"sparql_query\": \"#/$defs/SPARQLQueryIntent\","]
#[doc = "      \"spatial_kinematic\": \"#/$defs/SpatialKinematicActionIntent\","]
#[doc = "      \"state_mutation_intent\": \"#/$defs/StateMutationIntent\","]
#[doc = "      \"substrate_hydration\": \"#/$defs/SubstrateHydrationManifest\","]
#[doc = "      \"system_2_remediation\": \"#/$defs/System2RemediationIntent\","]
#[doc = "      \"task_announcement\": \"#/$defs/TaskAnnouncementIntent\","]
#[doc = "      \"taxonomic_restructure\": \"#/$defs/TaxonomicRestructureIntent\","]
#[doc = "      \"temporal_invalidation\": \"#/$defs/TemporalEdgeInvalidationIntent\","]
#[doc = "      \"topological_projection\": \"#/$defs/TopologicalProjectionIntent\","]
#[doc = "      \"zero_trust_contract\": \"#/$defs/EpistemicZeroTrustContract\""]
#[doc = "    },"]
#[doc = "    \"propertyName\": \"topology_class\""]
#[doc = "  }"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum AnyIntent {
    TemporalEdgeInvalidationIntent(TemporalEdgeInvalidationIntent),
    EpistemicZeroTrustContract(EpistemicZeroTrustContract),
    EmpiricalFalsificationContract(EmpiricalFalsificationContract),
    FalsificationContract(FalsificationContract),
    OntologicalCrosswalkIntent(OntologicalCrosswalkIntent),
    SemanticIntent(SemanticIntent),
    DraftingIntent(DraftingIntent),
    AdjudicationIntent(AdjudicationIntent),
    EscalationIntent(EscalationIntent),
    SemanticDiscoveryIntent(SemanticDiscoveryIntent),
    TaxonomicRestructureIntent(TaxonomicRestructureIntent),
    LatentProjectionIntent(LatentProjectionIntent),
    LatentSchemaInferenceIntent(LatentSchemaInferenceIntent),
    HumanDirectiveIntent(HumanDirectiveIntent),
    ContextualSemanticResolutionIntent(ContextualSemanticResolutionIntent),
    OntologyDiscoveryIntent(OntologyDiscoveryIntent),
    SemanticMappingHeuristicIntent(SemanticMappingHeuristicIntent),
    ContinuousSpatialMutationIntent(ContinuousSpatialMutationIntent),
    AgentBidIntent(AgentBidIntent),
    ComputeProvisioningIntent(ComputeProvisioningIntent),
    TaskAnnouncementIntent(TaskAnnouncementIntent),
    QuarantineIntent(QuarantineIntent),
    InterventionIntent(InterventionIntent),
    FyiIntent(FyiIntent),
    FallbackIntent(FallbackIntent),
    OverrideIntent(OverrideIntent),
    ConstitutionalAmendmentIntent(ConstitutionalAmendmentIntent),
    SpatialKinematicActionIntent(SpatialKinematicActionIntent),
    System2RemediationIntent(System2RemediationIntent),
    SubstrateHydrationManifest(SubstrateHydrationManifest),
    NeurosymbolicInferenceIntent(NeurosymbolicInferenceIntent),
    TopologicalProjectionIntent(TopologicalProjectionIntent),
    FormalLogicPremise(FormalLogicPremise),
    CausalPropagationIntent(CausalPropagationIntent),
    RdfSerializationIntent(RdfSerializationIntent),
    SparqlQueryIntent(SparqlQueryIntent),
    AnalogicalMappingTask(AnalogicalMappingTask),
    BoundedJsonrpcIntent(BoundedJsonrpcIntent),
    EpistemicTransmutationTask(EpistemicTransmutationTask),
    EpistemicUpsamplingTask(EpistemicUpsamplingTask),
    InterventionalCausalTask(InterventionalCausalTask),
    McpClientIntent(McpClientIntent),
    RollbackIntent(RollbackIntent),
    StateMutationIntent(StateMutationIntent),
    OntologicalNormalizationIntent(OntologicalNormalizationIntent),
}
impl ::std::convert::From<TemporalEdgeInvalidationIntent> for AnyIntent {
    fn from(value: TemporalEdgeInvalidationIntent) -> Self {
        Self::TemporalEdgeInvalidationIntent(value)
    }
}
impl ::std::convert::From<EpistemicZeroTrustContract> for AnyIntent {
    fn from(value: EpistemicZeroTrustContract) -> Self {
        Self::EpistemicZeroTrustContract(value)
    }
}
impl ::std::convert::From<EmpiricalFalsificationContract> for AnyIntent {
    fn from(value: EmpiricalFalsificationContract) -> Self {
        Self::EmpiricalFalsificationContract(value)
    }
}
impl ::std::convert::From<FalsificationContract> for AnyIntent {
    fn from(value: FalsificationContract) -> Self {
        Self::FalsificationContract(value)
    }
}
impl ::std::convert::From<OntologicalCrosswalkIntent> for AnyIntent {
    fn from(value: OntologicalCrosswalkIntent) -> Self {
        Self::OntologicalCrosswalkIntent(value)
    }
}
impl ::std::convert::From<SemanticIntent> for AnyIntent {
    fn from(value: SemanticIntent) -> Self {
        Self::SemanticIntent(value)
    }
}
impl ::std::convert::From<DraftingIntent> for AnyIntent {
    fn from(value: DraftingIntent) -> Self {
        Self::DraftingIntent(value)
    }
}
impl ::std::convert::From<AdjudicationIntent> for AnyIntent {
    fn from(value: AdjudicationIntent) -> Self {
        Self::AdjudicationIntent(value)
    }
}
impl ::std::convert::From<EscalationIntent> for AnyIntent {
    fn from(value: EscalationIntent) -> Self {
        Self::EscalationIntent(value)
    }
}
impl ::std::convert::From<SemanticDiscoveryIntent> for AnyIntent {
    fn from(value: SemanticDiscoveryIntent) -> Self {
        Self::SemanticDiscoveryIntent(value)
    }
}
impl ::std::convert::From<TaxonomicRestructureIntent> for AnyIntent {
    fn from(value: TaxonomicRestructureIntent) -> Self {
        Self::TaxonomicRestructureIntent(value)
    }
}
impl ::std::convert::From<LatentProjectionIntent> for AnyIntent {
    fn from(value: LatentProjectionIntent) -> Self {
        Self::LatentProjectionIntent(value)
    }
}
impl ::std::convert::From<LatentSchemaInferenceIntent> for AnyIntent {
    fn from(value: LatentSchemaInferenceIntent) -> Self {
        Self::LatentSchemaInferenceIntent(value)
    }
}
impl ::std::convert::From<HumanDirectiveIntent> for AnyIntent {
    fn from(value: HumanDirectiveIntent) -> Self {
        Self::HumanDirectiveIntent(value)
    }
}
impl ::std::convert::From<ContextualSemanticResolutionIntent> for AnyIntent {
    fn from(value: ContextualSemanticResolutionIntent) -> Self {
        Self::ContextualSemanticResolutionIntent(value)
    }
}
impl ::std::convert::From<OntologyDiscoveryIntent> for AnyIntent {
    fn from(value: OntologyDiscoveryIntent) -> Self {
        Self::OntologyDiscoveryIntent(value)
    }
}
impl ::std::convert::From<SemanticMappingHeuristicIntent> for AnyIntent {
    fn from(value: SemanticMappingHeuristicIntent) -> Self {
        Self::SemanticMappingHeuristicIntent(value)
    }
}
impl ::std::convert::From<ContinuousSpatialMutationIntent> for AnyIntent {
    fn from(value: ContinuousSpatialMutationIntent) -> Self {
        Self::ContinuousSpatialMutationIntent(value)
    }
}
impl ::std::convert::From<AgentBidIntent> for AnyIntent {
    fn from(value: AgentBidIntent) -> Self {
        Self::AgentBidIntent(value)
    }
}
impl ::std::convert::From<ComputeProvisioningIntent> for AnyIntent {
    fn from(value: ComputeProvisioningIntent) -> Self {
        Self::ComputeProvisioningIntent(value)
    }
}
impl ::std::convert::From<TaskAnnouncementIntent> for AnyIntent {
    fn from(value: TaskAnnouncementIntent) -> Self {
        Self::TaskAnnouncementIntent(value)
    }
}
impl ::std::convert::From<QuarantineIntent> for AnyIntent {
    fn from(value: QuarantineIntent) -> Self {
        Self::QuarantineIntent(value)
    }
}
impl ::std::convert::From<InterventionIntent> for AnyIntent {
    fn from(value: InterventionIntent) -> Self {
        Self::InterventionIntent(value)
    }
}
impl ::std::convert::From<FyiIntent> for AnyIntent {
    fn from(value: FyiIntent) -> Self {
        Self::FyiIntent(value)
    }
}
impl ::std::convert::From<FallbackIntent> for AnyIntent {
    fn from(value: FallbackIntent) -> Self {
        Self::FallbackIntent(value)
    }
}
impl ::std::convert::From<OverrideIntent> for AnyIntent {
    fn from(value: OverrideIntent) -> Self {
        Self::OverrideIntent(value)
    }
}
impl ::std::convert::From<ConstitutionalAmendmentIntent> for AnyIntent {
    fn from(value: ConstitutionalAmendmentIntent) -> Self {
        Self::ConstitutionalAmendmentIntent(value)
    }
}
impl ::std::convert::From<SpatialKinematicActionIntent> for AnyIntent {
    fn from(value: SpatialKinematicActionIntent) -> Self {
        Self::SpatialKinematicActionIntent(value)
    }
}
impl ::std::convert::From<System2RemediationIntent> for AnyIntent {
    fn from(value: System2RemediationIntent) -> Self {
        Self::System2RemediationIntent(value)
    }
}
impl ::std::convert::From<SubstrateHydrationManifest> for AnyIntent {
    fn from(value: SubstrateHydrationManifest) -> Self {
        Self::SubstrateHydrationManifest(value)
    }
}
impl ::std::convert::From<NeurosymbolicInferenceIntent> for AnyIntent {
    fn from(value: NeurosymbolicInferenceIntent) -> Self {
        Self::NeurosymbolicInferenceIntent(value)
    }
}
impl ::std::convert::From<TopologicalProjectionIntent> for AnyIntent {
    fn from(value: TopologicalProjectionIntent) -> Self {
        Self::TopologicalProjectionIntent(value)
    }
}
impl ::std::convert::From<FormalLogicPremise> for AnyIntent {
    fn from(value: FormalLogicPremise) -> Self {
        Self::FormalLogicPremise(value)
    }
}
impl ::std::convert::From<CausalPropagationIntent> for AnyIntent {
    fn from(value: CausalPropagationIntent) -> Self {
        Self::CausalPropagationIntent(value)
    }
}
impl ::std::convert::From<RdfSerializationIntent> for AnyIntent {
    fn from(value: RdfSerializationIntent) -> Self {
        Self::RdfSerializationIntent(value)
    }
}
impl ::std::convert::From<SparqlQueryIntent> for AnyIntent {
    fn from(value: SparqlQueryIntent) -> Self {
        Self::SparqlQueryIntent(value)
    }
}
impl ::std::convert::From<AnalogicalMappingTask> for AnyIntent {
    fn from(value: AnalogicalMappingTask) -> Self {
        Self::AnalogicalMappingTask(value)
    }
}
impl ::std::convert::From<BoundedJsonrpcIntent> for AnyIntent {
    fn from(value: BoundedJsonrpcIntent) -> Self {
        Self::BoundedJsonrpcIntent(value)
    }
}
impl ::std::convert::From<EpistemicTransmutationTask> for AnyIntent {
    fn from(value: EpistemicTransmutationTask) -> Self {
        Self::EpistemicTransmutationTask(value)
    }
}
impl ::std::convert::From<EpistemicUpsamplingTask> for AnyIntent {
    fn from(value: EpistemicUpsamplingTask) -> Self {
        Self::EpistemicUpsamplingTask(value)
    }
}
impl ::std::convert::From<InterventionalCausalTask> for AnyIntent {
    fn from(value: InterventionalCausalTask) -> Self {
        Self::InterventionalCausalTask(value)
    }
}
impl ::std::convert::From<McpClientIntent> for AnyIntent {
    fn from(value: McpClientIntent) -> Self {
        Self::McpClientIntent(value)
    }
}
impl ::std::convert::From<RollbackIntent> for AnyIntent {
    fn from(value: RollbackIntent) -> Self {
        Self::RollbackIntent(value)
    }
}
impl ::std::convert::From<StateMutationIntent> for AnyIntent {
    fn from(value: StateMutationIntent) -> Self {
        Self::StateMutationIntent(value)
    }
}
impl ::std::convert::From<OntologicalNormalizationIntent> for AnyIntent {
    fn from(value: OntologicalNormalizationIntent) -> Self {
        Self::OntologicalNormalizationIntent(value)
    }
}
#[doc = "A discriminated union of all valid workflow nodes."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"description\": \"A discriminated union of all valid workflow nodes.\","]
#[doc = "  \"oneOf\": ["]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveAgentNodeProfile\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveHumanNodeProfile\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveSystemNodeProfile\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CompositeNodeProfile\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/MemoizedNodeProfile\""]
#[doc = "    }"]
#[doc = "  ],"]
#[doc = "  \"discriminator\": {"]
#[doc = "    \"mapping\": {"]
#[doc = "      \"agent\": \"#/$defs/CognitiveAgentNodeProfile\","]
#[doc = "      \"composite\": \"#/$defs/CompositeNodeProfile\","]
#[doc = "      \"human\": \"#/$defs/CognitiveHumanNodeProfile\","]
#[doc = "      \"memoized\": \"#/$defs/MemoizedNodeProfile\","]
#[doc = "      \"system\": \"#/$defs/CognitiveSystemNodeProfile\""]
#[doc = "    },"]
#[doc = "    \"propertyName\": \"topology_class\""]
#[doc = "  }"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum AnyNodeProfile {
    CognitiveAgentNodeProfile(CognitiveAgentNodeProfile),
    CognitiveHumanNodeProfile(CognitiveHumanNodeProfile),
    CognitiveSystemNodeProfile(CognitiveSystemNodeProfile),
    CompositeNodeProfile(CompositeNodeProfile),
    MemoizedNodeProfile(MemoizedNodeProfile),
}
impl ::std::convert::From<CognitiveAgentNodeProfile> for AnyNodeProfile {
    fn from(value: CognitiveAgentNodeProfile) -> Self {
        Self::CognitiveAgentNodeProfile(value)
    }
}
impl ::std::convert::From<CognitiveHumanNodeProfile> for AnyNodeProfile {
    fn from(value: CognitiveHumanNodeProfile) -> Self {
        Self::CognitiveHumanNodeProfile(value)
    }
}
impl ::std::convert::From<CognitiveSystemNodeProfile> for AnyNodeProfile {
    fn from(value: CognitiveSystemNodeProfile) -> Self {
        Self::CognitiveSystemNodeProfile(value)
    }
}
impl ::std::convert::From<CompositeNodeProfile> for AnyNodeProfile {
    fn from(value: CompositeNodeProfile) -> Self {
        Self::CompositeNodeProfile(value)
    }
}
impl ::std::convert::From<MemoizedNodeProfile> for AnyNodeProfile {
    fn from(value: MemoizedNodeProfile) -> Self {
        Self::MemoizedNodeProfile(value)
    }
}
#[doc = "A discriminated union of presentation UI panels."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"description\": \"A discriminated union of presentation UI panels.\","]
#[doc = "  \"oneOf\": ["]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/GrammarPanelProfile\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/InsightCardProfile\""]
#[doc = "    }"]
#[doc = "  ],"]
#[doc = "  \"discriminator\": {"]
#[doc = "    \"mapping\": {"]
#[doc = "      \"grammar\": \"#/$defs/GrammarPanelProfile\","]
#[doc = "      \"insight_card\": \"#/$defs/InsightCardProfile\""]
#[doc = "    },"]
#[doc = "    \"propertyName\": \"topology_class\""]
#[doc = "  }"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum AnyPanelProfile {
    GrammarPanelProfile(GrammarPanelProfile),
    InsightCardProfile(InsightCardProfile),
}
impl ::std::convert::From<GrammarPanelProfile> for AnyPanelProfile {
    fn from(value: GrammarPanelProfile) -> Self {
        Self::GrammarPanelProfile(value)
    }
}
impl ::std::convert::From<InsightCardProfile> for AnyPanelProfile {
    fn from(value: InsightCardProfile) -> Self {
        Self::InsightCardProfile(value)
    }
}
#[doc = "`AnyPresentationIntent`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"oneOf\": ["]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/DraftingIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/AdjudicationIntent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EscalationIntent\""]
#[doc = "    }"]
#[doc = "  ],"]
#[doc = "  \"discriminator\": {"]
#[doc = "    \"mapping\": {"]
#[doc = "      \"drafting\": \"#/$defs/DraftingIntent\","]
#[doc = "      \"escalation\": \"#/$defs/EscalationIntent\","]
#[doc = "      \"forced_adjudication\": \"#/$defs/AdjudicationIntent\","]
#[doc = "      \"informational\": \"#/$defs/SemanticIntent\""]
#[doc = "    },"]
#[doc = "    \"propertyName\": \"topology_class\""]
#[doc = "  }"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum AnyPresentationIntent {
    SemanticIntent(SemanticIntent),
    DraftingIntent(DraftingIntent),
    AdjudicationIntent(AdjudicationIntent),
    EscalationIntent(EscalationIntent),
}
impl ::std::convert::From<SemanticIntent> for AnyPresentationIntent {
    fn from(value: SemanticIntent) -> Self {
        Self::SemanticIntent(value)
    }
}
impl ::std::convert::From<DraftingIntent> for AnyPresentationIntent {
    fn from(value: DraftingIntent) -> Self {
        Self::DraftingIntent(value)
    }
}
impl ::std::convert::From<AdjudicationIntent> for AnyPresentationIntent {
    fn from(value: AdjudicationIntent) -> Self {
        Self::AdjudicationIntent(value)
    }
}
impl ::std::convert::From<EscalationIntent> for AnyPresentationIntent {
    fn from(value: EscalationIntent) -> Self {
        Self::EscalationIntent(value)
    }
}
#[doc = "A discriminated union of state events."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"description\": \"A discriminated union of state events.\","]
#[doc = "  \"oneOf\": ["]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/TemporalGraphCRDTManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/MCPToolDefinition\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CrosswalkResolutionReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicZeroTrustReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/ObservationEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/BeliefMutationEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SystemFaultEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/AtomicPropositionState\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/PostCoordinatedSemanticState\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/ArtifactCorruptionEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/HypothesisGenerationEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/BargeInInterruptEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CounterfactualRegretEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/ToolInvocationEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicPromotionEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/PersistenceCommitReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/TokenBurnReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/BudgetExhaustionEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicTelemetryEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CognitivePredictionReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicAxiomVerificationReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicFlowStateReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CausalExplanationEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/IntentClassificationReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticRelationalVectorState\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/OntologicalReificationReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CircuitBreakerEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/ExogenousEpistemicEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicLogEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/InterventionReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/AdjudicationReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CustodyReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/DefeasibleAttackEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicRejectionReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/FormalVerificationReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/BeliefModulationReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/RDFExportReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicStarvationEvent\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SPARQLQueryResultReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/OracleExecutionReceipt\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/GuardrailViolationEvent\""]
#[doc = "    }"]
#[doc = "  ],"]
#[doc = "  \"discriminator\": {"]
#[doc = "    \"mapping\": {"]
#[doc = "      \"adjudication_receipt\": \"#/$defs/AdjudicationReceipt\","]
#[doc = "      \"artifact_corruption\": \"#/$defs/ArtifactCorruptionEvent\","]
#[doc = "      \"atomic_proposition\": \"#/$defs/AtomicPropositionState\","]
#[doc = "      \"barge_in\": \"#/$defs/BargeInInterruptEvent\","]
#[doc = "      \"belief_modulation\": \"#/$defs/BeliefModulationReceipt\","]
#[doc = "      \"belief_mutation\": \"#/$defs/BeliefMutationEvent\","]
#[doc = "      \"budget_exhaustion\": \"#/$defs/BudgetExhaustionEvent\","]
#[doc = "      \"causal_explanation\": \"#/$defs/CausalExplanationEvent\","]
#[doc = "      \"circuit_breaker_event\": \"#/$defs/CircuitBreakerEvent\","]
#[doc = "      \"cognitive_prediction\": \"#/$defs/CognitivePredictionReceipt\","]
#[doc = "      \"counterfactual_regret\": \"#/$defs/CounterfactualRegretEvent\","]
#[doc = "      \"crosswalk_resolution\": \"#/$defs/CrosswalkResolutionReceipt\","]
#[doc = "      \"custody_receipt\": \"#/$defs/CustodyReceipt\","]
#[doc = "      \"defeasible_attack\": \"#/$defs/DefeasibleAttackEvent\","]
#[doc = "      \"epistemic_axiom_verification\": \"#/$defs/EpistemicAxiomVerificationReceipt\","]
#[doc = "      \"epistemic_flow_state\": \"#/$defs/EpistemicFlowStateReceipt\","]
#[doc = "      \"epistemic_log\": \"#/$defs/EpistemicLogEvent\","]
#[doc = "      \"epistemic_promotion\": \"#/$defs/EpistemicPromotionEvent\","]
#[doc = "      \"epistemic_rejection\": \"#/$defs/EpistemicRejectionReceipt\","]
#[doc = "      \"epistemic_starvation\": \"#/$defs/EpistemicStarvationEvent\","]
#[doc = "      \"epistemic_telemetry\": \"#/$defs/EpistemicTelemetryEvent\","]
#[doc = "      \"exogenous_event\": \"#/$defs/ExogenousEpistemicEvent\","]
#[doc = "      \"formal_verification_receipt\": \"#/$defs/FormalVerificationReceipt\","]
#[doc = "      \"guardrail_violation_event\": \"#/$defs/GuardrailViolationEvent\","]
#[doc = "      \"hypothesis\": \"#/$defs/HypothesisGenerationEvent\","]
#[doc = "      \"intent_classification\": \"#/$defs/IntentClassificationReceipt\","]
#[doc = "      \"mcp_tool_definition\": \"#/$defs/MCPToolDefinition\","]
#[doc = "      \"observation\": \"#/$defs/ObservationEvent\","]
#[doc = "      \"ontological_reification\": \"#/$defs/OntologicalReificationReceipt\","]
#[doc = "      \"oracle_execution_receipt\": \"#/$defs/OracleExecutionReceipt\","]
#[doc = "      \"persistence_commit\": \"#/$defs/PersistenceCommitReceipt\","]
#[doc = "      \"post_coordinated_concept\": \"#/$defs/PostCoordinatedSemanticState\","]
#[doc = "      \"rdf_export_receipt\": \"#/$defs/RDFExportReceipt\","]
#[doc = "      \"semantic_relational_record\": \"#/$defs/SemanticRelationalVectorState\","]
#[doc = "      \"sparql_query_result\": \"#/$defs/SPARQLQueryResultReceipt\","]
#[doc = "      \"system_fault\": \"#/$defs/SystemFaultEvent\","]
#[doc = "      \"temporal_graph_crdt\": \"#/$defs/TemporalGraphCRDTManifest\","]
#[doc = "      \"token_burn\": \"#/$defs/TokenBurnReceipt\","]
#[doc = "      \"tool_invocation\": \"#/$defs/ToolInvocationEvent\","]
#[doc = "      \"verdict\": \"#/$defs/InterventionReceipt\","]
#[doc = "      \"zero_trust_receipt\": \"#/$defs/EpistemicZeroTrustReceipt\""]
#[doc = "    },"]
#[doc = "    \"propertyName\": \"topology_class\""]
#[doc = "  }"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum AnyStateEvent {
    TemporalGraphCrdtManifest(TemporalGraphCrdtManifest),
    McpToolDefinition(McpToolDefinition),
    CrosswalkResolutionReceipt(CrosswalkResolutionReceipt),
    EpistemicZeroTrustReceipt(EpistemicZeroTrustReceipt),
    ObservationEvent(ObservationEvent),
    BeliefMutationEvent(BeliefMutationEvent),
    SystemFaultEvent(SystemFaultEvent),
    AtomicPropositionState(AtomicPropositionState),
    PostCoordinatedSemanticState(PostCoordinatedSemanticState),
    ArtifactCorruptionEvent(ArtifactCorruptionEvent),
    HypothesisGenerationEvent(HypothesisGenerationEvent),
    BargeInInterruptEvent(BargeInInterruptEvent),
    CounterfactualRegretEvent(CounterfactualRegretEvent),
    ToolInvocationEvent(ToolInvocationEvent),
    EpistemicPromotionEvent(EpistemicPromotionEvent),
    PersistenceCommitReceipt(PersistenceCommitReceipt),
    TokenBurnReceipt(TokenBurnReceipt),
    BudgetExhaustionEvent(BudgetExhaustionEvent),
    EpistemicTelemetryEvent(EpistemicTelemetryEvent),
    CognitivePredictionReceipt(CognitivePredictionReceipt),
    EpistemicAxiomVerificationReceipt(EpistemicAxiomVerificationReceipt),
    EpistemicFlowStateReceipt(EpistemicFlowStateReceipt),
    CausalExplanationEvent(CausalExplanationEvent),
    IntentClassificationReceipt(IntentClassificationReceipt),
    SemanticRelationalVectorState(SemanticRelationalVectorState),
    OntologicalReificationReceipt(OntologicalReificationReceipt),
    CircuitBreakerEvent(CircuitBreakerEvent),
    ExogenousEpistemicEvent(ExogenousEpistemicEvent),
    EpistemicLogEvent(EpistemicLogEvent),
    InterventionReceipt(InterventionReceipt),
    AdjudicationReceipt(AdjudicationReceipt),
    CustodyReceipt(CustodyReceipt),
    DefeasibleAttackEvent(DefeasibleAttackEvent),
    EpistemicRejectionReceipt(EpistemicRejectionReceipt),
    FormalVerificationReceipt(FormalVerificationReceipt),
    BeliefModulationReceipt(BeliefModulationReceipt),
    RdfExportReceipt(RdfExportReceipt),
    EpistemicStarvationEvent(EpistemicStarvationEvent),
    SparqlQueryResultReceipt(SparqlQueryResultReceipt),
    OracleExecutionReceipt(OracleExecutionReceipt),
    GuardrailViolationEvent(GuardrailViolationEvent),
}
impl ::std::convert::From<TemporalGraphCrdtManifest> for AnyStateEvent {
    fn from(value: TemporalGraphCrdtManifest) -> Self {
        Self::TemporalGraphCrdtManifest(value)
    }
}
impl ::std::convert::From<McpToolDefinition> for AnyStateEvent {
    fn from(value: McpToolDefinition) -> Self {
        Self::McpToolDefinition(value)
    }
}
impl ::std::convert::From<CrosswalkResolutionReceipt> for AnyStateEvent {
    fn from(value: CrosswalkResolutionReceipt) -> Self {
        Self::CrosswalkResolutionReceipt(value)
    }
}
impl ::std::convert::From<EpistemicZeroTrustReceipt> for AnyStateEvent {
    fn from(value: EpistemicZeroTrustReceipt) -> Self {
        Self::EpistemicZeroTrustReceipt(value)
    }
}
impl ::std::convert::From<ObservationEvent> for AnyStateEvent {
    fn from(value: ObservationEvent) -> Self {
        Self::ObservationEvent(value)
    }
}
impl ::std::convert::From<BeliefMutationEvent> for AnyStateEvent {
    fn from(value: BeliefMutationEvent) -> Self {
        Self::BeliefMutationEvent(value)
    }
}
impl ::std::convert::From<SystemFaultEvent> for AnyStateEvent {
    fn from(value: SystemFaultEvent) -> Self {
        Self::SystemFaultEvent(value)
    }
}
impl ::std::convert::From<AtomicPropositionState> for AnyStateEvent {
    fn from(value: AtomicPropositionState) -> Self {
        Self::AtomicPropositionState(value)
    }
}
impl ::std::convert::From<PostCoordinatedSemanticState> for AnyStateEvent {
    fn from(value: PostCoordinatedSemanticState) -> Self {
        Self::PostCoordinatedSemanticState(value)
    }
}
impl ::std::convert::From<ArtifactCorruptionEvent> for AnyStateEvent {
    fn from(value: ArtifactCorruptionEvent) -> Self {
        Self::ArtifactCorruptionEvent(value)
    }
}
impl ::std::convert::From<HypothesisGenerationEvent> for AnyStateEvent {
    fn from(value: HypothesisGenerationEvent) -> Self {
        Self::HypothesisGenerationEvent(value)
    }
}
impl ::std::convert::From<BargeInInterruptEvent> for AnyStateEvent {
    fn from(value: BargeInInterruptEvent) -> Self {
        Self::BargeInInterruptEvent(value)
    }
}
impl ::std::convert::From<CounterfactualRegretEvent> for AnyStateEvent {
    fn from(value: CounterfactualRegretEvent) -> Self {
        Self::CounterfactualRegretEvent(value)
    }
}
impl ::std::convert::From<ToolInvocationEvent> for AnyStateEvent {
    fn from(value: ToolInvocationEvent) -> Self {
        Self::ToolInvocationEvent(value)
    }
}
impl ::std::convert::From<EpistemicPromotionEvent> for AnyStateEvent {
    fn from(value: EpistemicPromotionEvent) -> Self {
        Self::EpistemicPromotionEvent(value)
    }
}
impl ::std::convert::From<PersistenceCommitReceipt> for AnyStateEvent {
    fn from(value: PersistenceCommitReceipt) -> Self {
        Self::PersistenceCommitReceipt(value)
    }
}
impl ::std::convert::From<TokenBurnReceipt> for AnyStateEvent {
    fn from(value: TokenBurnReceipt) -> Self {
        Self::TokenBurnReceipt(value)
    }
}
impl ::std::convert::From<BudgetExhaustionEvent> for AnyStateEvent {
    fn from(value: BudgetExhaustionEvent) -> Self {
        Self::BudgetExhaustionEvent(value)
    }
}
impl ::std::convert::From<EpistemicTelemetryEvent> for AnyStateEvent {
    fn from(value: EpistemicTelemetryEvent) -> Self {
        Self::EpistemicTelemetryEvent(value)
    }
}
impl ::std::convert::From<CognitivePredictionReceipt> for AnyStateEvent {
    fn from(value: CognitivePredictionReceipt) -> Self {
        Self::CognitivePredictionReceipt(value)
    }
}
impl ::std::convert::From<EpistemicAxiomVerificationReceipt> for AnyStateEvent {
    fn from(value: EpistemicAxiomVerificationReceipt) -> Self {
        Self::EpistemicAxiomVerificationReceipt(value)
    }
}
impl ::std::convert::From<EpistemicFlowStateReceipt> for AnyStateEvent {
    fn from(value: EpistemicFlowStateReceipt) -> Self {
        Self::EpistemicFlowStateReceipt(value)
    }
}
impl ::std::convert::From<CausalExplanationEvent> for AnyStateEvent {
    fn from(value: CausalExplanationEvent) -> Self {
        Self::CausalExplanationEvent(value)
    }
}
impl ::std::convert::From<IntentClassificationReceipt> for AnyStateEvent {
    fn from(value: IntentClassificationReceipt) -> Self {
        Self::IntentClassificationReceipt(value)
    }
}
impl ::std::convert::From<SemanticRelationalVectorState> for AnyStateEvent {
    fn from(value: SemanticRelationalVectorState) -> Self {
        Self::SemanticRelationalVectorState(value)
    }
}
impl ::std::convert::From<OntologicalReificationReceipt> for AnyStateEvent {
    fn from(value: OntologicalReificationReceipt) -> Self {
        Self::OntologicalReificationReceipt(value)
    }
}
impl ::std::convert::From<CircuitBreakerEvent> for AnyStateEvent {
    fn from(value: CircuitBreakerEvent) -> Self {
        Self::CircuitBreakerEvent(value)
    }
}
impl ::std::convert::From<ExogenousEpistemicEvent> for AnyStateEvent {
    fn from(value: ExogenousEpistemicEvent) -> Self {
        Self::ExogenousEpistemicEvent(value)
    }
}
impl ::std::convert::From<EpistemicLogEvent> for AnyStateEvent {
    fn from(value: EpistemicLogEvent) -> Self {
        Self::EpistemicLogEvent(value)
    }
}
impl ::std::convert::From<InterventionReceipt> for AnyStateEvent {
    fn from(value: InterventionReceipt) -> Self {
        Self::InterventionReceipt(value)
    }
}
impl ::std::convert::From<AdjudicationReceipt> for AnyStateEvent {
    fn from(value: AdjudicationReceipt) -> Self {
        Self::AdjudicationReceipt(value)
    }
}
impl ::std::convert::From<CustodyReceipt> for AnyStateEvent {
    fn from(value: CustodyReceipt) -> Self {
        Self::CustodyReceipt(value)
    }
}
impl ::std::convert::From<DefeasibleAttackEvent> for AnyStateEvent {
    fn from(value: DefeasibleAttackEvent) -> Self {
        Self::DefeasibleAttackEvent(value)
    }
}
impl ::std::convert::From<EpistemicRejectionReceipt> for AnyStateEvent {
    fn from(value: EpistemicRejectionReceipt) -> Self {
        Self::EpistemicRejectionReceipt(value)
    }
}
impl ::std::convert::From<FormalVerificationReceipt> for AnyStateEvent {
    fn from(value: FormalVerificationReceipt) -> Self {
        Self::FormalVerificationReceipt(value)
    }
}
impl ::std::convert::From<BeliefModulationReceipt> for AnyStateEvent {
    fn from(value: BeliefModulationReceipt) -> Self {
        Self::BeliefModulationReceipt(value)
    }
}
impl ::std::convert::From<RdfExportReceipt> for AnyStateEvent {
    fn from(value: RdfExportReceipt) -> Self {
        Self::RdfExportReceipt(value)
    }
}
impl ::std::convert::From<EpistemicStarvationEvent> for AnyStateEvent {
    fn from(value: EpistemicStarvationEvent) -> Self {
        Self::EpistemicStarvationEvent(value)
    }
}
impl ::std::convert::From<SparqlQueryResultReceipt> for AnyStateEvent {
    fn from(value: SparqlQueryResultReceipt) -> Self {
        Self::SparqlQueryResultReceipt(value)
    }
}
impl ::std::convert::From<OracleExecutionReceipt> for AnyStateEvent {
    fn from(value: OracleExecutionReceipt) -> Self {
        Self::OracleExecutionReceipt(value)
    }
}
impl ::std::convert::From<GuardrailViolationEvent> for AnyStateEvent {
    fn from(value: GuardrailViolationEvent) -> Self {
        Self::GuardrailViolationEvent(value)
    }
}
#[doc = "A discriminated union of Causal Actuators defining strict perimeters for Exogenous Perturbations to the causal graph."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"description\": \"A discriminated union of Causal Actuators defining strict perimeters for Exogenous Perturbations to the causal graph.\","]
#[doc = "  \"oneOf\": ["]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/BrowserDOMState\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/TerminalBufferState\""]
#[doc = "    }"]
#[doc = "  ],"]
#[doc = "  \"discriminator\": {"]
#[doc = "    \"mapping\": {"]
#[doc = "      \"browser\": \"#/$defs/BrowserDOMState\","]
#[doc = "      \"terminal\": \"#/$defs/TerminalBufferState\""]
#[doc = "    },"]
#[doc = "    \"propertyName\": \"topology_class\""]
#[doc = "  }"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum AnyToolchainState {
    BrowserDomState(BrowserDomState),
    TerminalBufferState(TerminalBufferState),
}
impl ::std::convert::From<BrowserDomState> for AnyToolchainState {
    fn from(value: BrowserDomState) -> Self {
        Self::BrowserDomState(value)
    }
}
impl ::std::convert::From<TerminalBufferState> for AnyToolchainState {
    fn from(value: TerminalBufferState) -> Self {
        Self::TerminalBufferState(value)
    }
}
#[doc = "A discriminated union of workflow topologies."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"description\": \"A discriminated union of workflow topologies.\","]
#[doc = "  \"oneOf\": ["]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/DAGTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CouncilTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SwarmTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EvolutionaryTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SMPCTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EvaluatorOptimizerTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/DigitalTwinTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/AdversarialMarketTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/ConsensusFederationTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CapabilityForgeTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/IntentElicitationTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/NeurosymbolicIngestionTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/NeurosymbolicVerificationTopologyManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/DiscourseTreeManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/DocumentKnowledgeGraphManifest\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/HierarchicalDOMManifest\""]
#[doc = "    }"]
#[doc = "  ],"]
#[doc = "  \"discriminator\": {"]
#[doc = "    \"mapping\": {"]
#[doc = "      \"council\": \"#/$defs/CouncilTopologyManifest\","]
#[doc = "      \"dag\": \"#/$defs/DAGTopologyManifest\","]
#[doc = "      \"digital_twin\": \"#/$defs/DigitalTwinTopologyManifest\","]
#[doc = "      \"discourse_tree\": \"#/$defs/DiscourseTreeManifest\","]
#[doc = "      \"document_knowledge_graph\": \"#/$defs/DocumentKnowledgeGraphManifest\","]
#[doc = "      \"evaluator_optimizer\": \"#/$defs/EvaluatorOptimizerTopologyManifest\","]
#[doc = "      \"evolutionary\": \"#/$defs/EvolutionaryTopologyManifest\","]
#[doc = "      \"hierarchical_dom\": \"#/$defs/HierarchicalDOMManifest\","]
#[doc = "      \"macro_adversarial\": \"#/$defs/AdversarialMarketTopologyManifest\","]
#[doc = "      \"macro_elicitation\": \"#/$defs/IntentElicitationTopologyManifest\","]
#[doc = "      \"macro_federation\": \"#/$defs/ConsensusFederationTopologyManifest\","]
#[doc = "      \"macro_forge\": \"#/$defs/CapabilityForgeTopologyManifest\","]
#[doc = "      \"macro_ingestion\": \"#/$defs/NeurosymbolicIngestionTopologyManifest\","]
#[doc = "      \"macro_neurosymbolic\": \"#/$defs/NeurosymbolicVerificationTopologyManifest\","]
#[doc = "      \"smpc\": \"#/$defs/SMPCTopologyManifest\","]
#[doc = "      \"swarm\": \"#/$defs/SwarmTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"propertyName\": \"topology_class\""]
#[doc = "  }"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum AnyTopologyManifest {
    DagTopologyManifest(DagTopologyManifest),
    CouncilTopologyManifest(CouncilTopologyManifest),
    SwarmTopologyManifest(SwarmTopologyManifest),
    EvolutionaryTopologyManifest(EvolutionaryTopologyManifest),
    SmpcTopologyManifest(SmpcTopologyManifest),
    EvaluatorOptimizerTopologyManifest(EvaluatorOptimizerTopologyManifest),
    DigitalTwinTopologyManifest(DigitalTwinTopologyManifest),
    AdversarialMarketTopologyManifest(AdversarialMarketTopologyManifest),
    ConsensusFederationTopologyManifest(ConsensusFederationTopologyManifest),
    CapabilityForgeTopologyManifest(CapabilityForgeTopologyManifest),
    IntentElicitationTopologyManifest(IntentElicitationTopologyManifest),
    NeurosymbolicIngestionTopologyManifest(NeurosymbolicIngestionTopologyManifest),
    NeurosymbolicVerificationTopologyManifest(NeurosymbolicVerificationTopologyManifest),
    DiscourseTreeManifest(DiscourseTreeManifest),
    DocumentKnowledgeGraphManifest(DocumentKnowledgeGraphManifest),
    HierarchicalDomManifest(HierarchicalDomManifest),
}
impl ::std::convert::From<DagTopologyManifest> for AnyTopologyManifest {
    fn from(value: DagTopologyManifest) -> Self {
        Self::DagTopologyManifest(value)
    }
}
impl ::std::convert::From<CouncilTopologyManifest> for AnyTopologyManifest {
    fn from(value: CouncilTopologyManifest) -> Self {
        Self::CouncilTopologyManifest(value)
    }
}
impl ::std::convert::From<SwarmTopologyManifest> for AnyTopologyManifest {
    fn from(value: SwarmTopologyManifest) -> Self {
        Self::SwarmTopologyManifest(value)
    }
}
impl ::std::convert::From<EvolutionaryTopologyManifest> for AnyTopologyManifest {
    fn from(value: EvolutionaryTopologyManifest) -> Self {
        Self::EvolutionaryTopologyManifest(value)
    }
}
impl ::std::convert::From<SmpcTopologyManifest> for AnyTopologyManifest {
    fn from(value: SmpcTopologyManifest) -> Self {
        Self::SmpcTopologyManifest(value)
    }
}
impl ::std::convert::From<EvaluatorOptimizerTopologyManifest> for AnyTopologyManifest {
    fn from(value: EvaluatorOptimizerTopologyManifest) -> Self {
        Self::EvaluatorOptimizerTopologyManifest(value)
    }
}
impl ::std::convert::From<DigitalTwinTopologyManifest> for AnyTopologyManifest {
    fn from(value: DigitalTwinTopologyManifest) -> Self {
        Self::DigitalTwinTopologyManifest(value)
    }
}
impl ::std::convert::From<AdversarialMarketTopologyManifest> for AnyTopologyManifest {
    fn from(value: AdversarialMarketTopologyManifest) -> Self {
        Self::AdversarialMarketTopologyManifest(value)
    }
}
impl ::std::convert::From<ConsensusFederationTopologyManifest> for AnyTopologyManifest {
    fn from(value: ConsensusFederationTopologyManifest) -> Self {
        Self::ConsensusFederationTopologyManifest(value)
    }
}
impl ::std::convert::From<CapabilityForgeTopologyManifest> for AnyTopologyManifest {
    fn from(value: CapabilityForgeTopologyManifest) -> Self {
        Self::CapabilityForgeTopologyManifest(value)
    }
}
impl ::std::convert::From<IntentElicitationTopologyManifest> for AnyTopologyManifest {
    fn from(value: IntentElicitationTopologyManifest) -> Self {
        Self::IntentElicitationTopologyManifest(value)
    }
}
impl ::std::convert::From<NeurosymbolicIngestionTopologyManifest> for AnyTopologyManifest {
    fn from(value: NeurosymbolicIngestionTopologyManifest) -> Self {
        Self::NeurosymbolicIngestionTopologyManifest(value)
    }
}
impl ::std::convert::From<NeurosymbolicVerificationTopologyManifest> for AnyTopologyManifest {
    fn from(value: NeurosymbolicVerificationTopologyManifest) -> Self {
        Self::NeurosymbolicVerificationTopologyManifest(value)
    }
}
impl ::std::convert::From<DiscourseTreeManifest> for AnyTopologyManifest {
    fn from(value: DiscourseTreeManifest) -> Self {
        Self::DiscourseTreeManifest(value)
    }
}
impl ::std::convert::From<DocumentKnowledgeGraphManifest> for AnyTopologyManifest {
    fn from(value: DocumentKnowledgeGraphManifest) -> Self {
        Self::DocumentKnowledgeGraphManifest(value)
    }
}
impl ::std::convert::From<HierarchicalDomManifest> for AnyTopologyManifest {
    fn from(value: HierarchicalDomManifest) -> Self {
        Self::HierarchicalDomManifest(value)
    }
}
#[doc = "`AnyTransitionEdge`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"oneOf\": ["]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/TransitionEdgeProfile\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/CyclicEdgeProfile\""]
#[doc = "    }"]
#[doc = "  ],"]
#[doc = "  \"discriminator\": {"]
#[doc = "    \"mapping\": {"]
#[doc = "      \"acyclic\": \"#/$defs/TransitionEdgeProfile\","]
#[doc = "      \"cyclic\": \"#/$defs/CyclicEdgeProfile\""]
#[doc = "    },"]
#[doc = "    \"propertyName\": \"topology_class\""]
#[doc = "  }"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum AnyTransitionEdge {
    TransitionEdgeProfile(TransitionEdgeProfile),
    CyclicEdgeProfile(CyclicEdgeProfile),
}
impl ::std::convert::From<TransitionEdgeProfile> for AnyTransitionEdge {
    fn from(value: TransitionEdgeProfile) -> Self {
        Self::TransitionEdgeProfile(value)
    }
}
impl ::std::convert::From<CyclicEdgeProfile> for AnyTransitionEdge {
    fn from(value: CyclicEdgeProfile) -> Self {
        Self::CyclicEdgeProfile(value)
    }
}
#[doc = "The deterministic capability pointer representing the SemanticFlowPolicy successfully applied."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Applied Policy Cid\","]
#[doc = "  \"description\": \"The deterministic capability pointer representing the SemanticFlowPolicy successfully applied.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AppliedPolicyCid(::std::string::String);
impl ::std::ops::Deref for AppliedPolicyCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AppliedPolicyCid> for ::std::string::String {
    fn from(value: AppliedPolicyCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AppliedPolicyCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AppliedPolicyCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AppliedPolicyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AppliedPolicyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AppliedPolicyCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`ArgsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ArgsItem(::std::string::String);
impl ::std::ops::Deref for ArgsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ArgsItem> for ::std::string::String {
    fn from(value: ArgsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ArgsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ArgsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ArgsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ArgsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ArgsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The genesis artifact that caused the ingestion engine to crash."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Artifact Cid\","]
#[doc = "  \"description\": \"The genesis artifact that caused the ingestion engine to crash.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ArtifactCid(::std::string::String);
impl ::std::ops::Deref for ArtifactCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ArtifactCid> for ::std::string::String {
    fn from(value: ArtifactCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ArtifactCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ArtifactCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ArtifactCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ArtifactCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ArtifactCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A terminal state representing catastrophic physical failure of the ingestion engine (e.g., Docling segfaults on malformed bytes).\n\nCAUSAL AFFORDANCE: Emits an immediate circuit breaker to the orchestrator, cleanly severing the ingestion branch and preventing systemic DAG collapse.\n\nEPISTEMIC BOUNDS: Evaluated via a strict Literal automaton classifying the failure physics.\n\nMCP ROUTING TRIGGERS: Artifact Contagion Prevention, Terminal Fault, VLM Crash, Malformed Bytes, DRM Lock"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ArtifactCorruptionEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A terminal state representing catastrophic physical failure of the ingestion engine (e.g., Docling segfaults on malformed bytes).\\n\\nCAUSAL AFFORDANCE: Emits an immediate circuit breaker to the orchestrator, cleanly severing the ingestion branch and preventing systemic DAG collapse.\\n\\nEPISTEMIC BOUNDS: Evaluated via a strict Literal automaton classifying the failure physics.\\n\\nMCP ROUTING TRIGGERS: Artifact Contagion Prevention, Terminal Fault, VLM Crash, Malformed Bytes, DRM Lock\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"artifact_cid\","]
#[doc = "    \"corruption_class\","]
#[doc = "    \"diagnostic_hash\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"artifact_cid\": {"]
#[doc = "      \"title\": \"Artifact Cid\","]
#[doc = "      \"description\": \"The genesis artifact that caused the ingestion engine to crash.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"corruption_class\": {"]
#[doc = "      \"title\": \"Corruption Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"drm_locked\","]
#[doc = "        \"malformed_bytes\","]
#[doc = "        \"ocr_failure\","]
#[doc = "        \"unsupported_format\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"diagnostic_hash\": {"]
#[doc = "      \"title\": \"Diagnostic Hash\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"artifact_corruption\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ArtifactCorruptionEvent {
    #[doc = "The genesis artifact that caused the ingestion engine to crash."]
    pub artifact_cid: ArtifactCid,
    pub corruption_class: CorruptionClass,
    pub diagnostic_hash: DiagnosticHash,
    pub event_cid: EventCid,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl ArtifactCorruptionEvent {
    pub fn builder() -> builder::ArtifactCorruptionEvent {
        Default::default()
    }
}
#[doc = "The exact genesis globally unique decentralized identifier (DID) anchoring the document, ensuring continuity."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Artifact Event Cid\","]
#[doc = "  \"description\": \"The exact genesis globally unique decentralized identifier (DID) anchoring the document, ensuring continuity.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ArtifactEventCid(::std::string::String);
impl ::std::ops::Deref for ArtifactEventCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ArtifactEventCid> for ::std::string::String {
    fn from(value: ArtifactEventCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ArtifactEventCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ArtifactEventCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ArtifactEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ArtifactEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ArtifactEventCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Strict AST-parsable string constraint (e.g., 'len(plan.outputs) == len(plan.inputs)')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Assertion Ast\","]
#[doc = "  \"description\": \"Strict AST-parsable string constraint (e.g., 'len(plan.outputs) == len(plan.inputs)').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 1024"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AssertionAst(::std::string::String);
impl ::std::ops::Deref for AssertionAst {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AssertionAst> for ::std::string::String {
    fn from(value: AssertionAst) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AssertionAst {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 1024usize {
            return Err("longer than 1024 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AssertionAst {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AssertionAst {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AssertionAst {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AssertionAst {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`AssumedSharedBeliefsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AssumedSharedBeliefsItem(::std::string::String);
impl ::std::ops::Deref for AssumedSharedBeliefsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AssumedSharedBeliefsItem> for ::std::string::String {
    fn from(value: AssumedSharedBeliefsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AssumedSharedBeliefsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AssumedSharedBeliefsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AssumedSharedBeliefsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AssumedSharedBeliefsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AssumedSharedBeliefsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes syntactic failure geometries, replacing unstructured tracebacks with deterministic, high-dimensional loss vectors.\n\n    CAUSAL AFFORDANCE: Executes deterministic code repair strategies by supplying the generative optimization mechanism with precise structural node pointers indicating syntax fractures.\n\n    EPISTEMIC BOUNDS: Bounded structurally via a 128-char compilation ID and precise AST string pointers clamped to 2000 chars. Vector magnitudes define the specific error distance.\n\n    MCP ROUTING TRIGGERS: AST Pointer, Generative Repair, Syntax Falsification, High-Dimensional Loss, Structural Gradient"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ASTGradientReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes syntactic failure geometries, replacing unstructured tracebacks with deterministic, high-dimensional loss vectors.\\n\\n    CAUSAL AFFORDANCE: Executes deterministic code repair strategies by supplying the generative optimization mechanism with precise structural node pointers indicating syntax fractures.\\n\\n    EPISTEMIC BOUNDS: Bounded structurally via a 128-char compilation ID and precise AST string pointers clamped to 2000 chars. Vector magnitudes define the specific error distance.\\n\\n    MCP ROUTING TRIGGERS: AST Pointer, Generative Repair, Syntax Falsification, High-Dimensional Loss, Structural Gradient\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"actual_type_geometry\","]
#[doc = "    \"ast_node_pointer\","]
#[doc = "    \"compilation_attempt_cid\","]
#[doc = "    \"expected_type_geometry\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"actual_type_geometry\": {"]
#[doc = "      \"title\": \"Actual Type Geometry\","]
#[doc = "      \"description\": \"The physical contravariant type string encountered at the structural fracture point.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"ast_node_pointer\": {"]
#[doc = "      \"title\": \"Ast Node Pointer\","]
#[doc = "      \"description\": \"The absolute structural RFC 6902 JSON Pointer or AST coordinate marking the physical syntax fracture.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"compilation_attempt_cid\": {"]
#[doc = "      \"title\": \"Compilation Attempt Cid\","]
#[doc = "      \"description\": \"The deterministic cryptographic coordinate linking the failure geometry to the execution timeline.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"expected_type_geometry\": {"]
#[doc = "      \"title\": \"Expected Type Geometry\","]
#[doc = "      \"description\": \"The explicit structural definition of the mathematical covariant bound requirement.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"structural_loss_vector\": {"]
#[doc = "      \"description\": \"The mathematically defined multi-dimensional vector encoding the syntactic divergence.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/VectorEmbeddingState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AstGradientReceipt {
    #[doc = "The physical contravariant type string encountered at the structural fracture point."]
    pub actual_type_geometry: ActualTypeGeometry,
    #[doc = "The absolute structural RFC 6902 JSON Pointer or AST coordinate marking the physical syntax fracture."]
    pub ast_node_pointer: AstNodePointer,
    #[doc = "The deterministic cryptographic coordinate linking the failure geometry to the execution timeline."]
    pub compilation_attempt_cid: CompilationAttemptCid,
    #[doc = "The explicit structural definition of the mathematical covariant bound requirement."]
    pub expected_type_geometry: ExpectedTypeGeometry,
    #[doc = "The mathematically defined multi-dimensional vector encoding the syntactic divergence."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub structural_loss_vector: ::std::option::Option<VectorEmbeddingState>,
}
impl AstGradientReceipt {
    pub fn builder() -> builder::AstGradientReceipt {
        Default::default()
    }
}
#[doc = "The absolute structural RFC 6902 JSON Pointer or AST coordinate marking the physical syntax fracture."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Ast Node Pointer\","]
#[doc = "  \"description\": \"The absolute structural RFC 6902 JSON Pointer or AST coordinate marking the physical syntax fracture.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AstNodePointer(::std::string::String);
impl ::std::ops::Deref for AstNodePointer {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AstNodePointer> for ::std::string::String {
    fn from(value: AstNodePointer) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AstNodePointer {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AstNodePointer {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AstNodePointer {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AstNodePointer {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AstNodePointer {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Big-O asymptotic complexity via Monte Carlo fuzzing to populate deterministic Markov transition costs.\n\n    CAUSAL AFFORDANCE: Dynamically allocates topological routing metrics, allowing the swarm to economically bound latency and VRAM before calling a tool.\n\n    EPISTEMIC BOUNDS: The asymptotic classification space is constrained via algebraic regex `^O\\([a-zA-Z0-9_+\\^ \\-\\*]+\\)$` guaranteeing valid Big-O notation while permitting arbitrary mathematical expressions. Peak bytes and CPU constraints enforce hard integer clamping against memory exhaustion.\n\n    MCP ROUTING TRIGGERS: Asymptotic Complexity, Big-O Notation, Monte Carlo Fuzzing, Markov Transition Costs, Computational Budget"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AsymptoticComplexityReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Big-O asymptotic complexity via Monte Carlo fuzzing to populate deterministic Markov transition costs.\\n\\n    CAUSAL AFFORDANCE: Dynamically allocates topological routing metrics, allowing the swarm to economically bound latency and VRAM before calling a tool.\\n\\n    EPISTEMIC BOUNDS: The asymptotic classification space is constrained via algebraic regex `^O\\\\([a-zA-Z0-9_+\\\\^ \\\\-\\\\*]+\\\\)$` guaranteeing valid Big-O notation while permitting arbitrary mathematical expressions. Peak bytes and CPU constraints enforce hard integer clamping against memory exhaustion.\\n\\n    MCP ROUTING TRIGGERS: Asymptotic Complexity, Big-O Notation, Monte Carlo Fuzzing, Markov Transition Costs, Computational Budget\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"capability_cid\","]
#[doc = "    \"peak_vram_bytes\","]
#[doc = "    \"simulated_cpu_cycles\","]
#[doc = "    \"space_complexity_class\","]
#[doc = "    \"time_complexity_class\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"capability_cid\": {"]
#[doc = "      \"title\": \"Capability Cid\","]
#[doc = "      \"description\": \"The exact 128-char physical DID referencing the algorithmic payload evaluated.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"peak_vram_bytes\": {"]
#[doc = "      \"title\": \"Peak Vram Bytes\","]
#[doc = "      \"description\": \"The strict absolute integer measurement bounding thermodynamic memory allocations.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"simulated_cpu_cycles\": {"]
#[doc = "      \"title\": \"Simulated Cpu Cycles\","]
#[doc = "      \"description\": \"The empirical cyclic integer threshold capturing the magnitude of the compute vector.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"space_complexity_class\": {"]
#[doc = "      \"title\": \"Space Complexity Class\","]
#[doc = "      \"description\": \"The formal algebraic Big-O notation representing the asymptotic structural memory geometry.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255,"]
#[doc = "      \"pattern\": \"^O\\\\([a-zA-Z0-9_+\\\\^ \\\\-\\\\*]+\\\\)$\""]
#[doc = "    },"]
#[doc = "    \"time_complexity_class\": {"]
#[doc = "      \"title\": \"Time Complexity Class\","]
#[doc = "      \"description\": \"The formal algebraic Big-O notation mathematically bounding temporal execution limits (e.g., 'O(N)', 'O(V + E)', 'O(N^2)').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255,"]
#[doc = "      \"pattern\": \"^O\\\\([a-zA-Z0-9_+\\\\^ \\\\-\\\\*]+\\\\)$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AsymptoticComplexityReceipt {
    #[doc = "The exact 128-char physical DID referencing the algorithmic payload evaluated."]
    pub capability_cid: CapabilityCid,
    #[doc = "The strict absolute integer measurement bounding thermodynamic memory allocations."]
    pub peak_vram_bytes: u64,
    #[doc = "The empirical cyclic integer threshold capturing the magnitude of the compute vector."]
    pub simulated_cpu_cycles: u64,
    #[doc = "The formal algebraic Big-O notation representing the asymptotic structural memory geometry."]
    pub space_complexity_class: SpaceComplexityClass,
    #[doc = "The formal algebraic Big-O notation mathematically bounding temporal execution limits (e.g., 'O(N)', 'O(V + E)', 'O(N^2)')."]
    pub time_complexity_class: TimeComplexityClass,
}
impl AsymptoticComplexityReceipt {
    pub fn builder() -> builder::AsymptoticComplexityReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative, frozen snapshot of a standalone, verifiable statement extracted from unstructured discourse. Transmutes probabilistic 'bags-of-words' into a discrete, traversable node within the Labeled Property Graph (LPG).\n\n    CAUSAL AFFORDANCE: Instructs the orchestrator to persist a verifiable statement as a discrete node within the LPG.\n\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\n\n    MCP ROUTING TRIGGERS: Atomic Proposition, Discourse Extraction, Labeled Property Graph, Verifiable Statement"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AtomicPropositionState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative, frozen snapshot of a standalone, verifiable statement extracted from unstructured discourse. Transmutes probabilistic 'bags-of-words' into a discrete, traversable node within the Labeled Property Graph (LPG).\\n\\n    CAUSAL AFFORDANCE: Instructs the orchestrator to persist a verifiable statement as a discrete node within the LPG.\\n\\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\\n\\n    MCP ROUTING TRIGGERS: Atomic Proposition, Discourse Extraction, Labeled Property Graph, Verifiable Statement\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"illocutionary_force\","]
#[doc = "    \"proposition_cid\","]
#[doc = "    \"rhetorical_role\","]
#[doc = "    \"text_chunk\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"anaphoric_resolution_cids\": {"]
#[doc = "      \"title\": \"Anaphoric Resolution Cids\","]
#[doc = "      \"description\": \"Explicit array of entity DIDs/CIDs resolving implicit references (e.g., pronouns) within the text chunk back to explicit nodes.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"illocutionary_force\": {"]
#[doc = "      \"description\": \"The intentional boundary defining the statement's truth condition.\","]
#[doc = "      \"$ref\": \"#/$defs/IllocutionaryForceProfile\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The RFC 8785 Canonical hash of the immediate causal ancestor, securing the Merkle-DAG.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"proposition_cid\": {"]
#[doc = "      \"title\": \"Proposition Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) bounding this specific extracted proposition.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"rhetorical_role\": {"]
#[doc = "      \"description\": \"The structural relationship of this proposition to its surrounding discourse.\","]
#[doc = "      \"$ref\": \"#/$defs/RhetoricalStructureProfile\""]
#[doc = "    },"]
#[doc = "    \"statistical_qualifiers\": {"]
#[doc = "      \"title\": \"Statistical Qualifiers\","]
#[doc = "      \"description\": \"Explicit mathematical boundaries extracted from the text that empirically limit the certainty or scope of the proposition.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EmpiricalStatisticalProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"text_chunk\": {"]
#[doc = "      \"title\": \"Text Chunk\","]
#[doc = "      \"description\": \"The raw, atomic natural language representation of the proposition. Volumetrically clamped to prevent VRAM overflow.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 50000"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"The precise temporal coordinate of the event realization.\","]
#[doc = "      \"type\": \"number\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"atomic_proposition\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AtomicPropositionState {
    #[doc = "Explicit array of entity DIDs/CIDs resolving implicit references (e.g., pronouns) within the text chunk back to explicit nodes."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub anaphoric_resolution_cids: ::std::vec::Vec<NodeCidState>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The intentional boundary defining the statement's truth condition."]
    pub illocutionary_force: IllocutionaryForceProfile,
    #[doc = "The RFC 8785 Canonical hash of the immediate causal ancestor, securing the Merkle-DAG."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "A Content Identifier (CID) bounding this specific extracted proposition."]
    pub proposition_cid: PropositionCid,
    #[doc = "The structural relationship of this proposition to its surrounding discourse."]
    pub rhetorical_role: RhetoricalStructureProfile,
    #[doc = "Explicit mathematical boundaries extracted from the text that empirically limit the certainty or scope of the proposition."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub statistical_qualifiers: ::std::vec::Vec<EmpiricalStatisticalProfile>,
    #[doc = "The raw, atomic natural language representation of the proposition. Volumetrically clamped to prevent VRAM overflow."]
    pub text_chunk: TextChunk,
    #[doc = "The precise temporal coordinate of the event realization."]
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl AtomicPropositionState {
    pub fn builder() -> builder::AtomicPropositionState {
        Default::default()
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this directed attack edge."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Attack Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this directed attack edge.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AttackCid(::std::string::String);
impl ::std::ops::Deref for AttackCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AttackCid> for ::std::string::String {
    fn from(value: AttackCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AttackCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AttackCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AttackCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AttackCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AttackCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`AttackVectorProfile`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"rebuttal\","]
#[doc = "    \"undercutter\","]
#[doc = "    \"underminer\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum AttackVectorProfile {
    #[serde(rename = "rebuttal")]
    Rebuttal,
    #[serde(rename = "undercutter")]
    Undercutter,
    #[serde(rename = "underminer")]
    Underminer,
}
impl ::std::fmt::Display for AttackVectorProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Rebuttal => f.write_str("rebuttal"),
            Self::Undercutter => f.write_str("undercutter"),
            Self::Underminer => f.write_str("underminer"),
        }
    }
}
impl ::std::str::FromStr for AttackVectorProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "rebuttal" => Ok(Self::Rebuttal),
            "undercutter" => Ok(Self::Undercutter),
            "underminer" => Ok(Self::Underminer),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for AttackVectorProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AttackVectorProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AttackVectorProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`AuctionMechanismProfile`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"sealed_bid\","]
#[doc = "    \"dutch\","]
#[doc = "    \"vickrey\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum AuctionMechanismProfile {
    #[serde(rename = "sealed_bid")]
    SealedBid,
    #[serde(rename = "dutch")]
    Dutch,
    #[serde(rename = "vickrey")]
    Vickrey,
}
impl ::std::fmt::Display for AuctionMechanismProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::SealedBid => f.write_str("sealed_bid"),
            Self::Dutch => f.write_str("dutch"),
            Self::Vickrey => f.write_str("vickrey"),
        }
    }
}
impl ::std::str::FromStr for AuctionMechanismProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "sealed_bid" => Ok(Self::SealedBid),
            "dutch" => Ok(Self::Dutch),
            "vickrey" => Ok(Self::Vickrey),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for AuctionMechanismProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AuctionMechanismProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AuctionMechanismProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the Algorithmic Mechanism Design for the decentralized spot market, establishing the exact rules of engagement (e.g., Vickrey-Clarke-Groves, Dutch, Sealed-Bid) to ensure truthful bidding.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator's clearinghouse on how to mathematically resolve the AuctionState, applying the strict `tie_breaker` heuristic when bid vectors collide.\n\nEPISTEMIC BOUNDS: Market lifespan is strictly restricted by `max_bidding_window_ms` (`le=18446744073709551615`). Combinatorial space is locked to the `AuctionMechanismProfile` and `TieBreakerPolicy` Literal enums.\n\nMCP ROUTING TRIGGERS: Algorithmic Mechanism Design, Vickrey-Clarke-Groves, Strategyproofness, Market Clearing Heuristic"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AuctionPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the Algorithmic Mechanism Design for the decentralized spot market, establishing the exact rules of engagement (e.g., Vickrey-Clarke-Groves, Dutch, Sealed-Bid) to ensure truthful bidding.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator's clearinghouse on how to mathematically resolve the AuctionState, applying the strict `tie_breaker` heuristic when bid vectors collide.\\n\\nEPISTEMIC BOUNDS: Market lifespan is strictly restricted by `max_bidding_window_ms` (`le=18446744073709551615`). Combinatorial space is locked to the `AuctionMechanismProfile` and `TieBreakerPolicy` Literal enums.\\n\\nMCP ROUTING TRIGGERS: Algorithmic Mechanism Design, Vickrey-Clarke-Groves, Strategyproofness, Market Clearing Heuristic\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"auction_type\","]
#[doc = "    \"max_bidding_window_ms\","]
#[doc = "    \"tie_breaker\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"auction_type\": {"]
#[doc = "      \"description\": \"The market mechanism governing the auction.\","]
#[doc = "      \"$ref\": \"#/$defs/AuctionMechanismProfile\""]
#[doc = "    },"]
#[doc = "    \"max_bidding_window_ms\": {"]
#[doc = "      \"title\": \"Max Bidding Window Ms\","]
#[doc = "      \"description\": \"The absolute timeout in milliseconds for nodes to submit proposals.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"tie_breaker\": {"]
#[doc = "      \"description\": \"The deterministic rule for resolving tied bids.\","]
#[doc = "      \"$ref\": \"#/$defs/TieBreakerPolicy\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AuctionPolicy {
    #[doc = "The market mechanism governing the auction."]
    pub auction_type: AuctionMechanismProfile,
    #[doc = "The absolute timeout in milliseconds for nodes to submit proposals."]
    pub max_bidding_window_ms: u64,
    #[doc = "The deterministic rule for resolving tied bids."]
    pub tie_breaker: TieBreakerPolicy,
}
impl AuctionPolicy {
    pub fn builder() -> builder::AuctionPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A frozen, declarative snapshot of the N-dimensional order book tracking the ongoing convergence of an algorithmic spot market auction.\n\nCAUSAL AFFORDANCE: Aggregates incoming AgentBidIntent vectors against the foundational TaskAnnouncementIntent, serving as the deterministic state space for the orchestrator's clearing function.\n\nEPISTEMIC BOUNDS: Market liveness is physically bounded by `clearing_timeout` (`le=18446744073709551615, gt=0`). `minimum_tick_size` is clamped (`gt=0`). The `bids` array is deterministically sorted by `estimated_cost_magnitude` (price) then `agent_cid` for RFC 8785 Hashing.\n\nMCP ROUTING TRIGGERS: Order Book Snapshot, Market Convergence, RFC 8785 Canonicalization, Liquidity Aggregation, Declarative Coordinate"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"AuctionState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A frozen, declarative snapshot of the N-dimensional order book tracking the ongoing convergence of an algorithmic spot market auction.\\n\\nCAUSAL AFFORDANCE: Aggregates incoming AgentBidIntent vectors against the foundational TaskAnnouncementIntent, serving as the deterministic state space for the orchestrator's clearing function.\\n\\nEPISTEMIC BOUNDS: Market liveness is physically bounded by `clearing_timeout` (`le=18446744073709551615, gt=0`). `minimum_tick_size` is clamped (`gt=0`). The `bids` array is deterministically sorted by `estimated_cost_magnitude` (price) then `agent_cid` for RFC 8785 Hashing.\\n\\nMCP ROUTING TRIGGERS: Order Book Snapshot, Market Convergence, RFC 8785 Canonicalization, Liquidity Aggregation, Declarative Coordinate\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"announcement\","]
#[doc = "    \"clearing_timeout\","]
#[doc = "    \"minimum_tick_size\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"announcement\": {"]
#[doc = "      \"description\": \"The original call for proposals.\","]
#[doc = "      \"$ref\": \"#/$defs/TaskAnnouncementIntent\""]
#[doc = "    },"]
#[doc = "    \"award\": {"]
#[doc = "      \"description\": \"The final cryptographic receipt of the auction, if resolved.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TaskAwardReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"bids\": {"]
#[doc = "      \"title\": \"Bids\","]
#[doc = "      \"description\": \"The array of received bids.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/AgentBidIntent\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"clearing_timeout\": {"]
#[doc = "      \"title\": \"Clearing Timeout\","]
#[doc = "      \"description\": \"Maximum wait time for auction settlement.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"minimum_tick_size\": {"]
#[doc = "      \"title\": \"Minimum Tick Size\","]
#[doc = "      \"description\": \"The smallest allowable discrete bid increment.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AuctionState {
    #[doc = "The original call for proposals."]
    pub announcement: TaskAnnouncementIntent,
    #[doc = "The final cryptographic receipt of the auction, if resolved."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub award: ::std::option::Option<TaskAwardReceipt>,
    #[doc = "The array of received bids."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub bids: ::std::vec::Vec<AgentBidIntent>,
    #[doc = "Maximum wait time for auction settlement."]
    pub clearing_timeout: ::std::num::NonZeroU64,
    #[doc = "The smallest allowable discrete bid increment."]
    pub minimum_tick_size: ::std::num::NonZeroU64,
}
impl AuctionState {
    pub fn builder() -> builder::AuctionState {
        Default::default()
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Audit Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AuditCid(::std::string::String);
impl ::std::ops::Deref for AuditCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AuditCid> for ::std::string::String {
    fn from(value: AuditCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AuditCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AuditCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AuditCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AuditCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AuditCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The exact Lineage Watermark of the agent or system that authored this state mutation."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Author Node Cid\","]
#[doc = "  \"description\": \"The exact Lineage Watermark of the agent or system that authored this state mutation.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AuthorNodeCid(::std::string::String);
impl ::std::ops::Deref for AuthorNodeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AuthorNodeCid> for ::std::string::String {
    fn from(value: AuthorNodeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AuthorNodeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AuthorNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AuthorNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AuthorNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AuthorNodeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`AuthorizedBytecodeHashesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AuthorizedBytecodeHashesItem(::std::string::String);
impl ::std::ops::Deref for AuthorizedBytecodeHashesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AuthorizedBytecodeHashesItem> for ::std::string::String {
    fn from(value: AuthorizedBytecodeHashesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AuthorizedBytecodeHashesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AuthorizedBytecodeHashesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AuthorizedBytecodeHashesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AuthorizedBytecodeHashesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AuthorizedBytecodeHashesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`AuthorizedCapabilityArrayItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct AuthorizedCapabilityArrayItem(::std::string::String);
impl ::std::ops::Deref for AuthorizedCapabilityArrayItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<AuthorizedCapabilityArrayItem> for ::std::string::String {
    fn from(value: AuthorizedCapabilityArrayItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for AuthorizedCapabilityArrayItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for AuthorizedCapabilityArrayItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for AuthorizedCapabilityArrayItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for AuthorizedCapabilityArrayItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for AuthorizedCapabilityArrayItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Queueing Theory and the Token Bucket algorithm to\nmathematically regulate the thermodynamic flow of compute across topological\nboundaries. As a ...Policy suffix, this defines rigid mathematical boundaries.\n\nCAUSAL AFFORDANCE: Forces the orchestrator to yield execution threads, shed load,\nor trip circuit breakers when temporal velocity (max_tokens_per_minute,\nmax_requests_per_minute) or spatial queues (max_queue_depth) reach physical\nsaturation. Optional token_budget_per_branch and max_concurrent_tool_invocations\nfurther constrain parallel execution.\n\nEPISTEMIC BOUNDS: Physical system limits are rigidly clamped by integer bounds\n(le=18446744073709551615) on max_queue_depth, token_budget_per_branch,\nmax_tokens_per_minute (gt=0), max_requests_per_minute (gt=0), and\nmax_concurrent_tool_invocations (gt=0). Temporal liveness is bounded by\nmax_uninterruptible_span_ms (le=18446744073709551615, gt=0). All rate fields are Optional\n(default=None).\n\nMCP ROUTING TRIGGERS: Queueing Theory, Token Bucket, Backpressure, Load\nShedding, Thermodynamic Flow Control"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"BackpressurePolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Queueing Theory and the Token Bucket algorithm to\\nmathematically regulate the thermodynamic flow of compute across topological\\nboundaries. As a ...Policy suffix, this defines rigid mathematical boundaries.\\n\\nCAUSAL AFFORDANCE: Forces the orchestrator to yield execution threads, shed load,\\nor trip circuit breakers when temporal velocity (max_tokens_per_minute,\\nmax_requests_per_minute) or spatial queues (max_queue_depth) reach physical\\nsaturation. Optional token_budget_per_branch and max_concurrent_tool_invocations\\nfurther constrain parallel execution.\\n\\nEPISTEMIC BOUNDS: Physical system limits are rigidly clamped by integer bounds\\n(le=18446744073709551615) on max_queue_depth, token_budget_per_branch,\\nmax_tokens_per_minute (gt=0), max_requests_per_minute (gt=0), and\\nmax_concurrent_tool_invocations (gt=0). Temporal liveness is bounded by\\nmax_uninterruptible_span_ms (le=18446744073709551615, gt=0). All rate fields are Optional\\n(default=None).\\n\\nMCP ROUTING TRIGGERS: Queueing Theory, Token Bucket, Backpressure, Load\\nShedding, Thermodynamic Flow Control\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_queue_depth\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_concurrent_tool_invocations\": {"]
#[doc = "      \"title\": \"Max Concurrent Tool Invocations\","]
#[doc = "      \"description\": \"The mathematical integer ceiling to prevent Sybil-like parallel mutations against the CognitiveActionSpaceManifest.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"exclusiveMinimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_queue_depth\": {"]
#[doc = "      \"title\": \"Max Queue Depth\","]
#[doc = "      \"description\": \"The maximum number of unprocessed messages/observations allowed between connected nodes before yielding.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"max_requests_per_minute\": {"]
#[doc = "      \"title\": \"Max Requests Per Minute\","]
#[doc = "      \"description\": \"The maximum kinetic velocity of API requests allowed.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"exclusiveMinimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_tokens_per_minute\": {"]
#[doc = "      \"title\": \"Max Tokens Per Minute\","]
#[doc = "      \"description\": \"The maximum kinetic velocity of token consumption allowed before the circuit breaker trips.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"exclusiveMinimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_uninterruptible_span_ms\": {"]
#[doc = "      \"title\": \"Max Uninterruptible Span Ms\","]
#[doc = "      \"description\": \"Systemic heartbeat constraint. A node cannot lock the thread longer than this without yielding to poll for BargeInInterruptEvents.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"exclusiveMinimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"token_budget_per_branch\": {"]
#[doc = "      \"title\": \"Token Budget Per Branch\","]
#[doc = "      \"description\": \"The maximum token cost allowed per execution branch before rate-limiting.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct BackpressurePolicy {
    #[doc = "The mathematical integer ceiling to prevent Sybil-like parallel mutations against the CognitiveActionSpaceManifest."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_concurrent_tool_invocations: ::std::option::Option<::std::num::NonZeroU64>,
    #[doc = "The maximum number of unprocessed messages/observations allowed between connected nodes before yielding."]
    pub max_queue_depth: u64,
    #[doc = "The maximum kinetic velocity of API requests allowed."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_requests_per_minute: ::std::option::Option<::std::num::NonZeroU64>,
    #[doc = "The maximum kinetic velocity of token consumption allowed before the circuit breaker trips."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_tokens_per_minute: ::std::option::Option<::std::num::NonZeroU64>,
    #[doc = "Systemic heartbeat constraint. A node cannot lock the thread longer than this without yielding to poll for BargeInInterruptEvents."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_uninterruptible_span_ms: ::std::option::Option<::std::num::NonZeroU64>,
    #[doc = "The maximum token cost allowed per execution branch before rate-limiting."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub token_budget_per_branch: ::std::option::Option<u64>,
}
impl BackpressurePolicy {
    pub fn builder() -> builder::BackpressurePolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Encodes an asynchronous hardware interrupt or exogenous sensory spike that forces a premature probability wave collapse on an active generation trajectory.\n\nCAUSAL AFFORDANCE: Physically severs the continuous multimodal sequence of the `target_event_cid`, injecting the `retained_partial_payload` into the Epistemic Quarantine and forcing the orchestrator to execute the `epistemic_disposition`.\n\nEPISTEMIC BOUNDS: Topologically anchored to `target_event_cid` via a strict 128-char CID regex. The `retained_partial_payload` is volumetrically clamped by the `enforce_payload_topology` hook to prevent VRAM exhaustion.\n\nMCP ROUTING TRIGGERS: Asynchronous Interrupt, Generative Severing, Context Switching, Defeasible Disposition, Wave Collapse"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"BargeInInterruptEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Encodes an asynchronous hardware interrupt or exogenous sensory spike that forces a premature probability wave collapse on an active generation trajectory.\\n\\nCAUSAL AFFORDANCE: Physically severs the continuous multimodal sequence of the `target_event_cid`, injecting the `retained_partial_payload` into the Epistemic Quarantine and forcing the orchestrator to execute the `epistemic_disposition`.\\n\\nEPISTEMIC BOUNDS: Topologically anchored to `target_event_cid` via a strict 128-char CID regex. The `retained_partial_payload` is volumetrically clamped by the `enforce_payload_topology` hook to prevent VRAM exhaustion.\\n\\nMCP ROUTING TRIGGERS: Asynchronous Interrupt, Generative Severing, Context Switching, Defeasible Disposition, Wave Collapse\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"epistemic_disposition\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"target_event_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"epistemic_disposition\": {"]
#[doc = "      \"title\": \"Epistemic Disposition\","]
#[doc = "      \"description\": \"Explicit instruction to the orchestrator on how to patch the shared state blackboard with the partial payload.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"discard\","]
#[doc = "        \"retain_as_context\","]
#[doc = "        \"mark_as_falsified\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"retained_partial_payload\": {"]
#[doc = "      \"title\": \"Retained Partial Payload\","]
#[doc = "      \"description\": \"The 'stutter' state: the incomplete fragment of thought or text appended before the kill signal. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"object\","]
#[doc = "          \"additionalProperties\": {"]
#[doc = "            \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"sensory_trigger\": {"]
#[doc = "      \"description\": \"The continuous multimodal trigger (e.g., audio spike, user saying 'stop') that justified the interruption.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EmbodiedSensoryVectorProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_event_cid\": {"]
#[doc = "      \"title\": \"Target Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the active node generation cycle that was killed in the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for a barge-in interruption event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"barge_in\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct BargeInInterruptEvent {
    #[doc = "Explicit instruction to the orchestrator on how to patch the shared state blackboard with the partial payload."]
    pub epistemic_disposition: EpistemicDisposition,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The 'stutter' state: the incomplete fragment of thought or text appended before the kill signal. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub retained_partial_payload: ::std::option::Option<RetainedPartialPayload>,
    #[doc = "The continuous multimodal trigger (e.g., audio spike, user saying 'stop') that justified the interruption."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub sensory_trigger: ::std::option::Option<EmbodiedSensoryVectorProfile>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the active node generation cycle that was killed in the Merkle-DAG."]
    pub target_event_cid: TargetEventCid,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "Discriminator type for a barge-in interruption event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl BargeInInterruptEvent {
    pub fn builder() -> builder::BargeInInterruptEvent {
        Default::default()
    }
}
#[doc = "The SHA-256 hash of the exact foundational model this adapter was mathematically trained against."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Base Model Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the exact foundational model this adapter was mathematically trained against.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct BaseModelHash(::std::string::String);
impl ::std::ops::Deref for BaseModelHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<BaseModelHash> for ::std::string::String {
    fn from(value: BaseModelHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for BaseModelHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for BaseModelHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for BaseModelHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for BaseModelHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for BaseModelHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"BeliefModulationReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"grounded_edges\","]
#[doc = "    \"receipt_cid\","]
#[doc = "    \"severed_edge_cids\","]
#[doc = "    \"target_graph_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"grounded_edges\": {"]
#[doc = "      \"title\": \"Grounded Edges\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/DempsterShaferBeliefVector\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"receipt_cid\": {"]
#[doc = "      \"title\": \"Receipt Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"severed_edge_cids\": {"]
#[doc = "      \"title\": \"Severed Edge Cids\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"target_graph_cid\": {"]
#[doc = "      \"title\": \"Target Graph Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"belief_modulation\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct BeliefModulationReceipt {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    pub grounded_edges:
        ::std::collections::HashMap<::std::string::String, DempsterShaferBeliefVector>,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    pub receipt_cid: ReceiptCid,
    pub severed_edge_cids: ::std::vec::Vec<SeveredEdgeCidsItem>,
    pub target_graph_cid: TargetGraphCid,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl BeliefModulationReceipt {
    pub fn builder() -> builder::BeliefModulationReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Bayesian Belief Updating and Pearlian Causal Tracing by synthesizing internal cognitive shifts into discrete, hashable facts.\n\nCAUSAL AFFORDANCE: Projects a synthesized conclusion into the shared topology, binding the new belief to `causal_attributions`.\n\nEPISTEMIC BOUNDS: Structural validation is enforced via nested schema instantiation. `payload` is volumetrically clamped by `@field_validator`. `quorum_signatures` prevents Sybil attacks via `@model_validator` `enforce_sybil_resistance`.\n\nMCP ROUTING TRIGGERS: Bayesian Belief Updating, Causal Tracing, Cognitive Synthesis, Merkle-DAG Coordinate, Non-Monotonic Leap"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"BeliefMutationEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Bayesian Belief Updating and Pearlian Causal Tracing by synthesizing internal cognitive shifts into discrete, hashable facts.\\n\\nCAUSAL AFFORDANCE: Projects a synthesized conclusion into the shared topology, binding the new belief to `causal_attributions`.\\n\\nEPISTEMIC BOUNDS: Structural validation is enforced via nested schema instantiation. `payload` is volumetrically clamped by `@field_validator`. `quorum_signatures` prevents Sybil attacks via `@model_validator` `enforce_sybil_resistance`.\\n\\nMCP ROUTING TRIGGERS: Bayesian Belief Updating, Causal Tracing, Cognitive Synthesis, Merkle-DAG Coordinate, Non-Monotonic Leap\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"payload\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"causal_attributions\": {"]
#[doc = "      \"title\": \"Causal Attributions\","]
#[doc = "      \"description\": \"Immutable audit trail of prior states that forced this specific cognitive synthesis.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/CausalAttributionState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"hardware_attestation\": {"]
#[doc = "      \"description\": \"The physical hardware root-of-trust proving this belief was synthesized in a secure enclave.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/HardwareEnclaveReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"neural_audit\": {"]
#[doc = "      \"description\": \"The mathematical brain-scan proving exactly which neural circuits fired to append this event.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NeuralAuditAttestationReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"payload\": {"]
#[doc = "      \"title\": \"Payload\","]
#[doc = "      \"description\": \"Topologically Bounded Latent Spaces capturing the semantic representation of the agent's internal cognitive shift or synthesis that anchor statistical probability to a definitive causal event hash. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"quorum_signatures\": {"]
#[doc = "      \"title\": \"Quorum Signatures\","]
#[doc = "      \"description\": \"The deterministic execution signatures from the peer nodes that validated this belief.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 10000"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"scratchpad_trace\": {"]
#[doc = "      \"description\": \"The cryptographic record of the non-monotonic internal monologue that justifies this belief.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/LatentScratchpadReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"source_node_cid\": {"]
#[doc = "      \"description\": \"The specific topological node that synthesized this belief assertion.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for a Belief Assertion event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"belief_mutation\""]
#[doc = "    },"]
#[doc = "    \"uncertainty_profile\": {"]
#[doc = "      \"description\": \"The mathematical quantification of doubt associated with this synthesized belief.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/CognitiveUncertaintyProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"zk_proof\": {"]
#[doc = "      \"description\": \"The mathematical attestation proving this belief synthesis was appended securely without model-downgrade fraud.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ZeroKnowledgeReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct BeliefMutationEvent {
    #[doc = "Immutable audit trail of prior states that forced this specific cognitive synthesis."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub causal_attributions: ::std::vec::Vec<CausalAttributionState>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The physical hardware root-of-trust proving this belief was synthesized in a secure enclave."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub hardware_attestation: ::std::option::Option<HardwareEnclaveReceipt>,
    #[doc = "The mathematical brain-scan proving exactly which neural circuits fired to append this event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub neural_audit: ::std::option::Option<NeuralAuditAttestationReceipt>,
    #[doc = "Topologically Bounded Latent Spaces capturing the semantic representation of the agent's internal cognitive shift or synthesis that anchor statistical probability to a definitive causal event hash. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    pub payload: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The deterministic execution signatures from the peer nodes that validated this belief."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub quorum_signatures: ::std::vec::Vec<QuorumSignaturesItem>,
    #[doc = "The cryptographic record of the non-monotonic internal monologue that justifies this belief."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub scratchpad_trace: ::std::option::Option<LatentScratchpadReceipt>,
    #[doc = "The specific topological node that synthesized this belief assertion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub source_node_cid: ::std::option::Option<NodeCidState>,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "Discriminator type for a Belief Assertion event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The mathematical quantification of doubt associated with this synthesized belief."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub uncertainty_profile: ::std::option::Option<CognitiveUncertaintyProfile>,
    #[doc = "The mathematical attestation proving this belief synthesis was appended securely without model-downgrade fraud."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub zk_proof: ::std::option::Option<ZeroKnowledgeReceipt>,
}
impl BeliefMutationEvent {
    pub fn builder() -> builder::BeliefMutationEvent {
        Default::default()
    }
}
#[doc = "Unique structural identifier for this geometric region."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Block Cid\","]
#[doc = "  \"description\": \"Unique structural identifier for this geometric region.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct BlockCid(::std::string::String);
impl ::std::ops::Deref for BlockCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<BlockCid> for ::std::string::String {
    fn from(value: BlockCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for BlockCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for BlockCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for BlockCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for BlockCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for BlockCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The taxonomic classification of the layout region."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Block Class\","]
#[doc = "  \"description\": \"The taxonomic classification of the layout region.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"header\","]
#[doc = "    \"paragraph\","]
#[doc = "    \"figure\","]
#[doc = "    \"table\","]
#[doc = "    \"footnote\","]
#[doc = "    \"caption\","]
#[doc = "    \"equation\","]
#[doc = "    \"list_item\","]
#[doc = "    \"code_block\","]
#[doc = "    \"form_field\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum BlockClass {
    #[serde(rename = "header")]
    Header,
    #[serde(rename = "paragraph")]
    Paragraph,
    #[serde(rename = "figure")]
    Figure,
    #[serde(rename = "table")]
    Table,
    #[serde(rename = "footnote")]
    Footnote,
    #[serde(rename = "caption")]
    Caption,
    #[serde(rename = "equation")]
    Equation,
    #[serde(rename = "list_item")]
    ListItem,
    #[serde(rename = "code_block")]
    CodeBlock,
    #[serde(rename = "form_field")]
    FormField,
}
impl ::std::fmt::Display for BlockClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Header => f.write_str("header"),
            Self::Paragraph => f.write_str("paragraph"),
            Self::Figure => f.write_str("figure"),
            Self::Table => f.write_str("table"),
            Self::Footnote => f.write_str("footnote"),
            Self::Caption => f.write_str("caption"),
            Self::Equation => f.write_str("equation"),
            Self::ListItem => f.write_str("list_item"),
            Self::CodeBlock => f.write_str("code_block"),
            Self::FormField => f.write_str("form_field"),
        }
    }
}
impl ::std::str::FromStr for BlockClass {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "header" => Ok(Self::Header),
            "paragraph" => Ok(Self::Paragraph),
            "figure" => Ok(Self::Figure),
            "table" => Ok(Self::Table),
            "footnote" => Ok(Self::Footnote),
            "caption" => Ok(Self::Caption),
            "equation" => Ok(Self::Equation),
            "list_item" => Ok(Self::ListItem),
            "code_block" => Ok(Self::CodeBlock),
            "form_field" => Ok(Self::FormField),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for BlockClass {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for BlockClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for BlockClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The unique CID anchoring the start of the speculative execution branch."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Boundary Cid\","]
#[doc = "  \"description\": \"The unique CID anchoring the start of the speculative execution branch.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct BoundaryCid(::std::string::String);
impl ::std::ops::Deref for BoundaryCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<BoundaryCid> for ::std::string::String {
    fn from(value: BoundaryCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for BoundaryCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for BoundaryCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for BoundaryCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for BoundaryCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for BoundaryCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes the Principle of Least Privilege (PoLP) to\ngeometrically restrict the structural mutation surface available to a human or\nexternal oracle. As a ...Policy suffix, this defines rigid mathematical\nboundaries.\n\nCAUSAL AFFORDANCE: Provides a deterministic mathematical mask over the\nEpistemicLedgerState, guaranteeing that the external operator can only perturb\nthe graph at explicitly whitelisted JSON Pointers via allowed_fields.\n\nEPISTEMIC BOUNDS: The `json_schema_whitelist` is physically restricted by the\n`enforce_payload_topology` validator to prevent algorithmic complexity attacks\nduring schema intersection. The `allowed_fields` are deterministically sorted.\n\nMCP ROUTING TRIGGERS: Principle of Least Privilege, State Mutation Masking,\nZero-Trust Architecture, RFC 8785 Canonicalization, Bounded Surface Area"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"BoundedInterventionScopePolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes the Principle of Least Privilege (PoLP) to\\ngeometrically restrict the structural mutation surface available to a human or\\nexternal oracle. As a ...Policy suffix, this defines rigid mathematical\\nboundaries.\\n\\nCAUSAL AFFORDANCE: Provides a deterministic mathematical mask over the\\nEpistemicLedgerState, guaranteeing that the external operator can only perturb\\nthe graph at explicitly whitelisted JSON Pointers via allowed_fields.\\n\\nEPISTEMIC BOUNDS: The `json_schema_whitelist` is physically restricted by the\\n`enforce_payload_topology` validator to prevent algorithmic complexity attacks\\nduring schema intersection. The `allowed_fields` are deterministically sorted.\\n\\nMCP ROUTING TRIGGERS: Principle of Least Privilege, State Mutation Masking,\\nZero-Trust Architecture, RFC 8785 Canonicalization, Bounded Surface Area\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"allowed_fields\","]
#[doc = "    \"json_schema_whitelist\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"allowed_fields\": {"]
#[doc = "      \"title\": \"Allowed Fields\","]
#[doc = "      \"description\": \"The explicit whitelist of top-level JSON pointers mathematically open to mutation.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000"]
#[doc = "    },"]
#[doc = "    \"json_schema_whitelist\": {"]
#[doc = "      \"title\": \"Json Schema Whitelist\","]
#[doc = "      \"description\": \"Strict JSON Schema constraints for the human's input. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct BoundedInterventionScopePolicy {
    #[doc = "The explicit whitelist of top-level JSON pointers mathematically open to mutation."]
    pub allowed_fields: ::std::vec::Vec<AllowedFieldsItem>,
    #[doc = "Strict JSON Schema constraints for the human's input. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    pub json_schema_whitelist:
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
}
impl BoundedInterventionScopePolicy {
    pub fn builder() -> builder::BoundedInterventionScopePolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"BoundedJSONRPCIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"jsonrpc\","]
#[doc = "    \"method\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"id\": {"]
#[doc = "      \"title\": \"Id\","]
#[doc = "      \"description\": \"Unique request identifier.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"jsonrpc\": {"]
#[doc = "      \"title\": \"Jsonrpc\","]
#[doc = "      \"description\": \"JSON-RPC version.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"2.0\""]
#[doc = "    },"]
#[doc = "    \"method\": {"]
#[doc = "      \"title\": \"Method\","]
#[doc = "      \"description\": \"Method to be invoked.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 1000"]
#[doc = "    },"]
#[doc = "    \"params\": {"]
#[doc = "      \"title\": \"Params\","]
#[doc = "      \"description\": \"Payload parameters. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"object\","]
#[doc = "          \"maxProperties\": 86400000,"]
#[doc = "          \"additionalProperties\": {"]
#[doc = "            \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"bounded_json_rpc_intent\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct BoundedJsonrpcIntent {
    #[doc = "Unique request identifier."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub id: ::std::option::Option<Id>,
    #[doc = "JSON-RPC version."]
    pub jsonrpc: ::std::string::String,
    #[doc = "Method to be invoked."]
    pub method: Method,
    #[doc = "Payload parameters. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub params: ::std::option::Option<
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    >,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl BoundedJsonrpcIntent {
    pub fn builder() -> builder::BoundedJsonrpcIntent {
        Default::default()
    }
}
#[doc = "A deterministic capability pointer bounding this specific topological divergence in the Latent Scratchpad Trace."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Branch Cid\","]
#[doc = "  \"description\": \"A deterministic capability pointer bounding this specific topological divergence in the Latent Scratchpad Trace.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct BranchCid(::std::string::String);
impl ::std::ops::Deref for BranchCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<BranchCid> for ::std::string::String {
    fn from(value: BranchCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for BranchCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for BranchCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for BranchCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for BranchCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for BranchCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the exogenous structural boundary of a headless browser environment within a Partially Observable Markov Decision Process (POMDP).\n\nCAUSAL AFFORDANCE: Exposes the deterministic coordinate space (`viewport_size`, `dom_hash`, `accessibility_tree_hash`) enabling spatial kinematics and visual grounding.\n\nEPISTEMIC BOUNDS: `dom_hash` rigidly locked to SHA-256 pattern.\n\nMCP ROUTING TRIGGERS: Exogenous Perturbation, DOM Topography, Spatial Execution Bound, Accessibility Tree"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"BrowserDOMState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the exogenous structural boundary of a headless browser environment within a Partially Observable Markov Decision Process (POMDP).\\n\\nCAUSAL AFFORDANCE: Exposes the deterministic coordinate space (`viewport_size`, `dom_hash`, `accessibility_tree_hash`) enabling spatial kinematics and visual grounding.\\n\\nEPISTEMIC BOUNDS: `dom_hash` rigidly locked to SHA-256 pattern.\\n\\nMCP ROUTING TRIGGERS: Exogenous Perturbation, DOM Topography, Spatial Execution Bound, Accessibility Tree\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"accessibility_tree_hash\","]
#[doc = "    \"current_url\","]
#[doc = "    \"dom_hash\","]
#[doc = "    \"viewport_size\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"accessibility_tree_hash\": {"]
#[doc = "      \"title\": \"Accessibility Tree Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the accessibility tree defining Exogenous Perturbations to the state space.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"current_url\": {"]
#[doc = "      \"title\": \"Current Url\","]
#[doc = "      \"description\": \"Spatial Execution Bounds where the agent interacts.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"dom_hash\": {"]
#[doc = "      \"title\": \"Dom Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash acting as the structural manifestation vector.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"screenshot_cid\": {"]
#[doc = "      \"title\": \"Screenshot Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the snapshot representation.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for Causal Actuators representing structural shifts.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"browser\""]
#[doc = "    },"]
#[doc = "    \"viewport_size\": {"]
#[doc = "      \"title\": \"Viewport Size\","]
#[doc = "      \"description\": \"Capability Perimeters detailing bounding coordinates.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"maxItems\": 1000,"]
#[doc = "      \"minItems\": 2,"]
#[doc = "      \"prefixItems\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct BrowserDomState {
    #[doc = "The SHA-256 hash of the accessibility tree defining Exogenous Perturbations to the state space."]
    pub accessibility_tree_hash: AccessibilityTreeHash,
    #[doc = "Spatial Execution Bounds where the agent interacts."]
    pub current_url: CurrentUrl,
    #[doc = "The SHA-256 hash acting as the structural manifestation vector."]
    pub dom_hash: DomHash,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the snapshot representation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub screenshot_cid: ::std::option::Option<::std::string::String>,
    #[doc = "Discriminator for Causal Actuators representing structural shifts."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "Capability Perimeters detailing bounding coordinates."]
    pub viewport_size: ::std::vec::Vec<::serde_json::Value>,
}
impl BrowserDomState {
    pub fn builder() -> builder::BrowserDomState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents the definitive algorithmic circuit breaker (Optimal Stopping boundary) triggered the exact millisecond thermodynamic token burn mathematically exceeds the locked Proof-of-Stake escrow.\n\nCAUSAL AFFORDANCE: Instantly collapses the active Latent Scratchpad trajectory and physically severs the kinetic execution loop, preventing Sybil griefing attacks against the swarm's compute pool.\n\nEPISTEMIC BOUNDS: Cryptographically targets the specific `exhausted_escrow_cid` and the exact `final_burn_receipt_cid` (CID regex) that pushed the thermodynamic ledger into a negative state, providing an undeniable audit trail.\n\nMCP ROUTING TRIGGERS: Optimal Stopping Theory, Escrow Exhaustion, Sybil Resistance, Algorithmic Circuit Breaker, Generation Halting"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"BudgetExhaustionEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents the definitive algorithmic circuit breaker (Optimal Stopping boundary) triggered the exact millisecond thermodynamic token burn mathematically exceeds the locked Proof-of-Stake escrow.\\n\\nCAUSAL AFFORDANCE: Instantly collapses the active Latent Scratchpad trajectory and physically severs the kinetic execution loop, preventing Sybil griefing attacks against the swarm's compute pool.\\n\\nEPISTEMIC BOUNDS: Cryptographically targets the specific `exhausted_escrow_cid` and the exact `final_burn_receipt_cid` (CID regex) that pushed the thermodynamic ledger into a negative state, providing an undeniable audit trail.\\n\\nMCP ROUTING TRIGGERS: Optimal Stopping Theory, Escrow Exhaustion, Sybil Resistance, Algorithmic Circuit Breaker, Generation Halting\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"exhausted_escrow_cid\","]
#[doc = "    \"final_burn_receipt_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"exhausted_escrow_cid\": {"]
#[doc = "      \"title\": \"Exhausted Escrow Cid\","]
#[doc = "      \"description\": \"A string representing the original escrow boundary breached.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"final_burn_receipt_cid\": {"]
#[doc = "      \"title\": \"Final Burn Receipt Cid\","]
#[doc = "      \"description\": \"A string pointing to the exact TokenBurnReceipt CID that pushed the state over the limit.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for a budget exhaustion event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"budget_exhaustion\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct BudgetExhaustionEvent {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "A string representing the original escrow boundary breached."]
    pub exhausted_escrow_cid: ExhaustedEscrowCid,
    #[doc = "A string pointing to the exact TokenBurnReceipt CID that pushed the state over the limit."]
    pub final_burn_receipt_cid: FinalBurnReceiptCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "Discriminator type for a budget exhaustion event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl BudgetExhaustionEvent {
    pub fn builder() -> builder::BudgetExhaustionEvent {
        Default::default()
    }
}
#[doc = "A content-addressed SHA-256 hash of a deterministic artifact bundle (e.g., an Action Space MCP server, an OHDSI Circe cohort definition JSON, or any RFC 8785 canonicalizable resource), enabling zero-trust verification and distributed exchangeability across federated boundaries."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"description\": \"A content-addressed SHA-256 hash of a deterministic artifact bundle (e.g., an Action Space MCP server, an OHDSI Circe cohort definition JSON, or any RFC 8785 canonicalizable resource), enabling zero-trust verification and distributed exchangeability across federated boundaries.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^sha256:[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct BundleContentHashState(::std::string::String);
impl ::std::ops::Deref for BundleContentHashState {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<BundleContentHashState> for ::std::string::String {
    fn from(value: BundleContentHashState) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for BundleContentHashState {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^sha256:[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^sha256:[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for BundleContentHashState {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for BundleContentHashState {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for BundleContentHashState {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for BundleContentHashState {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Acts as a Cryptographic Null-Operator within Kahn's\nTopological Sort, preserving the topological chain of custody when an\nextraction node is intentionally skipped. As a ...Receipt suffix, this is an\nappend-only coordinate that the LLM must never mutate.\n\nCAUSAL AFFORDANCE: Safely starves a subgraph of compute without fracturing\nthe continuous Merkle-DAG hash chain. The bypassed_node_cid\n(NodeCIDState) identifies the exact starved vertex. The\nartifact_event_cid (128-char CID) ensures continuity with the genesis artifact.\n\nEPISTEMIC BOUNDS: The cryptographic_null_hash strictly requires a 64-char\nSHA-256 fingerprint (^[a-f0-9]{64}$). The execution skip rationale is\nmathematically locked to the justification Literal automaton\n[\"modality_mismatch\", \"budget_exhaustion\", \"sla_timeout\"], preventing\nhallucinated bypass reasons.\n\nMCP ROUTING TRIGGERS: Topological Sort, Cryptographic Null-Operator, Compute\nStarvation, DAG Integrity, Lazy Evaluation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"BypassReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Acts as a Cryptographic Null-Operator within Kahn's\\nTopological Sort, preserving the topological chain of custody when an\\nextraction node is intentionally skipped. As a ...Receipt suffix, this is an\\nappend-only coordinate that the LLM must never mutate.\\n\\nCAUSAL AFFORDANCE: Safely starves a subgraph of compute without fracturing\\nthe continuous Merkle-DAG hash chain. The bypassed_node_cid\\n(NodeCIDState) identifies the exact starved vertex. The\\nartifact_event_cid (128-char CID) ensures continuity with the genesis artifact.\\n\\nEPISTEMIC BOUNDS: The cryptographic_null_hash strictly requires a 64-char\\nSHA-256 fingerprint (^[a-f0-9]{64}$). The execution skip rationale is\\nmathematically locked to the justification Literal automaton\\n[\\\"modality_mismatch\\\", \\\"budget_exhaustion\\\", \\\"sla_timeout\\\"], preventing\\nhallucinated bypass reasons.\\n\\nMCP ROUTING TRIGGERS: Topological Sort, Cryptographic Null-Operator, Compute\\nStarvation, DAG Integrity, Lazy Evaluation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"artifact_event_cid\","]
#[doc = "    \"bypassed_node_cid\","]
#[doc = "    \"cryptographic_null_hash\","]
#[doc = "    \"justification\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"artifact_event_cid\": {"]
#[doc = "      \"title\": \"Artifact Event Cid\","]
#[doc = "      \"description\": \"The exact genesis globally unique decentralized identifier (DID) anchoring the document, ensuring continuity.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"bypassed_node_cid\": {"]
#[doc = "      \"description\": \"The exact extraction step in the DAG that was mathematically starved of compute.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"cryptographic_null_hash\": {"]
#[doc = "      \"title\": \"Cryptographic Null Hash\","]
#[doc = "      \"description\": \"The SHA-256 null-hash representing the skipped state to satisfy the Epistemic Ledger.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"The deterministic reason the orchestrator severed this execution branch.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"modality_mismatch\","]
#[doc = "        \"budget_exhaustion\","]
#[doc = "        \"sla_timeout\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct BypassReceipt {
    #[doc = "The exact genesis globally unique decentralized identifier (DID) anchoring the document, ensuring continuity."]
    pub artifact_event_cid: ArtifactEventCid,
    #[doc = "The exact extraction step in the DAG that was mathematically starved of compute."]
    pub bypassed_node_cid: NodeCidState,
    #[doc = "The SHA-256 null-hash representing the skipped state to satisfy the Epistemic Ledger."]
    pub cryptographic_null_hash: CryptographicNullHash,
    #[doc = "The deterministic reason the orchestrator severed this execution branch."]
    pub justification: Justification,
}
impl BypassReceipt {
    pub fn builder() -> builder::BypassReceipt {
        Default::default()
    }
}
#[doc = "The undeniable SHA-256 hash of the pre-transmutation byte stream."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Byte Stream Hash\","]
#[doc = "  \"description\": \"The undeniable SHA-256 hash of the pre-transmutation byte stream.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ByteStreamHash(::std::string::String);
impl ::std::ops::Deref for ByteStreamHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ByteStreamHash> for ::std::string::String {
    fn from(value: ByteStreamHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ByteStreamHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ByteStreamHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ByteStreamHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ByteStreamHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ByteStreamHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The deterministic punishment executed by the orchestrator against nodes that violate the consensus quorum."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Byzantine Action\","]
#[doc = "  \"description\": \"The deterministic punishment executed by the orchestrator against nodes that violate the consensus quorum.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"quarantine\","]
#[doc = "    \"slash_escrow\","]
#[doc = "    \"ignore\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ByzantineAction {
    #[serde(rename = "quarantine")]
    Quarantine,
    #[serde(rename = "slash_escrow")]
    SlashEscrow,
    #[serde(rename = "ignore")]
    Ignore,
}
impl ::std::fmt::Display for ByzantineAction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Quarantine => f.write_str("quarantine"),
            Self::SlashEscrow => f.write_str("slash_escrow"),
            Self::Ignore => f.write_str("ignore"),
        }
    }
}
impl ::std::str::FromStr for ByzantineAction {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "quarantine" => Ok(Self::Quarantine),
            "slash_escrow" => Ok(Self::SlashEscrow),
            "ignore" => Ok(Self::Ignore),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ByzantineAction {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ByzantineAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ByzantineAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`CapabilitiesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CapabilitiesItem(::std::string::String);
impl ::std::ops::Deref for CapabilitiesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CapabilitiesItem> for ::std::string::String {
    fn from(value: CapabilitiesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CapabilitiesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CapabilitiesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CapabilitiesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CapabilitiesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CapabilitiesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The exact 128-char physical DID referencing the algorithmic payload evaluated."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Capability Cid\","]
#[doc = "  \"description\": \"The exact 128-char physical DID referencing the algorithmic payload evaluated.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CapabilityCid(::std::string::String);
impl ::std::ops::Deref for CapabilityCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CapabilityCid> for ::std::string::String {
    fn from(value: CapabilityCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CapabilityCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CapabilityCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CapabilityCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CapabilityCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CapabilityCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Create a zero-cost macro abstraction that unrolls the entire Zero-to-One generation, verification, and profiling loop.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator to physically bind the ephemeral tool-creation workflow into a rigid DAG topology, enabling full cryptographic observability over the dynamic synthesis of capabilities.\n\nEPISTEMIC BOUNDS: Binds the execution state to a closed, finite mathematical matrix where every constituent node (generator, fuzzer, profiler) must resolve before the final capability is materialized onto the Hollow Data Plane.\n\nMCP ROUTING TRIGGERS: Tool Synthesis, Capability Generation, Verification Matrix, Ephemeral Execution, Macro Topology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CapabilityForgeTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Create a zero-cost macro abstraction that unrolls the entire Zero-to-One generation, verification, and profiling loop.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator to physically bind the ephemeral tool-creation workflow into a rigid DAG topology, enabling full cryptographic observability over the dynamic synthesis of capabilities.\\n\\nEPISTEMIC BOUNDS: Binds the execution state to a closed, finite mathematical matrix where every constituent node (generator, fuzzer, profiler) must resolve before the final capability is materialized onto the Hollow Data Plane.\\n\\nMCP ROUTING TRIGGERS: Tool Synthesis, Capability Generation, Verification Matrix, Ephemeral Execution, Macro Topology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"formal_verifier_cid\","]
#[doc = "    \"fuzzing_engine_cid\","]
#[doc = "    \"generator_node_cid\","]
#[doc = "    \"nodes\","]
#[doc = "    \"target_epistemic_deficit\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"epistemic_enforcement\": {"]
#[doc = "      \"description\": \"Ties the topology to the Truth Maintenance layer.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TruthMaintenancePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"formal_verifier_cid\": {"]
#[doc = "      \"description\": \"The formal verifier system node.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"fuzzing_engine_cid\": {"]
#[doc = "      \"description\": \"The fuzzing engine system node.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"generator_node_cid\": {"]
#[doc = "      \"description\": \"The agent writing the code.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"human_supervisor_cid\": {"]
#[doc = "      \"description\": \"The W3C DID of the human oracle required to cryptographically sign off on the forged capability.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"isometry_verification\": {"]
#[doc = "      \"description\": \"The final behavioral verification of the forged capability.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TeleologicalIsometryReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this topology's configuration.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"lifecycle_phase\": {"]
#[doc = "      \"title\": \"Lifecycle Phase\","]
#[doc = "      \"description\": \"The execution phase of the graph. 'draft' allows incomplete structural state.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"draft\","]
#[doc = "        \"live\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"nodes\": {"]
#[doc = "      \"title\": \"Nodes\","]
#[doc = "      \"description\": \"Flat registry of all nodes in this topology.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyNodeProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"observability\": {"]
#[doc = "      \"description\": \"The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ObservabilityLODPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"semantic_flow\": {"]
#[doc = "      \"description\": \"The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticFlowPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"shared_state_contract\": {"]
#[doc = "      \"description\": \"The schema-on-write contract governing the internal state of this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StateContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_epistemic_deficit\": {"]
#[doc = "      \"description\": \"The target epistemic deficit.\","]
#[doc = "      \"$ref\": \"#/$defs/SemanticDiscoveryIntent\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for forge macro.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"macro_forge\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CapabilityForgeTopologyManifest {
    #[doc = "The AI's declarative rationale for selecting this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "Ties the topology to the Truth Maintenance layer."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_enforcement: ::std::option::Option<TruthMaintenancePolicy>,
    #[doc = "The formal verifier system node."]
    pub formal_verifier_cid: NodeCidState,
    #[doc = "The fuzzing engine system node."]
    pub fuzzing_engine_cid: NodeCidState,
    #[doc = "The agent writing the code."]
    pub generator_node_cid: NodeCidState,
    #[doc = "The W3C DID of the human oracle required to cryptographically sign off on the forged capability."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub human_supervisor_cid: ::std::option::Option<NodeCidState>,
    #[doc = "The final behavioral verification of the forged capability."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub isometry_verification: ::std::option::Option<TeleologicalIsometryReceipt>,
    #[doc = "Cryptographic/audit justification for this topology's configuration."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The execution phase of the graph. 'draft' allows incomplete structural state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub lifecycle_phase: ::std::option::Option<LifecyclePhase>,
    #[doc = "Flat registry of all nodes in this topology."]
    pub nodes: ::std::collections::HashMap<::std::string::String, AnyNodeProfile>,
    #[doc = "The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub observability: ::std::option::Option<ObservabilityLodPolicy>,
    #[doc = "The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_flow: ::std::option::Option<SemanticFlowPolicy>,
    #[doc = "The schema-on-write contract governing the internal state of this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub shared_state_contract: ::std::option::Option<StateContract>,
    #[doc = "The target epistemic deficit."]
    pub target_epistemic_deficit: SemanticDiscoveryIntent,
    #[doc = "Discriminator for forge macro."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl CapabilityForgeTopologyManifest {
    pub fn builder() -> builder::CapabilityForgeTopologyManifest {
        Default::default()
    }
}
#[doc = "The SHA-256 Merkle root of the agent's verified semantic capabilities."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Capability Merkle Root\","]
#[doc = "  \"description\": \"The SHA-256 Merkle root of the agent's verified semantic capabilities.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CapabilityMerkleRoot(::std::string::String);
impl ::std::ops::Deref for CapabilityMerkleRoot {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CapabilityMerkleRoot> for ::std::string::String {
    fn from(value: CapabilityMerkleRoot) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CapabilityMerkleRoot {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CapabilityMerkleRoot {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CapabilityMerkleRoot {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CapabilityMerkleRoot {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CapabilityMerkleRoot {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A cryptographically deterministic capability pointer binding the agent to a verifiable spatial environment."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"description\": \"A cryptographically deterministic capability pointer binding the agent to a verifiable spatial environment.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CapabilityPointerState(::std::string::String);
impl ::std::ops::Deref for CapabilityPointerState {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CapabilityPointerState> for ::std::string::String {
    fn from(value: CapabilityPointerState) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CapabilityPointerState {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CapabilityPointerState {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CapabilityPointerState {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CapabilityPointerState {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CapabilityPointerState {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this automated truth maintenance operation."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Cascade Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this automated truth maintenance operation.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CascadeCid(::std::string::String);
impl ::std::ops::Deref for CascadeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CascadeCid> for ::std::string::String {
    fn from(value: CascadeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CascadeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CascadeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CascadeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CascadeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CascadeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`CategoricalCohortsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CategoricalCohortsItem(::std::string::String);
impl ::std::ops::Deref for CategoricalCohortsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CategoricalCohortsItem> for ::std::string::String {
    fn from(value: CategoricalCohortsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CategoricalCohortsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CategoricalCohortsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CategoricalCohortsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CategoricalCohortsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CategoricalCohortsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Pearlian causal tracing, linking a localized cognitive\nsynthesis back to its historical Merkle-DAG origin. As a ...State suffix, this is a\ndeclarative, frozen snapshot of a causal connection at a point in time.\n\nCAUSAL AFFORDANCE: Authorizes the assignment of fractional attention or influence\nweights to prior events, establishing a Directed Acyclic Graph (DAG) of causal lineage.\n\nEPISTEMIC BOUNDS: The influence_weight is mathematically bounded to a continuous\nprobability distribution (ge=0.0, le=1.0). The source_event_cid is locked to a 128-char\nCID regex (^[a-zA-Z0-9_.:-]+$).\n\nMCP ROUTING TRIGGERS: Pearlian Causal Tracing, Directed Acyclic Graph, Causal Lineage,\nAttention Weighting, Influence Distribution"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CausalAttributionState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Pearlian causal tracing, linking a localized cognitive\\nsynthesis back to its historical Merkle-DAG origin. As a ...State suffix, this is a\\ndeclarative, frozen snapshot of a causal connection at a point in time.\\n\\nCAUSAL AFFORDANCE: Authorizes the assignment of fractional attention or influence\\nweights to prior events, establishing a Directed Acyclic Graph (DAG) of causal lineage.\\n\\nEPISTEMIC BOUNDS: The influence_weight is mathematically bounded to a continuous\\nprobability distribution (ge=0.0, le=1.0). The source_event_cid is locked to a 128-char\\nCID regex (^[a-zA-Z0-9_.:-]+$).\\n\\nMCP ROUTING TRIGGERS: Pearlian Causal Tracing, Directed Acyclic Graph, Causal Lineage,\\nAttention Weighting, Influence Distribution\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"influence_weight\","]
#[doc = "    \"source_event_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"influence_weight\": {"]
#[doc = "      \"title\": \"Influence Weight\","]
#[doc = "      \"description\": \"The mathematical attention/importance weight (0.0 to 1.0) assigned to this source by the agent.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"source_event_cid\": {"]
#[doc = "      \"title\": \"Source Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the source event in the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CausalAttributionState {
    #[doc = "The mathematical attention/importance weight (0.0 to 1.0) assigned to this source by the agent."]
    pub influence_weight: f64,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the source event in the Merkle-DAG."]
    pub source_event_cid: SourceEventCid,
}
impl CausalAttributionState {
    pub fn builder() -> builder::CausalAttributionState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Judea Pearl's Structural Causal Models (SCMs)\nand d-separation mechanics to map exact topological relationships between\nvariables. As a ...State suffix, this is a frozen, declarative connection\nvector.\n\nCAUSAL AFFORDANCE: Empowers the orchestrator's traversal engine to construct\ninterventional graphs for the Do-Operator (P(y|do(x))), isolating direct\ncauses from latent confounders during active inference or counterfactual\nregret simulation.\n\nEPISTEMIC BOUNDS: The edge_class physically restricts topological connections\nto the Pearlian Literal automaton [\"direct_cause\", \"confounder\", \"collider\",\n\"mediator\"]. The source_variable and target_variable are bounded by\nmin_length=1 (no max_length) to prevent ghost pointer allocation.\n\nMCP ROUTING TRIGGERS: Structural Causal Models, Pearlian Causality,\nd-separation, Do-Calculus, Directed Edge"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CausalDirectedEdgeState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Judea Pearl's Structural Causal Models (SCMs)\\nand d-separation mechanics to map exact topological relationships between\\nvariables. As a ...State suffix, this is a frozen, declarative connection\\nvector.\\n\\nCAUSAL AFFORDANCE: Empowers the orchestrator's traversal engine to construct\\ninterventional graphs for the Do-Operator (P(y|do(x))), isolating direct\\ncauses from latent confounders during active inference or counterfactual\\nregret simulation.\\n\\nEPISTEMIC BOUNDS: The edge_class physically restricts topological connections\\nto the Pearlian Literal automaton [\\\"direct_cause\\\", \\\"confounder\\\", \\\"collider\\\",\\n\\\"mediator\\\"]. The source_variable and target_variable are bounded by\\nmin_length=1 (no max_length) to prevent ghost pointer allocation.\\n\\nMCP ROUTING TRIGGERS: Structural Causal Models, Pearlian Causality,\\nd-separation, Do-Calculus, Directed Edge\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"edge_class\","]
#[doc = "    \"predicate_curie\","]
#[doc = "    \"source_variable\","]
#[doc = "    \"target_variable\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"belief_vector\": {"]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/DempsterShaferBeliefVector\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"edge_class\": {"]
#[doc = "      \"title\": \"Edge Class\","]
#[doc = "      \"description\": \"The specific Pearlian topological relationship between the two variables.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"direct_cause\","]
#[doc = "        \"confounder\","]
#[doc = "        \"collider\","]
#[doc = "        \"mediator\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"grounding_sla\": {"]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EvidentiaryGroundingSLA\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"predicate_curie\": {"]
#[doc = "      \"title\": \"Predicate Curie\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$\","]
#[doc = "      \"rdf_edge_property\": true"]
#[doc = "    },"]
#[doc = "    \"source_variable\": {"]
#[doc = "      \"title\": \"Source Variable\","]
#[doc = "      \"description\": \"The independent variable $X$.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255,"]
#[doc = "      \"minLength\": 1"]
#[doc = "    },"]
#[doc = "    \"target_variable\": {"]
#[doc = "      \"title\": \"Target Variable\","]
#[doc = "      \"description\": \"The dependent variable $Y$.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255,"]
#[doc = "      \"minLength\": 1"]
#[doc = "    },"]
#[doc = "    \"volumetric_geometry\": {"]
#[doc = "      \"description\": \"The continuous parametric spline defining the physical connection manifold.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/VolumetricEdgeProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CausalDirectedEdgeState {
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub belief_vector: ::std::option::Option<DempsterShaferBeliefVector>,
    #[doc = "The specific Pearlian topological relationship between the two variables."]
    pub edge_class: EdgeClass,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub grounding_sla: ::std::option::Option<EvidentiaryGroundingSla>,
    pub predicate_curie: PredicateCurie,
    #[doc = "The independent variable $X$."]
    pub source_variable: SourceVariable,
    #[doc = "The dependent variable $Y$."]
    pub target_variable: TargetVariable,
    #[doc = "The continuous parametric spline defining the physical connection manifold."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub volumetric_geometry: ::std::option::Option<VolumetricEdgeProfile>,
}
impl CausalDirectedEdgeState {
    pub fn builder() -> builder::CausalDirectedEdgeState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the\nmacroscopic factorization of a collective swarm outcome into its constituent causal\ncomponents. As an ...Event suffix, this is an append-only coordinate on the\nMerkle-DAG.\n\nCAUSAL AFFORDANCE: Commits the system-level CollectiveIntelligenceProfile and the\nindividual ShapleyAttributionReceipt array to the Epistemic Ledger, finalizing the\ncredit assignment for a target_outcome_event_cid.\n\nEPISTEMIC BOUNDS: The target_outcome_event_cid is locked to a 128-char CID regex. The\n@model_validator mathematically enforces deterministic canonical hashing by sorting the\nagent_attributions array by target_node_cid (NodeCIDState), guaranteeing RFC 8785\nalignment.\n\nMCP ROUTING TRIGGERS: Causal Factorization, Epistemic Ledger Commit, Credit Assignment,\nMacroscopic Explanation, Deterministic Sorting"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CausalExplanationEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the\\nmacroscopic factorization of a collective swarm outcome into its constituent causal\\ncomponents. As an ...Event suffix, this is an append-only coordinate on the\\nMerkle-DAG.\\n\\nCAUSAL AFFORDANCE: Commits the system-level CollectiveIntelligenceProfile and the\\nindividual ShapleyAttributionReceipt array to the Epistemic Ledger, finalizing the\\ncredit assignment for a target_outcome_event_cid.\\n\\nEPISTEMIC BOUNDS: The target_outcome_event_cid is locked to a 128-char CID regex. The\\n@model_validator mathematically enforces deterministic canonical hashing by sorting the\\nagent_attributions array by target_node_cid (NodeCIDState), guaranteeing RFC 8785\\nalignment.\\n\\nMCP ROUTING TRIGGERS: Causal Factorization, Epistemic Ledger Commit, Credit Assignment,\\nMacroscopic Explanation, Deterministic Sorting\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"agent_attributions\","]
#[doc = "    \"collective_intelligence\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"target_outcome_event_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"agent_attributions\": {"]
#[doc = "      \"title\": \"Agent Attributions\","]
#[doc = "      \"description\": \"The array of individual causal contributions.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/ShapleyAttributionReceipt\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"collective_intelligence\": {"]
#[doc = "      \"description\": \"The system-level emergence metrics.\","]
#[doc = "      \"$ref\": \"#/$defs/CollectiveIntelligenceProfile\""]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_outcome_event_cid\": {"]
#[doc = "      \"title\": \"Target Outcome Event Cid\","]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring the collective outcome being explained.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for a causal explanation event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"causal_explanation\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CausalExplanationEvent {
    #[doc = "The array of individual causal contributions."]
    pub agent_attributions: ::std::vec::Vec<ShapleyAttributionReceipt>,
    #[doc = "The system-level emergence metrics."]
    pub collective_intelligence: CollectiveIntelligenceProfile,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The globally unique decentralized identifier (DID) anchoring the collective outcome being explained."]
    pub target_outcome_event_cid: TargetOutcomeEventCid,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "Discriminator type for a causal explanation event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl CausalExplanationEvent {
    pub fn builder() -> builder::CausalExplanationEvent {
        Default::default()
    }
}
#[doc = "`CausalIntervalProfile`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"strictly_precedes\","]
#[doc = "    \"overlaps\","]
#[doc = "    \"contains\","]
#[doc = "    \"causes\","]
#[doc = "    \"mitigates\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum CausalIntervalProfile {
    #[serde(rename = "strictly_precedes")]
    StrictlyPrecedes,
    #[serde(rename = "overlaps")]
    Overlaps,
    #[serde(rename = "contains")]
    Contains,
    #[serde(rename = "causes")]
    Causes,
    #[serde(rename = "mitigates")]
    Mitigates,
}
impl ::std::fmt::Display for CausalIntervalProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::StrictlyPrecedes => f.write_str("strictly_precedes"),
            Self::Overlaps => f.write_str("overlaps"),
            Self::Contains => f.write_str("contains"),
            Self::Causes => f.write_str("causes"),
            Self::Mitigates => f.write_str("mitigates"),
        }
    }
}
impl ::std::str::FromStr for CausalIntervalProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "strictly_precedes" => Ok(Self::StrictlyPrecedes),
            "overlaps" => Ok(Self::Overlaps),
            "contains" => Ok(Self::Contains),
            "causes" => Ok(Self::Causes),
            "mitigates" => Ok(Self::Mitigates),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for CausalIntervalProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CausalIntervalProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CausalIntervalProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CausalPropagationIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"grounding_sla\","]
#[doc = "    \"target_graph_cid\","]
#[doc = "    \"task_cid\","]
#[doc = "    \"unverified_edges\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"grounding_sla\": {"]
#[doc = "      \"$ref\": \"#/$defs/EvidentiaryGroundingSLA\""]
#[doc = "    },"]
#[doc = "    \"target_graph_cid\": {"]
#[doc = "      \"title\": \"Target Graph Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"task_cid\": {"]
#[doc = "      \"title\": \"Task Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"causal_propagation\""]
#[doc = "    },"]
#[doc = "    \"unverified_edges\": {"]
#[doc = "      \"title\": \"Unverified Edges\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/CausalDirectedEdgeState\""]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CausalPropagationIntent {
    pub grounding_sla: EvidentiaryGroundingSla,
    pub target_graph_cid: TargetGraphCid,
    pub task_cid: TaskCid,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    pub unverified_edges: ::std::vec::Vec<CausalDirectedEdgeState>,
}
impl CausalPropagationIntent {
    pub fn builder() -> builder::CausalPropagationIntent {
        Default::default()
    }
}
#[doc = "The Pearlian directionality of the semantic relationship."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Causal Relationship\","]
#[doc = "  \"description\": \"The Pearlian directionality of the semantic relationship.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"causes\","]
#[doc = "    \"confounds\","]
#[doc = "    \"correlates_with\","]
#[doc = "    \"undirected\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum CausalRelationship {
    #[serde(rename = "causes")]
    Causes,
    #[serde(rename = "confounds")]
    Confounds,
    #[serde(rename = "correlates_with")]
    CorrelatesWith,
    #[serde(rename = "undirected")]
    Undirected,
}
impl ::std::fmt::Display for CausalRelationship {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Causes => f.write_str("causes"),
            Self::Confounds => f.write_str("confounds"),
            Self::CorrelatesWith => f.write_str("correlates_with"),
            Self::Undirected => f.write_str("undirected"),
        }
    }
}
impl ::std::str::FromStr for CausalRelationship {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "causes" => Ok(Self::Causes),
            "confounds" => Ok(Self::Confounds),
            "correlates_with" => Ok(Self::CorrelatesWith),
            "undirected" => Ok(Self::Undirected),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for CausalRelationship {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CausalRelationship {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CausalRelationship {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`CellCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Cell Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CellCid(::std::string::String);
impl ::std::ops::Deref for CellCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CellCid> for ::std::string::String {
    fn from(value: CellCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CellCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CellCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CellCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CellCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CellCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`ChainCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Chain Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ChainCid(::std::string::String);
impl ::std::ops::Deref for ChainCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ChainCid> for ::std::string::String {
    fn from(value: ChainCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ChainCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ChainCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ChainCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ChainCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ChainCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The visual channel the metric is mapped to."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Channel\","]
#[doc = "  \"description\": \"The visual channel the metric is mapped to.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"x\","]
#[doc = "    \"y\","]
#[doc = "    \"color\","]
#[doc = "    \"size\","]
#[doc = "    \"opacity\","]
#[doc = "    \"shape\","]
#[doc = "    \"text\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum Channel {
    #[serde(rename = "x")]
    X,
    #[serde(rename = "y")]
    Y,
    #[serde(rename = "color")]
    Color,
    #[serde(rename = "size")]
    Size,
    #[serde(rename = "opacity")]
    Opacity,
    #[serde(rename = "shape")]
    Shape,
    #[serde(rename = "text")]
    Text,
}
impl ::std::fmt::Display for Channel {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::X => f.write_str("x"),
            Self::Y => f.write_str("y"),
            Self::Color => f.write_str("color"),
            Self::Size => f.write_str("size"),
            Self::Opacity => f.write_str("opacity"),
            Self::Shape => f.write_str("shape"),
            Self::Text => f.write_str("text"),
        }
    }
}
impl ::std::str::FromStr for Channel {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "x" => Ok(Self::X),
            "y" => Ok(Self::Y),
            "color" => Ok(Self::Color),
            "size" => Ok(Self::Size),
            "opacity" => Ok(Self::Opacity),
            "shape" => Ok(Self::Shape),
            "text" => Ok(Self::Text),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for Channel {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Channel {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Channel {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the temporal anchor."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Checkpoint Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the temporal anchor.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CheckpointCid(::std::string::String);
impl ::std::ops::Deref for CheckpointCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CheckpointCid> for ::std::string::String {
    fn from(value: CheckpointCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CheckpointCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CheckpointCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CheckpointCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CheckpointCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CheckpointCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The mapped key in the nested topology's state contract."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Child Key\","]
#[doc = "  \"description\": \"The mapped key in the nested topology's state contract.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ChildKey(::std::string::String);
impl ::std::ops::Deref for ChildKey {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ChildKey> for ::std::string::String {
    fn from(value: ChildKey) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ChildKey {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ChildKey {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ChildKey {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ChildKey {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ChildKey {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`ChildrenNodeCidsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ChildrenNodeCidsItem(::std::string::String);
impl ::std::ops::Deref for ChildrenNodeCidsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ChildrenNodeCidsItem> for ::std::string::String {
    fn from(value: ChildrenNodeCidsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ChildrenNodeCidsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ChildrenNodeCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ChildrenNodeCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ChildrenNodeCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ChildrenNodeCidsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The base64-encoded homomorphic ciphertext."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Ciphertext Blob\","]
#[doc = "  \"description\": \"The base64-encoded homomorphic ciphertext.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 5000000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CiphertextBlob(::std::string::String);
impl ::std::ops::Deref for CiphertextBlob {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CiphertextBlob> for ::std::string::String {
    fn from(value: CiphertextBlob) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CiphertextBlob {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 5000000usize {
            return Err("longer than 5000000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CiphertextBlob {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CiphertextBlob {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CiphertextBlob {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CiphertextBlob {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Lyapunov Stability and distributed Control Theory to guarantee that the neurosymbolic network returns to a deterministic equilibrium when facing catastrophic variance. As an ...Event suffix, this is a cryptographically frozen coordinate.\n\nCAUSAL AFFORDANCE: Physically severs the active execution thread for the targeted node, acting as a hardware guillotine that immediately halts out-of-memory cascades, runaway generative loops, or API rate-limit breaches.\n\nEPISTEMIC BOUNDS: The fault perimeter is mathematically restricted to a specific `target_node_cid` (`NodeCIDState`). To prevent log-poisoning and VRAM exhaustion during the crash, the `error_signature` is strictly clamped at `max_length=2000`.\n\nMCP ROUTING TRIGGERS: Lyapunov Stability, Control Theory, Circuit Breaker, Cascading Failure, State Equilibrium"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CircuitBreakerEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Lyapunov Stability and distributed Control Theory to guarantee that the neurosymbolic network returns to a deterministic equilibrium when facing catastrophic variance. As an ...Event suffix, this is a cryptographically frozen coordinate.\\n\\nCAUSAL AFFORDANCE: Physically severs the active execution thread for the targeted node, acting as a hardware guillotine that immediately halts out-of-memory cascades, runaway generative loops, or API rate-limit breaches.\\n\\nEPISTEMIC BOUNDS: The fault perimeter is mathematically restricted to a specific `target_node_cid` (`NodeCIDState`). To prevent log-poisoning and VRAM exhaustion during the crash, the `error_signature` is strictly clamped at `max_length=2000`.\\n\\nMCP ROUTING TRIGGERS: Lyapunov Stability, Control Theory, Circuit Breaker, Cascading Failure, State Equilibrium\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"error_signature\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"target_node_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"error_signature\": {"]
#[doc = "      \"title\": \"Error Signature\","]
#[doc = "      \"description\": \"Signature or summary of the error causing the trip.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"description\": \"The deterministic capability pointer representing the node for which the circuit breaker was tripped.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The type of the resilience payload.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"circuit_breaker_event\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CircuitBreakerEvent {
    #[doc = "Signature or summary of the error causing the trip."]
    pub error_signature: ErrorSignature,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The deterministic capability pointer representing the node for which the circuit breaker was tripped."]
    pub target_node_cid: NodeCidState,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "The type of the resilience payload."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl CircuitBreakerEvent {
    pub fn builder() -> builder::CircuitBreakerEvent {
        Default::default()
    }
}
#[doc = "Cryptographic anchor for the specific piece of evidence."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Citation Cid\","]
#[doc = "  \"description\": \"Cryptographic anchor for the specific piece of evidence.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CitationCid(::std::string::String);
impl ::std::ops::Deref for CitationCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CitationCid> for ::std::string::String {
    fn from(value: CitationCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CitationCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CitationCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CitationCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CitationCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CitationCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this specific logical proposition."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Claim Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this specific logical proposition.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ClaimCid(::std::string::String);
impl ::std::ops::Deref for ClaimCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ClaimCid> for ::std::string::String {
    fn from(value: ClaimCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ClaimCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ClaimCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ClaimCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ClaimCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ClaimCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The discrete, structurally bounded capability or heuristic mapped by the LLM."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Classified Intent\","]
#[doc = "  \"description\": \"The discrete, structurally bounded capability or heuristic mapped by the LLM.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ClassifiedIntent(::std::string::String);
impl ::std::ops::Deref for ClassifiedIntent {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ClassifiedIntent> for ::std::string::String {
    fn from(value: ClassifiedIntent) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ClassifiedIntent {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ClassifiedIntent {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ClassifiedIntent {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ClassifiedIntent {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ClassifiedIntent {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nUnified JSON Schema for the Coreason Manifest"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nUnified JSON Schema for the Coreason Manifest\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"properties\": {"]
#[doc = "    \"ASTGradientReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/ASTGradientReceipt\""]
#[doc = "    },"]
#[doc = "    \"ActivationSteeringContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/ActivationSteeringContract\""]
#[doc = "    },"]
#[doc = "    \"ActiveInferenceContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/ActiveInferenceContract\""]
#[doc = "    },"]
#[doc = "    \"AdjudicationIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/AdjudicationIntent\""]
#[doc = "    },"]
#[doc = "    \"AdjudicationReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/AdjudicationReceipt\""]
#[doc = "    },"]
#[doc = "    \"AdjudicationRubricProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/AdjudicationRubricProfile\""]
#[doc = "    },"]
#[doc = "    \"AdversarialMarketTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/AdversarialMarketTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"AgentAttestationReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/AgentAttestationReceipt\""]
#[doc = "    },"]
#[doc = "    \"AgentBidIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/AgentBidIntent\""]
#[doc = "    },"]
#[doc = "    \"AlgebraicRefinementContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/AlgebraicRefinementContract\""]
#[doc = "    },"]
#[doc = "    \"AmbientState\": {"]
#[doc = "      \"$ref\": \"#/$defs/AmbientState\""]
#[doc = "    },"]
#[doc = "    \"AnalogicalMappingTask\": {"]
#[doc = "      \"$ref\": \"#/$defs/AnalogicalMappingTask\""]
#[doc = "    },"]
#[doc = "    \"AnchoringPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/AnchoringPolicy\""]
#[doc = "    },"]
#[doc = "    \"AnyActionSpaceCapability\": {"]
#[doc = "      \"$ref\": \"#/$defs/AnyActionSpaceCapability\""]
#[doc = "    },"]
#[doc = "    \"AnyExplorationBranch\": {"]
#[doc = "      \"$ref\": \"#/$defs/AnyExplorationBranch\""]
#[doc = "    },"]
#[doc = "    \"AnyIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/AnyIntent\""]
#[doc = "    },"]
#[doc = "    \"AnyNodeProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/AnyNodeProfile\""]
#[doc = "    },"]
#[doc = "    \"AnyPanelProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/AnyPanelProfile\""]
#[doc = "    },"]
#[doc = "    \"AnyPresentationIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/AnyPresentationIntent\""]
#[doc = "    },"]
#[doc = "    \"AnyStateEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/AnyStateEvent\""]
#[doc = "    },"]
#[doc = "    \"AnyToolchainState\": {"]
#[doc = "      \"$ref\": \"#/$defs/AnyToolchainState\""]
#[doc = "    },"]
#[doc = "    \"AnyTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/AnyTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"AnyTransitionEdge\": {"]
#[doc = "      \"$ref\": \"#/$defs/AnyTransitionEdge\""]
#[doc = "    },"]
#[doc = "    \"ArtifactCorruptionEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/ArtifactCorruptionEvent\""]
#[doc = "    },"]
#[doc = "    \"AsymptoticComplexityReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/AsymptoticComplexityReceipt\""]
#[doc = "    },"]
#[doc = "    \"AtomicPropositionState\": {"]
#[doc = "      \"$ref\": \"#/$defs/AtomicPropositionState\""]
#[doc = "    },"]
#[doc = "    \"AttackVectorProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/AttackVectorProfile\""]
#[doc = "    },"]
#[doc = "    \"AuctionMechanismProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/AuctionMechanismProfile\""]
#[doc = "    },"]
#[doc = "    \"AuctionPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/AuctionPolicy\""]
#[doc = "    },"]
#[doc = "    \"AuctionState\": {"]
#[doc = "      \"$ref\": \"#/$defs/AuctionState\""]
#[doc = "    },"]
#[doc = "    \"BackpressurePolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/BackpressurePolicy\""]
#[doc = "    },"]
#[doc = "    \"BargeInInterruptEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/BargeInInterruptEvent\""]
#[doc = "    },"]
#[doc = "    \"BeliefModulationReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/BeliefModulationReceipt\""]
#[doc = "    },"]
#[doc = "    \"BeliefMutationEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/BeliefMutationEvent\""]
#[doc = "    },"]
#[doc = "    \"BoundedInterventionScopePolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/BoundedInterventionScopePolicy\""]
#[doc = "    },"]
#[doc = "    \"BoundedJSONRPCIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/BoundedJSONRPCIntent\""]
#[doc = "    },"]
#[doc = "    \"BrowserDOMState\": {"]
#[doc = "      \"$ref\": \"#/$defs/BrowserDOMState\""]
#[doc = "    },"]
#[doc = "    \"BudgetExhaustionEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/BudgetExhaustionEvent\""]
#[doc = "    },"]
#[doc = "    \"BundleContentHashState\": {"]
#[doc = "      \"$ref\": \"#/$defs/BundleContentHashState\""]
#[doc = "    },"]
#[doc = "    \"BypassReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/BypassReceipt\""]
#[doc = "    },"]
#[doc = "    \"CapabilityForgeTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/CapabilityForgeTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"CapabilityPointerState\": {"]
#[doc = "      \"$ref\": \"#/$defs/CapabilityPointerState\""]
#[doc = "    },"]
#[doc = "    \"CausalAttributionState\": {"]
#[doc = "      \"$ref\": \"#/$defs/CausalAttributionState\""]
#[doc = "    },"]
#[doc = "    \"CausalDirectedEdgeState\": {"]
#[doc = "      \"$ref\": \"#/$defs/CausalDirectedEdgeState\""]
#[doc = "    },"]
#[doc = "    \"CausalExplanationEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/CausalExplanationEvent\""]
#[doc = "    },"]
#[doc = "    \"CausalIntervalProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/CausalIntervalProfile\""]
#[doc = "    },"]
#[doc = "    \"CausalPropagationIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/CausalPropagationIntent\""]
#[doc = "    },"]
#[doc = "    \"CircuitBreakerEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/CircuitBreakerEvent\""]
#[doc = "    },"]
#[doc = "    \"CognitiveActionSpaceManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveActionSpaceManifest\""]
#[doc = "    },"]
#[doc = "    \"CognitiveAgentNodeProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveAgentNodeProfile\""]
#[doc = "    },"]
#[doc = "    \"CognitiveCritiqueProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveCritiqueProfile\""]
#[doc = "    },"]
#[doc = "    \"CognitiveDetailedBalanceContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveDetailedBalanceContract\""]
#[doc = "    },"]
#[doc = "    \"CognitiveDualVerificationReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveDualVerificationReceipt\""]
#[doc = "    },"]
#[doc = "    \"CognitiveHumanNodeProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveHumanNodeProfile\""]
#[doc = "    },"]
#[doc = "    \"CognitivePredictionReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitivePredictionReceipt\""]
#[doc = "    },"]
#[doc = "    \"CognitiveReasoningTraceState\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveReasoningTraceState\""]
#[doc = "    },"]
#[doc = "    \"CognitiveRoutingContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveRoutingContract\""]
#[doc = "    },"]
#[doc = "    \"CognitiveSamplingPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveSamplingPolicy\""]
#[doc = "    },"]
#[doc = "    \"CognitiveStateProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveStateProfile\""]
#[doc = "    },"]
#[doc = "    \"CognitiveSwarmDeploymentManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveSwarmDeploymentManifest\""]
#[doc = "    },"]
#[doc = "    \"CognitiveSystemNodeProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveSystemNodeProfile\""]
#[doc = "    },"]
#[doc = "    \"CognitiveTierProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveTierProfile\""]
#[doc = "    },"]
#[doc = "    \"CognitiveUncertaintyProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/CognitiveUncertaintyProfile\""]
#[doc = "    },"]
#[doc = "    \"CollectiveIntelligenceProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/CollectiveIntelligenceProfile\""]
#[doc = "    },"]
#[doc = "    \"CompositeNodeProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/CompositeNodeProfile\""]
#[doc = "    },"]
#[doc = "    \"ComputeEngineProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/ComputeEngineProfile\""]
#[doc = "    },"]
#[doc = "    \"ComputeProvisioningIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/ComputeProvisioningIntent\""]
#[doc = "    },"]
#[doc = "    \"ComputeRateContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/ComputeRateContract\""]
#[doc = "    },"]
#[doc = "    \"ConsensusFederationTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/ConsensusFederationTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"ConsensusPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/ConsensusPolicy\""]
#[doc = "    },"]
#[doc = "    \"ConstitutionalAmendmentIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/ConstitutionalAmendmentIntent\""]
#[doc = "    },"]
#[doc = "    \"ConstrainedDecodingPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/ConstrainedDecodingPolicy\""]
#[doc = "    },"]
#[doc = "    \"ContextExpansionPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/ContextExpansionPolicy\""]
#[doc = "    },"]
#[doc = "    \"ContextualSemanticResolutionIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/ContextualSemanticResolutionIntent\""]
#[doc = "    },"]
#[doc = "    \"ContextualizedSourceState\": {"]
#[doc = "      \"$ref\": \"#/$defs/ContextualizedSourceState\""]
#[doc = "    },"]
#[doc = "    \"ContinuousManifoldMappingContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/ContinuousManifoldMappingContract\""]
#[doc = "    },"]
#[doc = "    \"ContinuousMutationPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/ContinuousMutationPolicy\""]
#[doc = "    },"]
#[doc = "    \"ContinuousObservationState\": {"]
#[doc = "      \"$ref\": \"#/$defs/ContinuousObservationState\""]
#[doc = "    },"]
#[doc = "    \"ContinuousSpatialMutationIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/ContinuousSpatialMutationIntent\""]
#[doc = "    },"]
#[doc = "    \"CouncilTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/CouncilTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"CounterfactualRegretEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/CounterfactualRegretEvent\""]
#[doc = "    },"]
#[doc = "    \"CrossoverMechanismProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/CrossoverMechanismProfile\""]
#[doc = "    },"]
#[doc = "    \"CrossoverPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/CrossoverPolicy\""]
#[doc = "    },"]
#[doc = "    \"CrosswalkResolutionReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/CrosswalkResolutionReceipt\""]
#[doc = "    },"]
#[doc = "    \"CryptographicProvenancePolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/CryptographicProvenancePolicy\""]
#[doc = "    },"]
#[doc = "    \"CrystallizationPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/CrystallizationPolicy\""]
#[doc = "    },"]
#[doc = "    \"CustodyReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/CustodyReceipt\""]
#[doc = "    },"]
#[doc = "    \"CyclicEdgeProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/CyclicEdgeProfile\""]
#[doc = "    },"]
#[doc = "    \"DAGTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/DAGTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"DefeasibleAttackEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/DefeasibleAttackEvent\""]
#[doc = "    },"]
#[doc = "    \"DefeasibleCascadeEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/DefeasibleCascadeEvent\""]
#[doc = "    },"]
#[doc = "    \"DelegatedCapabilityManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/DelegatedCapabilityManifest\""]
#[doc = "    },"]
#[doc = "    \"DeliberativeEnvelope\": {"]
#[doc = "      \"$ref\": \"#/$defs/DeliberativeEnvelope\""]
#[doc = "    },"]
#[doc = "    \"DempsterShaferBeliefVector\": {"]
#[doc = "      \"$ref\": \"#/$defs/DempsterShaferBeliefVector\""]
#[doc = "    },"]
#[doc = "    \"DerivationModeProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/DerivationModeProfile\""]
#[doc = "    },"]
#[doc = "    \"DifferentiableLogicPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/DifferentiableLogicPolicy\""]
#[doc = "    },"]
#[doc = "    \"DigitalTwinTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/DigitalTwinTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"DiscourseNodeState\": {"]
#[doc = "      \"$ref\": \"#/$defs/DiscourseNodeState\""]
#[doc = "    },"]
#[doc = "    \"DiscourseTreeManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/DiscourseTreeManifest\""]
#[doc = "    },"]
#[doc = "    \"DistributionProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/DistributionProfile\""]
#[doc = "    },"]
#[doc = "    \"DistributionShapeProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/DistributionShapeProfile\""]
#[doc = "    },"]
#[doc = "    \"DiversityPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/DiversityPolicy\""]
#[doc = "    },"]
#[doc = "    \"DocumentKnowledgeGraphManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/DocumentKnowledgeGraphManifest\""]
#[doc = "    },"]
#[doc = "    \"DocumentLayoutManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/DocumentLayoutManifest\""]
#[doc = "    },"]
#[doc = "    \"DocumentLayoutRegionState\": {"]
#[doc = "      \"$ref\": \"#/$defs/DocumentLayoutRegionState\""]
#[doc = "    },"]
#[doc = "    \"DraftingIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/DraftingIntent\""]
#[doc = "    },"]
#[doc = "    \"DynamicConvergenceSLA\": {"]
#[doc = "      \"$ref\": \"#/$defs/DynamicConvergenceSLA\""]
#[doc = "    },"]
#[doc = "    \"DynamicLayoutManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/DynamicLayoutManifest\""]
#[doc = "    },"]
#[doc = "    \"DynamicManifoldProjectionManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/DynamicManifoldProjectionManifest\""]
#[doc = "    },"]
#[doc = "    \"DynamicRoutingManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/DynamicRoutingManifest\""]
#[doc = "    },"]
#[doc = "    \"EdgeMappingContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/EdgeMappingContract\""]
#[doc = "    },"]
#[doc = "    \"EmbodiedSensoryVectorProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/EmbodiedSensoryVectorProfile\""]
#[doc = "    },"]
#[doc = "    \"EmpiricalFalsificationContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/EmpiricalFalsificationContract\""]
#[doc = "    },"]
#[doc = "    \"EmpiricalStatisticalProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/EmpiricalStatisticalProfile\""]
#[doc = "    },"]
#[doc = "    \"EnsembleTopologyProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/EnsembleTopologyProfile\""]
#[doc = "    },"]
#[doc = "    \"EphemeralNamespacePartitionState\": {"]
#[doc = "      \"$ref\": \"#/$defs/EphemeralNamespacePartitionState\""]
#[doc = "    },"]
#[doc = "    \"EpistemicArgumentClaimState\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicArgumentClaimState\""]
#[doc = "    },"]
#[doc = "    \"EpistemicArgumentGraphState\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicArgumentGraphState\""]
#[doc = "    },"]
#[doc = "    \"EpistemicAttentionState\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicAttentionState\""]
#[doc = "    },"]
#[doc = "    \"EpistemicAxiomState\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicAxiomState\""]
#[doc = "    },"]
#[doc = "    \"EpistemicAxiomVerificationReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicAxiomVerificationReceipt\""]
#[doc = "    },"]
#[doc = "    \"EpistemicChainGraphState\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicChainGraphState\""]
#[doc = "    },"]
#[doc = "    \"EpistemicCompressionSLA\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicCompressionSLA\""]
#[doc = "    },"]
#[doc = "    \"EpistemicConstraintPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicConstraintPolicy\""]
#[doc = "    },"]
#[doc = "    \"EpistemicCurriculumManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicCurriculumManifest\""]
#[doc = "    },"]
#[doc = "    \"EpistemicDomainGraphManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicDomainGraphManifest\""]
#[doc = "    },"]
#[doc = "    \"EpistemicEscalationContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicEscalationContract\""]
#[doc = "    },"]
#[doc = "    \"EpistemicFlowStateReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicFlowStateReceipt\""]
#[doc = "    },"]
#[doc = "    \"EpistemicGroundedTaskManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicGroundedTaskManifest\""]
#[doc = "    },"]
#[doc = "    \"EpistemicGuardrailsManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicGuardrailsManifest\""]
#[doc = "    },"]
#[doc = "    \"EpistemicHydrationPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicHydrationPolicy\""]
#[doc = "    },"]
#[doc = "    \"EpistemicLedgerState\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicLedgerState\""]
#[doc = "    },"]
#[doc = "    \"EpistemicLogEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicLogEvent\""]
#[doc = "    },"]
#[doc = "    \"EpistemicPromotionEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicPromotionEvent\""]
#[doc = "    },"]
#[doc = "    \"EpistemicProvenanceReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicProvenanceReceipt\""]
#[doc = "    },"]
#[doc = "    \"EpistemicProxyState\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicProxyState\""]
#[doc = "    },"]
#[doc = "    \"EpistemicProxyState_Any_\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicProxyState_Any_\""]
#[doc = "    },"]
#[doc = "    \"EpistemicQuarantineSnapshot\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicQuarantineSnapshot\""]
#[doc = "    },"]
#[doc = "    \"EpistemicRejectionReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicRejectionReceipt\""]
#[doc = "    },"]
#[doc = "    \"EpistemicRigidityPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicRigidityPolicy\""]
#[doc = "    },"]
#[doc = "    \"EpistemicSOPManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicSOPManifest\""]
#[doc = "    },"]
#[doc = "    \"EpistemicScanningPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicScanningPolicy\""]
#[doc = "    },"]
#[doc = "    \"EpistemicSecurityPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicSecurityPolicy\""]
#[doc = "    },"]
#[doc = "    \"EpistemicSecurityProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicSecurityProfile\""]
#[doc = "    },"]
#[doc = "    \"EpistemicSeedInjectionPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicSeedInjectionPolicy\""]
#[doc = "    },"]
#[doc = "    \"EpistemicStarvationEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicStarvationEvent\""]
#[doc = "    },"]
#[doc = "    \"EpistemicTelemetryEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicTelemetryEvent\""]
#[doc = "    },"]
#[doc = "    \"EpistemicTopologicalProofManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicTopologicalProofManifest\""]
#[doc = "    },"]
#[doc = "    \"EpistemicTransmutationTask\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicTransmutationTask\""]
#[doc = "    },"]
#[doc = "    \"EpistemicUpsamplingTask\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicUpsamplingTask\""]
#[doc = "    },"]
#[doc = "    \"EpistemicZeroTrustContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicZeroTrustContract\""]
#[doc = "    },"]
#[doc = "    \"EpistemicZeroTrustReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicZeroTrustReceipt\""]
#[doc = "    },"]
#[doc = "    \"EscalationContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/EscalationContract\""]
#[doc = "    },"]
#[doc = "    \"EscalationIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/EscalationIntent\""]
#[doc = "    },"]
#[doc = "    \"EscrowPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/EscrowPolicy\""]
#[doc = "    },"]
#[doc = "    \"EvaluatorOptimizerTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/EvaluatorOptimizerTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"EvictionPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/EvictionPolicy\""]
#[doc = "    },"]
#[doc = "    \"EvidentiaryCitationState\": {"]
#[doc = "      \"$ref\": \"#/$defs/EvidentiaryCitationState\""]
#[doc = "    },"]
#[doc = "    \"EvidentiaryGroundingSLA\": {"]
#[doc = "      \"$ref\": \"#/$defs/EvidentiaryGroundingSLA\""]
#[doc = "    },"]
#[doc = "    \"EvidentiaryWarrantState\": {"]
#[doc = "      \"$ref\": \"#/$defs/EvidentiaryWarrantState\""]
#[doc = "    },"]
#[doc = "    \"EvolutionaryTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/EvolutionaryTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"ExecutionEnvelopeState\": {"]
#[doc = "      \"$ref\": \"#/$defs/ExecutionEnvelopeState\""]
#[doc = "    },"]
#[doc = "    \"ExecutionSLA\": {"]
#[doc = "      \"$ref\": \"#/$defs/ExecutionSLA\""]
#[doc = "    },"]
#[doc = "    \"ExecutionSubstrateProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/ExecutionSubstrateProfile\""]
#[doc = "    },"]
#[doc = "    \"ExogenousEpistemicEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/ExogenousEpistemicEvent\""]
#[doc = "    },"]
#[doc = "    \"FYIIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/FYIIntent\""]
#[doc = "    },"]
#[doc = "    \"FacetMatrixProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/FacetMatrixProfile\""]
#[doc = "    },"]
#[doc = "    \"FallbackIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/FallbackIntent\""]
#[doc = "    },"]
#[doc = "    \"FallbackSLA\": {"]
#[doc = "      \"$ref\": \"#/$defs/FallbackSLA\""]
#[doc = "    },"]
#[doc = "    \"FalsificationContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/FalsificationContract\""]
#[doc = "    },"]
#[doc = "    \"FitnessObjectiveProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/FitnessObjectiveProfile\""]
#[doc = "    },"]
#[doc = "    \"FormalLogicPremise\": {"]
#[doc = "      \"$ref\": \"#/$defs/FormalLogicPremise\""]
#[doc = "    },"]
#[doc = "    \"FormalVerificationContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/FormalVerificationContract\""]
#[doc = "    },"]
#[doc = "    \"FormalVerificationReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/FormalVerificationReceipt\""]
#[doc = "    },"]
#[doc = "    \"GenerativeManifoldSLA\": {"]
#[doc = "      \"$ref\": \"#/$defs/GenerativeManifoldSLA\""]
#[doc = "    },"]
#[doc = "    \"GenerativeTaxonomyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/GenerativeTaxonomyManifest\""]
#[doc = "    },"]
#[doc = "    \"GlobalGovernancePolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/GlobalGovernancePolicy\""]
#[doc = "    },"]
#[doc = "    \"GlobalSemanticInvariantProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/GlobalSemanticInvariantProfile\""]
#[doc = "    },"]
#[doc = "    \"GlobalSemanticProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/GlobalSemanticProfile\""]
#[doc = "    },"]
#[doc = "    \"GradingCriterionProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/GradingCriterionProfile\""]
#[doc = "    },"]
#[doc = "    \"GrammarPanelProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/GrammarPanelProfile\""]
#[doc = "    },"]
#[doc = "    \"GraphFlatteningPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/GraphFlatteningPolicy\""]
#[doc = "    },"]
#[doc = "    \"GuardrailViolationEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/GuardrailViolationEvent\""]
#[doc = "    },"]
#[doc = "    \"HTTPTransportProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/HTTPTransportProfile\""]
#[doc = "    },"]
#[doc = "    \"HardwareEnclaveReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/HardwareEnclaveReceipt\""]
#[doc = "    },"]
#[doc = "    \"HierarchicalDOMManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/HierarchicalDOMManifest\""]
#[doc = "    },"]
#[doc = "    \"HoareLogicProofReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/HoareLogicProofReceipt\""]
#[doc = "    },"]
#[doc = "    \"HomomorphicEncryptionProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/HomomorphicEncryptionProfile\""]
#[doc = "    },"]
#[doc = "    \"HumanDirectiveIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/HumanDirectiveIntent\""]
#[doc = "    },"]
#[doc = "    \"HypothesisGenerationEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/HypothesisGenerationEvent\""]
#[doc = "    },"]
#[doc = "    \"HypothesisStakeReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/HypothesisStakeReceipt\""]
#[doc = "    },"]
#[doc = "    \"HypothesisSuperpositionState\": {"]
#[doc = "      \"$ref\": \"#/$defs/HypothesisSuperpositionState\""]
#[doc = "    },"]
#[doc = "    \"IdeationPhaseProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/IdeationPhaseProfile\""]
#[doc = "    },"]
#[doc = "    \"IllocutionaryForceProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/IllocutionaryForceProfile\""]
#[doc = "    },"]
#[doc = "    \"InputMappingContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/InputMappingContract\""]
#[doc = "    },"]
#[doc = "    \"InsightCardProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/InsightCardProfile\""]
#[doc = "    },"]
#[doc = "    \"IntentClassificationReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/IntentClassificationReceipt\""]
#[doc = "    },"]
#[doc = "    \"IntentElicitationTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/IntentElicitationTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"InterventionIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/InterventionIntent\""]
#[doc = "    },"]
#[doc = "    \"InterventionPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/InterventionPolicy\""]
#[doc = "    },"]
#[doc = "    \"InterventionReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/InterventionReceipt\""]
#[doc = "    },"]
#[doc = "    \"InterventionalCausalTask\": {"]
#[doc = "      \"$ref\": \"#/$defs/InterventionalCausalTask\""]
#[doc = "    },"]
#[doc = "    \"JSONRPCErrorResponseState\": {"]
#[doc = "      \"$ref\": \"#/$defs/JSONRPCErrorResponseState\""]
#[doc = "    },"]
#[doc = "    \"JSONRPCErrorState\": {"]
#[doc = "      \"$ref\": \"#/$defs/JSONRPCErrorState\""]
#[doc = "    },"]
#[doc = "    \"JsonPrimitiveState\": {"]
#[doc = "      \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "    },"]
#[doc = "    \"KinematicDeltaManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/KinematicDeltaManifest\""]
#[doc = "    },"]
#[doc = "    \"KinematicDerivativeProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/KinematicDerivativeProfile\""]
#[doc = "    },"]
#[doc = "    \"KineticBudgetPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/KineticBudgetPolicy\""]
#[doc = "    },"]
#[doc = "    \"KineticSeparationPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/KineticSeparationPolicy\""]
#[doc = "    },"]
#[doc = "    \"LatentProjectionIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/LatentProjectionIntent\""]
#[doc = "    },"]
#[doc = "    \"LatentSchemaInferenceIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/LatentSchemaInferenceIntent\""]
#[doc = "    },"]
#[doc = "    \"LatentScratchpadReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/LatentScratchpadReceipt\""]
#[doc = "    },"]
#[doc = "    \"LatentSmoothingProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/LatentSmoothingProfile\""]
#[doc = "    },"]
#[doc = "    \"LifecycleTriggerEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/LifecycleTriggerEvent\""]
#[doc = "    },"]
#[doc = "    \"LineageWatermarkReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/LineageWatermarkReceipt\""]
#[doc = "    },"]
#[doc = "    \"LinkMLValidationSLA\": {"]
#[doc = "      \"$ref\": \"#/$defs/LinkMLValidationSLA\""]
#[doc = "    },"]
#[doc = "    \"LogitSteganographyContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/LogitSteganographyContract\""]
#[doc = "    },"]
#[doc = "    \"MCPCapabilityWhitelistPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/MCPCapabilityWhitelistPolicy\""]
#[doc = "    },"]
#[doc = "    \"MCPClientIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/MCPClientIntent\""]
#[doc = "    },"]
#[doc = "    \"MCPPromptReferenceState\": {"]
#[doc = "      \"$ref\": \"#/$defs/MCPPromptReferenceState\""]
#[doc = "    },"]
#[doc = "    \"MCPResourceManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/MCPResourceManifest\""]
#[doc = "    },"]
#[doc = "    \"MCPServerManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/MCPServerManifest\""]
#[doc = "    },"]
#[doc = "    \"MCPToolDefinition\": {"]
#[doc = "      \"$ref\": \"#/$defs/MCPToolDefinition\""]
#[doc = "    },"]
#[doc = "    \"MacroGridProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/MacroGridProfile\""]
#[doc = "    },"]
#[doc = "    \"ManifestViolationReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/ManifestViolationReceipt\""]
#[doc = "    },"]
#[doc = "    \"ManifoldAlignmentMetricProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/ManifoldAlignmentMetricProfile\""]
#[doc = "    },"]
#[doc = "    \"MarketContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/MarketContract\""]
#[doc = "    },"]
#[doc = "    \"MarketResolutionState\": {"]
#[doc = "      \"$ref\": \"#/$defs/MarketResolutionState\""]
#[doc = "    },"]
#[doc = "    \"MarkovBlanketRenderingPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/MarkovBlanketRenderingPolicy\""]
#[doc = "    },"]
#[doc = "    \"MechanisticAuditContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/MechanisticAuditContract\""]
#[doc = "    },"]
#[doc = "    \"MemoizedNodeProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/MemoizedNodeProfile\""]
#[doc = "    },"]
#[doc = "    \"MultimodalArtifactReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/MultimodalArtifactReceipt\""]
#[doc = "    },"]
#[doc = "    \"MultimodalTokenAnchorState\": {"]
#[doc = "      \"$ref\": \"#/$defs/MultimodalTokenAnchorState\""]
#[doc = "    },"]
#[doc = "    \"MutationPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/MutationPolicy\""]
#[doc = "    },"]
#[doc = "    \"NDimensionalTensorManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/NDimensionalTensorManifest\""]
#[doc = "    },"]
#[doc = "    \"NeuralAuditAttestationReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/NeuralAuditAttestationReceipt\""]
#[doc = "    },"]
#[doc = "    \"NeuroSymbolicHandoffContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/NeuroSymbolicHandoffContract\""]
#[doc = "    },"]
#[doc = "    \"NeurosymbolicInferenceIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/NeurosymbolicInferenceIntent\""]
#[doc = "    },"]
#[doc = "    \"NeurosymbolicIngestionTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/NeurosymbolicIngestionTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"NeurosymbolicVerificationTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/NeurosymbolicVerificationTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"NodeCIDState\": {"]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"ObservabilityLODPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/ObservabilityLODPolicy\""]
#[doc = "    },"]
#[doc = "    \"ObservationEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/ObservationEvent\""]
#[doc = "    },"]
#[doc = "    \"OntologicalAlignmentPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/OntologicalAlignmentPolicy\""]
#[doc = "    },"]
#[doc = "    \"OntologicalCrosswalkIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/OntologicalCrosswalkIntent\""]
#[doc = "    },"]
#[doc = "    \"OntologicalNormalizationIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/OntologicalNormalizationIntent\""]
#[doc = "    },"]
#[doc = "    \"OntologicalReificationReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/OntologicalReificationReceipt\""]
#[doc = "    },"]
#[doc = "    \"OntologicalSurfaceProjectionManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/OntologicalSurfaceProjectionManifest\""]
#[doc = "    },"]
#[doc = "    \"OntologyDiscoveryIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/OntologyDiscoveryIntent\""]
#[doc = "    },"]
#[doc = "    \"OpticalMappingContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/OpticalMappingContract\""]
#[doc = "    },"]
#[doc = "    \"OpticalParsingSLA\": {"]
#[doc = "      \"$ref\": \"#/$defs/OpticalParsingSLA\""]
#[doc = "    },"]
#[doc = "    \"OptimizationDirectionProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/OptimizationDirectionProfile\""]
#[doc = "    },"]
#[doc = "    \"OracleExecutionReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/OracleExecutionReceipt\""]
#[doc = "    },"]
#[doc = "    \"OutputMappingContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/OutputMappingContract\""]
#[doc = "    },"]
#[doc = "    \"OverrideIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/OverrideIntent\""]
#[doc = "    },"]
#[doc = "    \"PatchOperationProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/PatchOperationProfile\""]
#[doc = "    },"]
#[doc = "    \"PeftAdapterContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/PeftAdapterContract\""]
#[doc = "    },"]
#[doc = "    \"PermissionBoundaryPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/PermissionBoundaryPolicy\""]
#[doc = "    },"]
#[doc = "    \"PersistenceCommitReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/PersistenceCommitReceipt\""]
#[doc = "    },"]
#[doc = "    \"PostCoordinatedSemanticState\": {"]
#[doc = "      \"$ref\": \"#/$defs/PostCoordinatedSemanticState\""]
#[doc = "    },"]
#[doc = "    \"PostQuantumSignatureReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/PostQuantumSignatureReceipt\""]
#[doc = "    },"]
#[doc = "    \"PredictionMarketPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/PredictionMarketPolicy\""]
#[doc = "    },"]
#[doc = "    \"PredictionMarketState\": {"]
#[doc = "      \"$ref\": \"#/$defs/PredictionMarketState\""]
#[doc = "    },"]
#[doc = "    \"PresentationManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/PresentationManifest\""]
#[doc = "    },"]
#[doc = "    \"ProceduralMetadataManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/ProceduralMetadataManifest\""]
#[doc = "    },"]
#[doc = "    \"ProcessRewardContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/ProcessRewardContract\""]
#[doc = "    },"]
#[doc = "    \"ProfileCIDState\": {"]
#[doc = "      \"$ref\": \"#/$defs/ProfileCIDState\""]
#[doc = "    },"]
#[doc = "    \"QoSClassificationProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/QoSClassificationProfile\""]
#[doc = "    },"]
#[doc = "    \"QuarantineIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/QuarantineIntent\""]
#[doc = "    },"]
#[doc = "    \"QuorumPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/QuorumPolicy\""]
#[doc = "    },"]
#[doc = "    \"RDFExportReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/RDFExportReceipt\""]
#[doc = "    },"]
#[doc = "    \"RDFSerializationIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/RDFSerializationIntent\""]
#[doc = "    },"]
#[doc = "    \"ReasoningEngineeringPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/ReasoningEngineeringPolicy\""]
#[doc = "    },"]
#[doc = "    \"RhetoricalStructureProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/RhetoricalStructureProfile\""]
#[doc = "    },"]
#[doc = "    \"RiskLevelPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/RiskLevelPolicy\""]
#[doc = "    },"]
#[doc = "    \"RollbackIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/RollbackIntent\""]
#[doc = "    },"]
#[doc = "    \"RoutingFrontierPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/RoutingFrontierPolicy\""]
#[doc = "    },"]
#[doc = "    \"SE3TransformProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/SE3TransformProfile\""]
#[doc = "    },"]
#[doc = "    \"SHACLValidationSLA\": {"]
#[doc = "      \"$ref\": \"#/$defs/SHACLValidationSLA\""]
#[doc = "    },"]
#[doc = "    \"SMPCTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/SMPCTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"SPARQLQueryIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/SPARQLQueryIntent\""]
#[doc = "    },"]
#[doc = "    \"SPARQLQueryResultReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/SPARQLQueryResultReceipt\""]
#[doc = "    },"]
#[doc = "    \"SSETransportProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/SSETransportProfile\""]
#[doc = "    },"]
#[doc = "    \"SaeFeatureActivationState\": {"]
#[doc = "      \"$ref\": \"#/$defs/SaeFeatureActivationState\""]
#[doc = "    },"]
#[doc = "    \"SaeLatentPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/SaeLatentPolicy\""]
#[doc = "    },"]
#[doc = "    \"SalienceProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/SalienceProfile\""]
#[doc = "    },"]
#[doc = "    \"ScalePolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/ScalePolicy\""]
#[doc = "    },"]
#[doc = "    \"SchemaDrivenExtractionSLA\": {"]
#[doc = "      \"$ref\": \"#/$defs/SchemaDrivenExtractionSLA\""]
#[doc = "    },"]
#[doc = "    \"SecureSubSessionState\": {"]
#[doc = "      \"$ref\": \"#/$defs/SecureSubSessionState\""]
#[doc = "    },"]
#[doc = "    \"SelfCorrectionPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/SelfCorrectionPolicy\""]
#[doc = "    },"]
#[doc = "    \"SemanticDiscoveryIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticDiscoveryIntent\""]
#[doc = "    },"]
#[doc = "    \"SemanticEdgeState\": {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticEdgeState\""]
#[doc = "    },"]
#[doc = "    \"SemanticFirewallPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticFirewallPolicy\""]
#[doc = "    },"]
#[doc = "    \"SemanticFlowPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticFlowPolicy\""]
#[doc = "    },"]
#[doc = "    \"SemanticIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticIntent\""]
#[doc = "    },"]
#[doc = "    \"SemanticMappingHeuristicIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticMappingHeuristicIntent\""]
#[doc = "    },"]
#[doc = "    \"SemanticNodeState\": {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticNodeState\""]
#[doc = "    },"]
#[doc = "    \"SemanticRelationalVectorState\": {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticRelationalVectorState\""]
#[doc = "    },"]
#[doc = "    \"SemanticSlicingPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticSlicingPolicy\""]
#[doc = "    },"]
#[doc = "    \"SemanticVersionState\": {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticVersionState\""]
#[doc = "    },"]
#[doc = "    \"SemanticZoomProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/SemanticZoomProfile\""]
#[doc = "    },"]
#[doc = "    \"ShapleyAttributionReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/ShapleyAttributionReceipt\""]
#[doc = "    },"]
#[doc = "    \"SideEffectProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/SideEffectProfile\""]
#[doc = "    },"]
#[doc = "    \"SimulationConvergenceSLA\": {"]
#[doc = "      \"$ref\": \"#/$defs/SimulationConvergenceSLA\""]
#[doc = "    },"]
#[doc = "    \"SimulationEscrowContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/SimulationEscrowContract\""]
#[doc = "    },"]
#[doc = "    \"SpatialBillboardContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/SpatialBillboardContract\""]
#[doc = "    },"]
#[doc = "    \"SpatialHardwareProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/SpatialHardwareProfile\""]
#[doc = "    },"]
#[doc = "    \"SpatialKinematicActionIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/SpatialKinematicActionIntent\""]
#[doc = "    },"]
#[doc = "    \"SpatialReferenceFrameManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/SpatialReferenceFrameManifest\""]
#[doc = "    },"]
#[doc = "    \"SpatialRenderMaterial\": {"]
#[doc = "      \"$ref\": \"#/$defs/SpatialRenderMaterial\""]
#[doc = "    },"]
#[doc = "    \"SpatialToolManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/SpatialToolManifest\""]
#[doc = "    },"]
#[doc = "    \"SpeculativeExecutionPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/SpeculativeExecutionPolicy\""]
#[doc = "    },"]
#[doc = "    \"StateContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/StateContract\""]
#[doc = "    },"]
#[doc = "    \"StateDifferentialManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/StateDifferentialManifest\""]
#[doc = "    },"]
#[doc = "    \"StateHydrationManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/StateHydrationManifest\""]
#[doc = "    },"]
#[doc = "    \"StateMutationIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/StateMutationIntent\""]
#[doc = "    },"]
#[doc = "    \"StateVectorProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/StateVectorProfile\""]
#[doc = "    },"]
#[doc = "    \"StdioTransportProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/StdioTransportProfile\""]
#[doc = "    },"]
#[doc = "    \"StochasticNodeState\": {"]
#[doc = "      \"$ref\": \"#/$defs/StochasticNodeState\""]
#[doc = "    },"]
#[doc = "    \"StochasticTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/StochasticTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"StrategicThoughtNodeIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/StrategicThoughtNodeIntent\""]
#[doc = "    },"]
#[doc = "    \"StreamingDisfluencyContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/StreamingDisfluencyContract\""]
#[doc = "    },"]
#[doc = "    \"StructuralCausalGraphProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/StructuralCausalGraphProfile\""]
#[doc = "    },"]
#[doc = "    \"SubstrateHydrationManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/SubstrateHydrationManifest\""]
#[doc = "    },"]
#[doc = "    \"SwarmTopologyManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/SwarmTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"SyntheticGenerationProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/SyntheticGenerationProfile\""]
#[doc = "    },"]
#[doc = "    \"System1ReflexPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/System1ReflexPolicy\""]
#[doc = "    },"]
#[doc = "    \"System2RemediationIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/System2RemediationIntent\""]
#[doc = "    },"]
#[doc = "    \"SystemFaultEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/SystemFaultEvent\""]
#[doc = "    },"]
#[doc = "    \"TabularCellState\": {"]
#[doc = "      \"$ref\": \"#/$defs/TabularCellState\""]
#[doc = "    },"]
#[doc = "    \"TabularEncodingProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/TabularEncodingProfile\""]
#[doc = "    },"]
#[doc = "    \"TabularMatrixProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/TabularMatrixProfile\""]
#[doc = "    },"]
#[doc = "    \"TargetTopologyProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/TargetTopologyProfile\""]
#[doc = "    },"]
#[doc = "    \"TaskAnnouncementIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/TaskAnnouncementIntent\""]
#[doc = "    },"]
#[doc = "    \"TaskAwardReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/TaskAwardReceipt\""]
#[doc = "    },"]
#[doc = "    \"TaxonomicNodeState\": {"]
#[doc = "      \"$ref\": \"#/$defs/TaxonomicNodeState\""]
#[doc = "    },"]
#[doc = "    \"TaxonomicRestructureIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/TaxonomicRestructureIntent\""]
#[doc = "    },"]
#[doc = "    \"TaxonomicRoutingPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/TaxonomicRoutingPolicy\""]
#[doc = "    },"]
#[doc = "    \"TelemetryBackpressureContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/TelemetryBackpressureContract\""]
#[doc = "    },"]
#[doc = "    \"TelemetryContextProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/TelemetryContextProfile\""]
#[doc = "    },"]
#[doc = "    \"TelemetryScalarState\": {"]
#[doc = "      \"$ref\": \"#/$defs/TelemetryScalarState\""]
#[doc = "    },"]
#[doc = "    \"TeleologicalIsometryReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/TeleologicalIsometryReceipt\""]
#[doc = "    },"]
#[doc = "    \"TemporalBoundsProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/TemporalBoundsProfile\""]
#[doc = "    },"]
#[doc = "    \"TemporalCheckpointState\": {"]
#[doc = "      \"$ref\": \"#/$defs/TemporalCheckpointState\""]
#[doc = "    },"]
#[doc = "    \"TemporalConflictResolutionPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/TemporalConflictResolutionPolicy\""]
#[doc = "    },"]
#[doc = "    \"TemporalEdgeInvalidationIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/TemporalEdgeInvalidationIntent\""]
#[doc = "    },"]
#[doc = "    \"TemporalGraphCRDTManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/TemporalGraphCRDTManifest\""]
#[doc = "    },"]
#[doc = "    \"TensorStructuralFormatProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/TensorStructuralFormatProfile\""]
#[doc = "    },"]
#[doc = "    \"TerminalBufferState\": {"]
#[doc = "      \"$ref\": \"#/$defs/TerminalBufferState\""]
#[doc = "    },"]
#[doc = "    \"TerminalCognitiveEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/TerminalCognitiveEvent\""]
#[doc = "    },"]
#[doc = "    \"TerminalConditionContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/TerminalConditionContract\""]
#[doc = "    },"]
#[doc = "    \"TheoryOfMindSnapshot\": {"]
#[doc = "      \"$ref\": \"#/$defs/TheoryOfMindSnapshot\""]
#[doc = "    },"]
#[doc = "    \"ThoughtBranchState\": {"]
#[doc = "      \"$ref\": \"#/$defs/ThoughtBranchState\""]
#[doc = "    },"]
#[doc = "    \"TieBreakerPolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/TieBreakerPolicy\""]
#[doc = "    },"]
#[doc = "    \"TokenBurnReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/TokenBurnReceipt\""]
#[doc = "    },"]
#[doc = "    \"ToolInvocationEvent\": {"]
#[doc = "      \"$ref\": \"#/$defs/ToolInvocationEvent\""]
#[doc = "    },"]
#[doc = "    \"TopologicalFidelityReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/TopologicalFidelityReceipt\""]
#[doc = "    },"]
#[doc = "    \"TopologicalProjectionIntent\": {"]
#[doc = "      \"$ref\": \"#/$defs/TopologicalProjectionIntent\""]
#[doc = "    },"]
#[doc = "    \"TopologicalRetrievalContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/TopologicalRetrievalContract\""]
#[doc = "    },"]
#[doc = "    \"TopologyHashReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/TopologyHashReceipt\""]
#[doc = "    },"]
#[doc = "    \"TraceContextState\": {"]
#[doc = "      \"$ref\": \"#/$defs/TraceContextState\""]
#[doc = "    },"]
#[doc = "    \"TransformationMechanismProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/TransformationMechanismProfile\""]
#[doc = "    },"]
#[doc = "    \"TransitionEdgeProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/TransitionEdgeProfile\""]
#[doc = "    },"]
#[doc = "    \"TruthMaintenancePolicy\": {"]
#[doc = "      \"$ref\": \"#/$defs/TruthMaintenancePolicy\""]
#[doc = "    },"]
#[doc = "    \"UpperOntologyClassProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/UpperOntologyClassProfile\""]
#[doc = "    },"]
#[doc = "    \"UtilityJustificationGraphReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/UtilityJustificationGraphReceipt\""]
#[doc = "    },"]
#[doc = "    \"VectorEmbeddingState\": {"]
#[doc = "      \"$ref\": \"#/$defs/VectorEmbeddingState\""]
#[doc = "    },"]
#[doc = "    \"VerifiableCredentialPresentationReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/VerifiableCredentialPresentationReceipt\""]
#[doc = "    },"]
#[doc = "    \"VerifiableEntropyReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/VerifiableEntropyReceipt\""]
#[doc = "    },"]
#[doc = "    \"ViewportProjectionContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/ViewportProjectionContract\""]
#[doc = "    },"]
#[doc = "    \"VisualEncodingProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/VisualEncodingProfile\""]
#[doc = "    },"]
#[doc = "    \"VolumetricBoundingProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/VolumetricBoundingProfile\""]
#[doc = "    },"]
#[doc = "    \"VolumetricEdgeProfile\": {"]
#[doc = "      \"$ref\": \"#/$defs/VolumetricEdgeProfile\""]
#[doc = "    },"]
#[doc = "    \"VolumetricPartitionState\": {"]
#[doc = "      \"$ref\": \"#/$defs/VolumetricPartitionState\""]
#[doc = "    },"]
#[doc = "    \"WetwareAttestationContract\": {"]
#[doc = "      \"$ref\": \"#/$defs/WetwareAttestationContract\""]
#[doc = "    },"]
#[doc = "    \"WorkflowManifest\": {"]
#[doc = "      \"$ref\": \"#/$defs/WorkflowManifest\""]
#[doc = "    },"]
#[doc = "    \"ZeroKnowledgeReceipt\": {"]
#[doc = "      \"$ref\": \"#/$defs/ZeroKnowledgeReceipt\""]
#[doc = "    }"]
#[doc = "  }"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
pub struct CoReasonSharedKernelOntology {
    #[serde(
        rename = "ActivationSteeringContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub activation_steering_contract: ::std::option::Option<ActivationSteeringContract>,
    #[serde(
        rename = "ActiveInferenceContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub active_inference_contract: ::std::option::Option<ActiveInferenceContract>,
    #[serde(
        rename = "AdjudicationIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub adjudication_intent: ::std::option::Option<AdjudicationIntent>,
    #[serde(
        rename = "AdjudicationReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub adjudication_receipt: ::std::option::Option<AdjudicationReceipt>,
    #[serde(
        rename = "AdjudicationRubricProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub adjudication_rubric_profile: ::std::option::Option<AdjudicationRubricProfile>,
    #[serde(
        rename = "AdversarialMarketTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub adversarial_market_topology_manifest:
        ::std::option::Option<AdversarialMarketTopologyManifest>,
    #[serde(
        rename = "AgentAttestationReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub agent_attestation_receipt: ::std::option::Option<AgentAttestationReceipt>,
    #[serde(
        rename = "AgentBidIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub agent_bid_intent: ::std::option::Option<AgentBidIntent>,
    #[serde(
        rename = "AlgebraicRefinementContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub algebraic_refinement_contract: ::std::option::Option<AlgebraicRefinementContract>,
    #[serde(
        rename = "AmbientState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub ambient_state: ::std::option::Option<AmbientState>,
    #[serde(
        rename = "AnalogicalMappingTask",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub analogical_mapping_task: ::std::option::Option<AnalogicalMappingTask>,
    #[serde(
        rename = "AnchoringPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub anchoring_policy: ::std::option::Option<AnchoringPolicy>,
    #[serde(
        rename = "AnyActionSpaceCapability",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub any_action_space_capability: ::std::option::Option<AnyActionSpaceCapability>,
    #[serde(
        rename = "AnyExplorationBranch",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub any_exploration_branch: ::std::option::Option<AnyExplorationBranch>,
    #[serde(
        rename = "AnyIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub any_intent: ::std::option::Option<AnyIntent>,
    #[serde(
        rename = "AnyNodeProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub any_node_profile: ::std::option::Option<AnyNodeProfile>,
    #[serde(
        rename = "AnyPanelProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub any_panel_profile: ::std::option::Option<AnyPanelProfile>,
    #[serde(
        rename = "AnyPresentationIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub any_presentation_intent: ::std::option::Option<AnyPresentationIntent>,
    #[serde(
        rename = "AnyStateEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub any_state_event: ::std::option::Option<AnyStateEvent>,
    #[serde(
        rename = "AnyToolchainState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub any_toolchain_state: ::std::option::Option<AnyToolchainState>,
    #[serde(
        rename = "AnyTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub any_topology_manifest: ::std::option::Option<AnyTopologyManifest>,
    #[serde(
        rename = "AnyTransitionEdge",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub any_transition_edge: ::std::option::Option<AnyTransitionEdge>,
    #[serde(
        rename = "ArtifactCorruptionEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub artifact_corruption_event: ::std::option::Option<ArtifactCorruptionEvent>,
    #[serde(
        rename = "ASTGradientReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub ast_gradient_receipt: ::std::option::Option<AstGradientReceipt>,
    #[serde(
        rename = "AsymptoticComplexityReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub asymptotic_complexity_receipt: ::std::option::Option<AsymptoticComplexityReceipt>,
    #[serde(
        rename = "AtomicPropositionState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub atomic_proposition_state: ::std::option::Option<AtomicPropositionState>,
    #[serde(
        rename = "AttackVectorProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub attack_vector_profile: ::std::option::Option<AttackVectorProfile>,
    #[serde(
        rename = "AuctionMechanismProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub auction_mechanism_profile: ::std::option::Option<AuctionMechanismProfile>,
    #[serde(
        rename = "AuctionPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub auction_policy: ::std::option::Option<AuctionPolicy>,
    #[serde(
        rename = "AuctionState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub auction_state: ::std::option::Option<AuctionState>,
    #[serde(
        rename = "BackpressurePolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub backpressure_policy: ::std::option::Option<BackpressurePolicy>,
    #[serde(
        rename = "BargeInInterruptEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub barge_in_interrupt_event: ::std::option::Option<BargeInInterruptEvent>,
    #[serde(
        rename = "BeliefModulationReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub belief_modulation_receipt: ::std::option::Option<BeliefModulationReceipt>,
    #[serde(
        rename = "BeliefMutationEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub belief_mutation_event: ::std::option::Option<BeliefMutationEvent>,
    #[serde(
        rename = "BoundedInterventionScopePolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub bounded_intervention_scope_policy: ::std::option::Option<BoundedInterventionScopePolicy>,
    #[serde(
        rename = "BoundedJSONRPCIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub bounded_jsonrpc_intent: ::std::option::Option<BoundedJsonrpcIntent>,
    #[serde(
        rename = "BrowserDOMState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub browser_dom_state: ::std::option::Option<BrowserDomState>,
    #[serde(
        rename = "BudgetExhaustionEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub budget_exhaustion_event: ::std::option::Option<BudgetExhaustionEvent>,
    #[serde(
        rename = "BundleContentHashState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub bundle_content_hash_state: ::std::option::Option<BundleContentHashState>,
    #[serde(
        rename = "BypassReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub bypass_receipt: ::std::option::Option<BypassReceipt>,
    #[serde(
        rename = "CapabilityForgeTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub capability_forge_topology_manifest: ::std::option::Option<CapabilityForgeTopologyManifest>,
    #[serde(
        rename = "CapabilityPointerState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub capability_pointer_state: ::std::option::Option<CapabilityPointerState>,
    #[serde(
        rename = "CausalAttributionState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub causal_attribution_state: ::std::option::Option<CausalAttributionState>,
    #[serde(
        rename = "CausalDirectedEdgeState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub causal_directed_edge_state: ::std::option::Option<CausalDirectedEdgeState>,
    #[serde(
        rename = "CausalExplanationEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub causal_explanation_event: ::std::option::Option<CausalExplanationEvent>,
    #[serde(
        rename = "CausalIntervalProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub causal_interval_profile: ::std::option::Option<CausalIntervalProfile>,
    #[serde(
        rename = "CausalPropagationIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub causal_propagation_intent: ::std::option::Option<CausalPropagationIntent>,
    #[serde(
        rename = "CircuitBreakerEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub circuit_breaker_event: ::std::option::Option<CircuitBreakerEvent>,
    #[serde(
        rename = "CognitiveActionSpaceManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_action_space_manifest: ::std::option::Option<CognitiveActionSpaceManifest>,
    #[serde(
        rename = "CognitiveAgentNodeProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_agent_node_profile: ::std::option::Option<CognitiveAgentNodeProfile>,
    #[serde(
        rename = "CognitiveCritiqueProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_critique_profile: ::std::option::Option<CognitiveCritiqueProfile>,
    #[serde(
        rename = "CognitiveDetailedBalanceContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_detailed_balance_contract:
        ::std::option::Option<CognitiveDetailedBalanceContract>,
    #[serde(
        rename = "CognitiveDualVerificationReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_dual_verification_receipt:
        ::std::option::Option<CognitiveDualVerificationReceipt>,
    #[serde(
        rename = "CognitiveHumanNodeProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_human_node_profile: ::std::option::Option<CognitiveHumanNodeProfile>,
    #[serde(
        rename = "CognitivePredictionReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_prediction_receipt: ::std::option::Option<CognitivePredictionReceipt>,
    #[serde(
        rename = "CognitiveReasoningTraceState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_reasoning_trace_state: ::std::option::Option<CognitiveReasoningTraceState>,
    #[serde(
        rename = "CognitiveRoutingContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_routing_contract: ::std::option::Option<CognitiveRoutingContract>,
    #[serde(
        rename = "CognitiveSamplingPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_sampling_policy: ::std::option::Option<CognitiveSamplingPolicy>,
    #[serde(
        rename = "CognitiveStateProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_state_profile: ::std::option::Option<CognitiveStateProfile>,
    #[serde(
        rename = "CognitiveSwarmDeploymentManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_swarm_deployment_manifest:
        ::std::option::Option<CognitiveSwarmDeploymentManifest>,
    #[serde(
        rename = "CognitiveSystemNodeProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_system_node_profile: ::std::option::Option<CognitiveSystemNodeProfile>,
    #[serde(
        rename = "CognitiveTierProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_tier_profile: ::std::option::Option<CognitiveTierProfile>,
    #[serde(
        rename = "CognitiveUncertaintyProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cognitive_uncertainty_profile: ::std::option::Option<CognitiveUncertaintyProfile>,
    #[serde(
        rename = "CollectiveIntelligenceProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub collective_intelligence_profile: ::std::option::Option<CollectiveIntelligenceProfile>,
    #[serde(
        rename = "CompositeNodeProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub composite_node_profile: ::std::option::Option<CompositeNodeProfile>,
    #[serde(
        rename = "ComputeEngineProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub compute_engine_profile: ::std::option::Option<ComputeEngineProfile>,
    #[serde(
        rename = "ComputeProvisioningIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub compute_provisioning_intent: ::std::option::Option<ComputeProvisioningIntent>,
    #[serde(
        rename = "ComputeRateContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub compute_rate_contract: ::std::option::Option<ComputeRateContract>,
    #[serde(
        rename = "ConsensusFederationTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub consensus_federation_topology_manifest:
        ::std::option::Option<ConsensusFederationTopologyManifest>,
    #[serde(
        rename = "ConsensusPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub consensus_policy: ::std::option::Option<ConsensusPolicy>,
    #[serde(
        rename = "ConstitutionalAmendmentIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub constitutional_amendment_intent: ::std::option::Option<ConstitutionalAmendmentIntent>,
    #[serde(
        rename = "ConstrainedDecodingPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub constrained_decoding_policy: ::std::option::Option<ConstrainedDecodingPolicy>,
    #[serde(
        rename = "ContextExpansionPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub context_expansion_policy: ::std::option::Option<ContextExpansionPolicy>,
    #[serde(
        rename = "ContextualSemanticResolutionIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub contextual_semantic_resolution_intent:
        ::std::option::Option<ContextualSemanticResolutionIntent>,
    #[serde(
        rename = "ContextualizedSourceState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub contextualized_source_state: ::std::option::Option<ContextualizedSourceState>,
    #[serde(
        rename = "ContinuousManifoldMappingContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub continuous_manifold_mapping_contract:
        ::std::option::Option<ContinuousManifoldMappingContract>,
    #[serde(
        rename = "ContinuousMutationPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub continuous_mutation_policy: ::std::option::Option<ContinuousMutationPolicy>,
    #[serde(
        rename = "ContinuousObservationState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub continuous_observation_state: ::std::option::Option<ContinuousObservationState>,
    #[serde(
        rename = "ContinuousSpatialMutationIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub continuous_spatial_mutation_intent: ::std::option::Option<ContinuousSpatialMutationIntent>,
    #[serde(
        rename = "CouncilTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub council_topology_manifest: ::std::option::Option<CouncilTopologyManifest>,
    #[serde(
        rename = "CounterfactualRegretEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub counterfactual_regret_event: ::std::option::Option<CounterfactualRegretEvent>,
    #[serde(
        rename = "CrossoverMechanismProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub crossover_mechanism_profile: ::std::option::Option<CrossoverMechanismProfile>,
    #[serde(
        rename = "CrossoverPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub crossover_policy: ::std::option::Option<CrossoverPolicy>,
    #[serde(
        rename = "CrosswalkResolutionReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub crosswalk_resolution_receipt: ::std::option::Option<CrosswalkResolutionReceipt>,
    #[serde(
        rename = "CryptographicProvenancePolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cryptographic_provenance_policy: ::std::option::Option<CryptographicProvenancePolicy>,
    #[serde(
        rename = "CrystallizationPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub crystallization_policy: ::std::option::Option<CrystallizationPolicy>,
    #[serde(
        rename = "CustodyReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub custody_receipt: ::std::option::Option<CustodyReceipt>,
    #[serde(
        rename = "CyclicEdgeProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub cyclic_edge_profile: ::std::option::Option<CyclicEdgeProfile>,
    #[serde(
        rename = "DAGTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub dag_topology_manifest: ::std::option::Option<DagTopologyManifest>,
    #[serde(
        rename = "DefeasibleAttackEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub defeasible_attack_event: ::std::option::Option<DefeasibleAttackEvent>,
    #[serde(
        rename = "DefeasibleCascadeEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub defeasible_cascade_event: ::std::option::Option<DefeasibleCascadeEvent>,
    #[serde(
        rename = "DelegatedCapabilityManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub delegated_capability_manifest: ::std::option::Option<DelegatedCapabilityManifest>,
    #[serde(
        rename = "DeliberativeEnvelope",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub deliberative_envelope: ::std::option::Option<DeliberativeEnvelope>,
    #[serde(
        rename = "DempsterShaferBeliefVector",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub dempster_shafer_belief_vector: ::std::option::Option<DempsterShaferBeliefVector>,
    #[serde(
        rename = "DerivationModeProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub derivation_mode_profile: ::std::option::Option<DerivationModeProfile>,
    #[serde(
        rename = "DifferentiableLogicPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub differentiable_logic_policy: ::std::option::Option<DifferentiableLogicPolicy>,
    #[serde(
        rename = "DigitalTwinTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub digital_twin_topology_manifest: ::std::option::Option<DigitalTwinTopologyManifest>,
    #[serde(
        rename = "DiscourseNodeState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub discourse_node_state: ::std::option::Option<DiscourseNodeState>,
    #[serde(
        rename = "DiscourseTreeManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub discourse_tree_manifest: ::std::option::Option<DiscourseTreeManifest>,
    #[serde(
        rename = "DistributionProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub distribution_profile: ::std::option::Option<DistributionProfile>,
    #[serde(
        rename = "DistributionShapeProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub distribution_shape_profile: ::std::option::Option<DistributionShapeProfile>,
    #[serde(
        rename = "DiversityPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub diversity_policy: ::std::option::Option<DiversityPolicy>,
    #[serde(
        rename = "DocumentKnowledgeGraphManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub document_knowledge_graph_manifest: ::std::option::Option<DocumentKnowledgeGraphManifest>,
    #[serde(
        rename = "DocumentLayoutManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub document_layout_manifest: ::std::option::Option<DocumentLayoutManifest>,
    #[serde(
        rename = "DocumentLayoutRegionState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub document_layout_region_state: ::std::option::Option<DocumentLayoutRegionState>,
    #[serde(
        rename = "DraftingIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub drafting_intent: ::std::option::Option<DraftingIntent>,
    #[serde(
        rename = "DynamicConvergenceSLA",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub dynamic_convergence_sla: ::std::option::Option<DynamicConvergenceSla>,
    #[serde(
        rename = "DynamicLayoutManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub dynamic_layout_manifest: ::std::option::Option<DynamicLayoutManifest>,
    #[serde(
        rename = "DynamicManifoldProjectionManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub dynamic_manifold_projection_manifest:
        ::std::option::Option<DynamicManifoldProjectionManifest>,
    #[serde(
        rename = "DynamicRoutingManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub dynamic_routing_manifest: ::std::option::Option<DynamicRoutingManifest>,
    #[serde(
        rename = "EdgeMappingContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub edge_mapping_contract: ::std::option::Option<EdgeMappingContract>,
    #[serde(
        rename = "EmbodiedSensoryVectorProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub embodied_sensory_vector_profile: ::std::option::Option<EmbodiedSensoryVectorProfile>,
    #[serde(
        rename = "EmpiricalFalsificationContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub empirical_falsification_contract: ::std::option::Option<EmpiricalFalsificationContract>,
    #[serde(
        rename = "EmpiricalStatisticalProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub empirical_statistical_profile: ::std::option::Option<EmpiricalStatisticalProfile>,
    #[serde(
        rename = "EnsembleTopologyProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub ensemble_topology_profile: ::std::option::Option<EnsembleTopologyProfile>,
    #[serde(
        rename = "EphemeralNamespacePartitionState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub ephemeral_namespace_partition_state:
        ::std::option::Option<EphemeralNamespacePartitionState>,
    #[serde(
        rename = "EpistemicArgumentClaimState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_argument_claim_state: ::std::option::Option<EpistemicArgumentClaimState>,
    #[serde(
        rename = "EpistemicArgumentGraphState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_argument_graph_state: ::std::option::Option<EpistemicArgumentGraphState>,
    #[serde(
        rename = "EpistemicAttentionState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_attention_state: ::std::option::Option<EpistemicAttentionState>,
    #[serde(
        rename = "EpistemicAxiomState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_axiom_state: ::std::option::Option<EpistemicAxiomState>,
    #[serde(
        rename = "EpistemicAxiomVerificationReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_axiom_verification_receipt:
        ::std::option::Option<EpistemicAxiomVerificationReceipt>,
    #[serde(
        rename = "EpistemicChainGraphState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_chain_graph_state: ::std::option::Option<EpistemicChainGraphState>,
    #[serde(
        rename = "EpistemicCompressionSLA",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_compression_sla: ::std::option::Option<EpistemicCompressionSla>,
    #[serde(
        rename = "EpistemicConstraintPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_constraint_policy: ::std::option::Option<EpistemicConstraintPolicy>,
    #[serde(
        rename = "EpistemicCurriculumManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_curriculum_manifest: ::std::option::Option<EpistemicCurriculumManifest>,
    #[serde(
        rename = "EpistemicDomainGraphManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_domain_graph_manifest: ::std::option::Option<EpistemicDomainGraphManifest>,
    #[serde(
        rename = "EpistemicEscalationContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_escalation_contract: ::std::option::Option<EpistemicEscalationContract>,
    #[serde(
        rename = "EpistemicFlowStateReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_flow_state_receipt: ::std::option::Option<EpistemicFlowStateReceipt>,
    #[serde(
        rename = "EpistemicGroundedTaskManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_grounded_task_manifest: ::std::option::Option<EpistemicGroundedTaskManifest>,
    #[serde(
        rename = "EpistemicGuardrailsManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_guardrails_manifest: ::std::option::Option<EpistemicGuardrailsManifest>,
    #[serde(
        rename = "EpistemicHydrationPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_hydration_policy: ::std::option::Option<EpistemicHydrationPolicy>,
    #[serde(
        rename = "EpistemicLedgerState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_ledger_state: ::std::option::Option<EpistemicLedgerState>,
    #[serde(
        rename = "EpistemicLogEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_log_event: ::std::option::Option<EpistemicLogEvent>,
    #[serde(
        rename = "EpistemicPromotionEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_promotion_event: ::std::option::Option<EpistemicPromotionEvent>,
    #[serde(
        rename = "EpistemicProvenanceReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_provenance_receipt: ::std::option::Option<EpistemicProvenanceReceipt>,
    #[serde(
        rename = "EpistemicProxyState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_proxy_state: ::std::option::Option<EpistemicProxyState>,
    #[serde(
        rename = "EpistemicProxyState_Any_",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_proxy_state_any: ::std::option::Option<EpistemicProxyStateAny>,
    #[serde(
        rename = "EpistemicQuarantineSnapshot",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_quarantine_snapshot: ::std::option::Option<EpistemicQuarantineSnapshot>,
    #[serde(
        rename = "EpistemicRejectionReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_rejection_receipt: ::std::option::Option<EpistemicRejectionReceipt>,
    #[serde(
        rename = "EpistemicRigidityPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_rigidity_policy: ::std::option::Option<EpistemicRigidityPolicy>,
    #[serde(
        rename = "EpistemicScanningPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_scanning_policy: ::std::option::Option<EpistemicScanningPolicy>,
    #[serde(
        rename = "EpistemicSecurityPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_security_policy: ::std::option::Option<EpistemicSecurityPolicy>,
    #[serde(
        rename = "EpistemicSecurityProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_security_profile: ::std::option::Option<EpistemicSecurityProfile>,
    #[serde(
        rename = "EpistemicSeedInjectionPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_seed_injection_policy: ::std::option::Option<EpistemicSeedInjectionPolicy>,
    #[serde(
        rename = "EpistemicSOPManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_sop_manifest: ::std::option::Option<EpistemicSopManifest>,
    #[serde(
        rename = "EpistemicStarvationEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_starvation_event: ::std::option::Option<EpistemicStarvationEvent>,
    #[serde(
        rename = "EpistemicTelemetryEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_telemetry_event: ::std::option::Option<EpistemicTelemetryEvent>,
    #[serde(
        rename = "EpistemicTopologicalProofManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_topological_proof_manifest:
        ::std::option::Option<EpistemicTopologicalProofManifest>,
    #[serde(
        rename = "EpistemicTransmutationTask",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_transmutation_task: ::std::option::Option<EpistemicTransmutationTask>,
    #[serde(
        rename = "EpistemicUpsamplingTask",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_upsampling_task: ::std::option::Option<EpistemicUpsamplingTask>,
    #[serde(
        rename = "EpistemicZeroTrustContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_zero_trust_contract: ::std::option::Option<EpistemicZeroTrustContract>,
    #[serde(
        rename = "EpistemicZeroTrustReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub epistemic_zero_trust_receipt: ::std::option::Option<EpistemicZeroTrustReceipt>,
    #[serde(
        rename = "EscalationContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub escalation_contract: ::std::option::Option<EscalationContract>,
    #[serde(
        rename = "EscalationIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub escalation_intent: ::std::option::Option<EscalationIntent>,
    #[serde(
        rename = "EscrowPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub escrow_policy: ::std::option::Option<EscrowPolicy>,
    #[serde(
        rename = "EvaluatorOptimizerTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub evaluator_optimizer_topology_manifest:
        ::std::option::Option<EvaluatorOptimizerTopologyManifest>,
    #[serde(
        rename = "EvictionPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub eviction_policy: ::std::option::Option<EvictionPolicy>,
    #[serde(
        rename = "EvidentiaryCitationState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub evidentiary_citation_state: ::std::option::Option<EvidentiaryCitationState>,
    #[serde(
        rename = "EvidentiaryGroundingSLA",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub evidentiary_grounding_sla: ::std::option::Option<EvidentiaryGroundingSla>,
    #[serde(
        rename = "EvidentiaryWarrantState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub evidentiary_warrant_state: ::std::option::Option<EvidentiaryWarrantState>,
    #[serde(
        rename = "EvolutionaryTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub evolutionary_topology_manifest: ::std::option::Option<EvolutionaryTopologyManifest>,
    #[serde(
        rename = "ExecutionEnvelopeState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub execution_envelope_state: ::std::option::Option<ExecutionEnvelopeState>,
    #[serde(
        rename = "ExecutionSLA",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub execution_sla: ::std::option::Option<ExecutionSla>,
    #[serde(
        rename = "ExecutionSubstrateProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub execution_substrate_profile: ::std::option::Option<ExecutionSubstrateProfile>,
    #[serde(
        rename = "ExogenousEpistemicEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub exogenous_epistemic_event: ::std::option::Option<ExogenousEpistemicEvent>,
    #[serde(
        rename = "FacetMatrixProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub facet_matrix_profile: ::std::option::Option<FacetMatrixProfile>,
    #[serde(
        rename = "FallbackIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub fallback_intent: ::std::option::Option<FallbackIntent>,
    #[serde(
        rename = "FallbackSLA",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub fallback_sla: ::std::option::Option<FallbackSla>,
    #[serde(
        rename = "FalsificationContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub falsification_contract: ::std::option::Option<FalsificationContract>,
    #[serde(
        rename = "FitnessObjectiveProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub fitness_objective_profile: ::std::option::Option<FitnessObjectiveProfile>,
    #[serde(
        rename = "FormalLogicPremise",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub formal_logic_premise: ::std::option::Option<FormalLogicPremise>,
    #[serde(
        rename = "FormalVerificationContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub formal_verification_contract: ::std::option::Option<FormalVerificationContract>,
    #[serde(
        rename = "FormalVerificationReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub formal_verification_receipt: ::std::option::Option<FormalVerificationReceipt>,
    #[serde(
        rename = "FYIIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub fyi_intent: ::std::option::Option<FyiIntent>,
    #[serde(
        rename = "GenerativeManifoldSLA",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub generative_manifold_sla: ::std::option::Option<GenerativeManifoldSla>,
    #[serde(
        rename = "GenerativeTaxonomyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub generative_taxonomy_manifest: ::std::option::Option<GenerativeTaxonomyManifest>,
    #[serde(
        rename = "GlobalGovernancePolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub global_governance_policy: ::std::option::Option<GlobalGovernancePolicy>,
    #[serde(
        rename = "GlobalSemanticInvariantProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub global_semantic_invariant_profile: ::std::option::Option<GlobalSemanticInvariantProfile>,
    #[serde(
        rename = "GlobalSemanticProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub global_semantic_profile: ::std::option::Option<GlobalSemanticProfile>,
    #[serde(
        rename = "GradingCriterionProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub grading_criterion_profile: ::std::option::Option<GradingCriterionProfile>,
    #[serde(
        rename = "GrammarPanelProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub grammar_panel_profile: ::std::option::Option<GrammarPanelProfile>,
    #[serde(
        rename = "GraphFlatteningPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub graph_flattening_policy: ::std::option::Option<GraphFlatteningPolicy>,
    #[serde(
        rename = "GuardrailViolationEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub guardrail_violation_event: ::std::option::Option<GuardrailViolationEvent>,
    #[serde(
        rename = "HardwareEnclaveReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub hardware_enclave_receipt: ::std::option::Option<HardwareEnclaveReceipt>,
    #[serde(
        rename = "HierarchicalDOMManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub hierarchical_dom_manifest: ::std::option::Option<HierarchicalDomManifest>,
    #[serde(
        rename = "HoareLogicProofReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub hoare_logic_proof_receipt: ::std::option::Option<HoareLogicProofReceipt>,
    #[serde(
        rename = "HomomorphicEncryptionProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub homomorphic_encryption_profile: ::std::option::Option<HomomorphicEncryptionProfile>,
    #[serde(
        rename = "HTTPTransportProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub http_transport_profile: ::std::option::Option<HttpTransportProfile>,
    #[serde(
        rename = "HumanDirectiveIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub human_directive_intent: ::std::option::Option<HumanDirectiveIntent>,
    #[serde(
        rename = "HypothesisGenerationEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub hypothesis_generation_event: ::std::option::Option<HypothesisGenerationEvent>,
    #[serde(
        rename = "HypothesisStakeReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub hypothesis_stake_receipt: ::std::option::Option<HypothesisStakeReceipt>,
    #[serde(
        rename = "HypothesisSuperpositionState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub hypothesis_superposition_state: ::std::option::Option<HypothesisSuperpositionState>,
    #[serde(
        rename = "IdeationPhaseProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub ideation_phase_profile: ::std::option::Option<IdeationPhaseProfile>,
    #[serde(
        rename = "IllocutionaryForceProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub illocutionary_force_profile: ::std::option::Option<IllocutionaryForceProfile>,
    #[serde(
        rename = "InputMappingContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub input_mapping_contract: ::std::option::Option<InputMappingContract>,
    #[serde(
        rename = "InsightCardProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub insight_card_profile: ::std::option::Option<InsightCardProfile>,
    #[serde(
        rename = "IntentClassificationReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub intent_classification_receipt: ::std::option::Option<IntentClassificationReceipt>,
    #[serde(
        rename = "IntentElicitationTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub intent_elicitation_topology_manifest:
        ::std::option::Option<IntentElicitationTopologyManifest>,
    #[serde(
        rename = "InterventionIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub intervention_intent: ::std::option::Option<InterventionIntent>,
    #[serde(
        rename = "InterventionPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub intervention_policy: ::std::option::Option<InterventionPolicy>,
    #[serde(
        rename = "InterventionReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub intervention_receipt: ::std::option::Option<InterventionReceipt>,
    #[serde(
        rename = "InterventionalCausalTask",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub interventional_causal_task: ::std::option::Option<InterventionalCausalTask>,
    #[serde(
        rename = "JsonPrimitiveState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub json_primitive_state: ::std::option::Option<JsonPrimitiveState>,
    #[serde(
        rename = "JSONRPCErrorResponseState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub jsonrpc_error_response_state: ::std::option::Option<JsonrpcErrorResponseState>,
    #[serde(
        rename = "JSONRPCErrorState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub jsonrpc_error_state: ::std::option::Option<JsonrpcErrorState>,
    #[serde(
        rename = "KinematicDeltaManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub kinematic_delta_manifest: ::std::option::Option<KinematicDeltaManifest>,
    #[serde(
        rename = "KinematicDerivativeProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub kinematic_derivative_profile: ::std::option::Option<KinematicDerivativeProfile>,
    #[serde(
        rename = "KineticBudgetPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub kinetic_budget_policy: ::std::option::Option<KineticBudgetPolicy>,
    #[serde(
        rename = "KineticSeparationPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub kinetic_separation_policy: ::std::option::Option<KineticSeparationPolicy>,
    #[serde(
        rename = "LatentProjectionIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub latent_projection_intent: ::std::option::Option<LatentProjectionIntent>,
    #[serde(
        rename = "LatentSchemaInferenceIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub latent_schema_inference_intent: ::std::option::Option<LatentSchemaInferenceIntent>,
    #[serde(
        rename = "LatentScratchpadReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub latent_scratchpad_receipt: ::std::option::Option<LatentScratchpadReceipt>,
    #[serde(
        rename = "LatentSmoothingProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub latent_smoothing_profile: ::std::option::Option<LatentSmoothingProfile>,
    #[serde(
        rename = "LifecycleTriggerEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub lifecycle_trigger_event: ::std::option::Option<LifecycleTriggerEvent>,
    #[serde(
        rename = "LineageWatermarkReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub lineage_watermark_receipt: ::std::option::Option<LineageWatermarkReceipt>,
    #[serde(
        rename = "LinkMLValidationSLA",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub link_ml_validation_sla: ::std::option::Option<LinkMlValidationSla>,
    #[serde(
        rename = "LogitSteganographyContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub logit_steganography_contract: ::std::option::Option<LogitSteganographyContract>,
    #[serde(
        rename = "MacroGridProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub macro_grid_profile: ::std::option::Option<MacroGridProfile>,
    #[serde(
        rename = "ManifestViolationReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub manifest_violation_receipt: ::std::option::Option<ManifestViolationReceipt>,
    #[serde(
        rename = "ManifoldAlignmentMetricProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub manifold_alignment_metric_profile: ::std::option::Option<ManifoldAlignmentMetricProfile>,
    #[serde(
        rename = "MarketContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub market_contract: ::std::option::Option<MarketContract>,
    #[serde(
        rename = "MarketResolutionState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub market_resolution_state: ::std::option::Option<MarketResolutionState>,
    #[serde(
        rename = "MarkovBlanketRenderingPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub markov_blanket_rendering_policy: ::std::option::Option<MarkovBlanketRenderingPolicy>,
    #[serde(
        rename = "MCPCapabilityWhitelistPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub mcp_capability_whitelist_policy: ::std::option::Option<McpCapabilityWhitelistPolicy>,
    #[serde(
        rename = "MCPClientIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub mcp_client_intent: ::std::option::Option<McpClientIntent>,
    #[serde(
        rename = "MCPPromptReferenceState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub mcp_prompt_reference_state: ::std::option::Option<McpPromptReferenceState>,
    #[serde(
        rename = "MCPResourceManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub mcp_resource_manifest: ::std::option::Option<McpResourceManifest>,
    #[serde(
        rename = "MCPServerManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub mcp_server_manifest: ::std::option::Option<McpServerManifest>,
    #[serde(
        rename = "MCPToolDefinition",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub mcp_tool_definition: ::std::option::Option<McpToolDefinition>,
    #[serde(
        rename = "MechanisticAuditContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub mechanistic_audit_contract: ::std::option::Option<MechanisticAuditContract>,
    #[serde(
        rename = "MemoizedNodeProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub memoized_node_profile: ::std::option::Option<MemoizedNodeProfile>,
    #[serde(
        rename = "MultimodalArtifactReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub multimodal_artifact_receipt: ::std::option::Option<MultimodalArtifactReceipt>,
    #[serde(
        rename = "MultimodalTokenAnchorState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub multimodal_token_anchor_state: ::std::option::Option<MultimodalTokenAnchorState>,
    #[serde(
        rename = "MutationPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub mutation_policy: ::std::option::Option<MutationPolicy>,
    #[serde(
        rename = "NDimensionalTensorManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub n_dimensional_tensor_manifest: ::std::option::Option<NDimensionalTensorManifest>,
    #[serde(
        rename = "NeuralAuditAttestationReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub neural_audit_attestation_receipt: ::std::option::Option<NeuralAuditAttestationReceipt>,
    #[serde(
        rename = "NeuroSymbolicHandoffContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub neuro_symbolic_handoff_contract: ::std::option::Option<NeuroSymbolicHandoffContract>,
    #[serde(
        rename = "NeurosymbolicInferenceIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub neurosymbolic_inference_intent: ::std::option::Option<NeurosymbolicInferenceIntent>,
    #[serde(
        rename = "NeurosymbolicIngestionTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub neurosymbolic_ingestion_topology_manifest:
        ::std::option::Option<NeurosymbolicIngestionTopologyManifest>,
    #[serde(
        rename = "NeurosymbolicVerificationTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub neurosymbolic_verification_topology_manifest:
        ::std::option::Option<NeurosymbolicVerificationTopologyManifest>,
    #[serde(
        rename = "NodeCIDState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub node_cid_state: ::std::option::Option<NodeCidState>,
    #[serde(
        rename = "ObservabilityLODPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub observability_lod_policy: ::std::option::Option<ObservabilityLodPolicy>,
    #[serde(
        rename = "ObservationEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub observation_event: ::std::option::Option<ObservationEvent>,
    #[serde(
        rename = "OntologicalAlignmentPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub ontological_alignment_policy: ::std::option::Option<OntologicalAlignmentPolicy>,
    #[serde(
        rename = "OntologicalCrosswalkIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub ontological_crosswalk_intent: ::std::option::Option<OntologicalCrosswalkIntent>,
    #[serde(
        rename = "OntologicalNormalizationIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub ontological_normalization_intent: ::std::option::Option<OntologicalNormalizationIntent>,
    #[serde(
        rename = "OntologicalReificationReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub ontological_reification_receipt: ::std::option::Option<OntologicalReificationReceipt>,
    #[serde(
        rename = "OntologicalSurfaceProjectionManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub ontological_surface_projection_manifest:
        ::std::option::Option<OntologicalSurfaceProjectionManifest>,
    #[serde(
        rename = "OntologyDiscoveryIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub ontology_discovery_intent: ::std::option::Option<OntologyDiscoveryIntent>,
    #[serde(
        rename = "OpticalMappingContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub optical_mapping_contract: ::std::option::Option<OpticalMappingContract>,
    #[serde(
        rename = "OpticalParsingSLA",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub optical_parsing_sla: ::std::option::Option<OpticalParsingSla>,
    #[serde(
        rename = "OptimizationDirectionProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub optimization_direction_profile: ::std::option::Option<OptimizationDirectionProfile>,
    #[serde(
        rename = "OracleExecutionReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub oracle_execution_receipt: ::std::option::Option<OracleExecutionReceipt>,
    #[serde(
        rename = "OutputMappingContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub output_mapping_contract: ::std::option::Option<OutputMappingContract>,
    #[serde(
        rename = "OverrideIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub override_intent: ::std::option::Option<OverrideIntent>,
    #[serde(
        rename = "PatchOperationProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub patch_operation_profile: ::std::option::Option<PatchOperationProfile>,
    #[serde(
        rename = "PeftAdapterContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub peft_adapter_contract: ::std::option::Option<PeftAdapterContract>,
    #[serde(
        rename = "PermissionBoundaryPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub permission_boundary_policy: ::std::option::Option<PermissionBoundaryPolicy>,
    #[serde(
        rename = "PersistenceCommitReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub persistence_commit_receipt: ::std::option::Option<PersistenceCommitReceipt>,
    #[serde(
        rename = "PostCoordinatedSemanticState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub post_coordinated_semantic_state: ::std::option::Option<PostCoordinatedSemanticState>,
    #[serde(
        rename = "PostQuantumSignatureReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub post_quantum_signature_receipt: ::std::option::Option<PostQuantumSignatureReceipt>,
    #[serde(
        rename = "PredictionMarketPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub prediction_market_policy: ::std::option::Option<PredictionMarketPolicy>,
    #[serde(
        rename = "PredictionMarketState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub prediction_market_state: ::std::option::Option<PredictionMarketState>,
    #[serde(
        rename = "PresentationManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub presentation_manifest: ::std::option::Option<PresentationManifest>,
    #[serde(
        rename = "ProceduralMetadataManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub procedural_metadata_manifest: ::std::option::Option<ProceduralMetadataManifest>,
    #[serde(
        rename = "ProcessRewardContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub process_reward_contract: ::std::option::Option<ProcessRewardContract>,
    #[serde(
        rename = "ProfileCIDState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub profile_cid_state: ::std::option::Option<ProfileCidState>,
    #[serde(
        rename = "QoSClassificationProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub qo_s_classification_profile: ::std::option::Option<QoSClassificationProfile>,
    #[serde(
        rename = "QuarantineIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub quarantine_intent: ::std::option::Option<QuarantineIntent>,
    #[serde(
        rename = "QuorumPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub quorum_policy: ::std::option::Option<QuorumPolicy>,
    #[serde(
        rename = "RDFExportReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub rdf_export_receipt: ::std::option::Option<RdfExportReceipt>,
    #[serde(
        rename = "RDFSerializationIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub rdf_serialization_intent: ::std::option::Option<RdfSerializationIntent>,
    #[serde(
        rename = "ReasoningEngineeringPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub reasoning_engineering_policy: ::std::option::Option<ReasoningEngineeringPolicy>,
    #[serde(
        rename = "RhetoricalStructureProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub rhetorical_structure_profile: ::std::option::Option<RhetoricalStructureProfile>,
    #[serde(
        rename = "RiskLevelPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub risk_level_policy: ::std::option::Option<RiskLevelPolicy>,
    #[serde(
        rename = "RollbackIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub rollback_intent: ::std::option::Option<RollbackIntent>,
    #[serde(
        rename = "RoutingFrontierPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub routing_frontier_policy: ::std::option::Option<RoutingFrontierPolicy>,
    #[serde(
        rename = "SaeFeatureActivationState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub sae_feature_activation_state: ::std::option::Option<SaeFeatureActivationState>,
    #[serde(
        rename = "SaeLatentPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub sae_latent_policy: ::std::option::Option<SaeLatentPolicy>,
    #[serde(
        rename = "SalienceProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub salience_profile: ::std::option::Option<SalienceProfile>,
    #[serde(
        rename = "ScalePolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub scale_policy: ::std::option::Option<ScalePolicy>,
    #[serde(
        rename = "SchemaDrivenExtractionSLA",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub schema_driven_extraction_sla: ::std::option::Option<SchemaDrivenExtractionSla>,
    #[serde(
        rename = "SE3TransformProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub se3_transform_profile: ::std::option::Option<Se3TransformProfile>,
    #[serde(
        rename = "SecureSubSessionState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub secure_sub_session_state: ::std::option::Option<SecureSubSessionState>,
    #[serde(
        rename = "SelfCorrectionPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub self_correction_policy: ::std::option::Option<SelfCorrectionPolicy>,
    #[serde(
        rename = "SemanticDiscoveryIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub semantic_discovery_intent: ::std::option::Option<SemanticDiscoveryIntent>,
    #[serde(
        rename = "SemanticEdgeState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub semantic_edge_state: ::std::option::Option<SemanticEdgeState>,
    #[serde(
        rename = "SemanticFirewallPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub semantic_firewall_policy: ::std::option::Option<SemanticFirewallPolicy>,
    #[serde(
        rename = "SemanticFlowPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub semantic_flow_policy: ::std::option::Option<SemanticFlowPolicy>,
    #[serde(
        rename = "SemanticIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub semantic_intent: ::std::option::Option<SemanticIntent>,
    #[serde(
        rename = "SemanticMappingHeuristicIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub semantic_mapping_heuristic_intent: ::std::option::Option<SemanticMappingHeuristicIntent>,
    #[serde(
        rename = "SemanticNodeState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub semantic_node_state: ::std::option::Option<SemanticNodeState>,
    #[serde(
        rename = "SemanticRelationalVectorState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub semantic_relational_vector_state: ::std::option::Option<SemanticRelationalVectorState>,
    #[serde(
        rename = "SemanticSlicingPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub semantic_slicing_policy: ::std::option::Option<SemanticSlicingPolicy>,
    #[serde(
        rename = "SemanticVersionState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub semantic_version_state: ::std::option::Option<SemanticVersionState>,
    #[serde(
        rename = "SemanticZoomProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub semantic_zoom_profile: ::std::option::Option<SemanticZoomProfile>,
    #[serde(
        rename = "SHACLValidationSLA",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub shacl_validation_sla: ::std::option::Option<ShaclValidationSla>,
    #[serde(
        rename = "ShapleyAttributionReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub shapley_attribution_receipt: ::std::option::Option<ShapleyAttributionReceipt>,
    #[serde(
        rename = "SideEffectProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub side_effect_profile: ::std::option::Option<SideEffectProfile>,
    #[serde(
        rename = "SimulationConvergenceSLA",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub simulation_convergence_sla: ::std::option::Option<SimulationConvergenceSla>,
    #[serde(
        rename = "SimulationEscrowContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub simulation_escrow_contract: ::std::option::Option<SimulationEscrowContract>,
    #[serde(
        rename = "SMPCTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub smpc_topology_manifest: ::std::option::Option<SmpcTopologyManifest>,
    #[serde(
        rename = "SPARQLQueryIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub sparql_query_intent: ::std::option::Option<SparqlQueryIntent>,
    #[serde(
        rename = "SPARQLQueryResultReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub sparql_query_result_receipt: ::std::option::Option<SparqlQueryResultReceipt>,
    #[serde(
        rename = "SpatialBillboardContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub spatial_billboard_contract: ::std::option::Option<SpatialBillboardContract>,
    #[serde(
        rename = "SpatialHardwareProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub spatial_hardware_profile: ::std::option::Option<SpatialHardwareProfile>,
    #[serde(
        rename = "SpatialKinematicActionIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub spatial_kinematic_action_intent: ::std::option::Option<SpatialKinematicActionIntent>,
    #[serde(
        rename = "SpatialReferenceFrameManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub spatial_reference_frame_manifest: ::std::option::Option<SpatialReferenceFrameManifest>,
    #[serde(
        rename = "SpatialRenderMaterial",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub spatial_render_material: ::std::option::Option<SpatialRenderMaterial>,
    #[serde(
        rename = "SpatialToolManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub spatial_tool_manifest: ::std::option::Option<SpatialToolManifest>,
    #[serde(
        rename = "SpeculativeExecutionPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub speculative_execution_policy: ::std::option::Option<SpeculativeExecutionPolicy>,
    #[serde(
        rename = "SSETransportProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub sse_transport_profile: ::std::option::Option<SseTransportProfile>,
    #[serde(
        rename = "StateContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub state_contract: ::std::option::Option<StateContract>,
    #[serde(
        rename = "StateDifferentialManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub state_differential_manifest: ::std::option::Option<StateDifferentialManifest>,
    #[serde(
        rename = "StateHydrationManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub state_hydration_manifest: ::std::option::Option<StateHydrationManifest>,
    #[serde(
        rename = "StateMutationIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub state_mutation_intent: ::std::option::Option<StateMutationIntent>,
    #[serde(
        rename = "StateVectorProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub state_vector_profile: ::std::option::Option<StateVectorProfile>,
    #[serde(
        rename = "StdioTransportProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub stdio_transport_profile: ::std::option::Option<StdioTransportProfile>,
    #[serde(
        rename = "StochasticNodeState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub stochastic_node_state: ::std::option::Option<StochasticNodeState>,
    #[serde(
        rename = "StochasticTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub stochastic_topology_manifest: ::std::option::Option<StochasticTopologyManifest>,
    #[serde(
        rename = "StrategicThoughtNodeIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub strategic_thought_node_intent: ::std::option::Option<StrategicThoughtNodeIntent>,
    #[serde(
        rename = "StreamingDisfluencyContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub streaming_disfluency_contract: ::std::option::Option<StreamingDisfluencyContract>,
    #[serde(
        rename = "StructuralCausalGraphProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub structural_causal_graph_profile: ::std::option::Option<StructuralCausalGraphProfile>,
    #[serde(
        rename = "SubstrateHydrationManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub substrate_hydration_manifest: ::std::option::Option<SubstrateHydrationManifest>,
    #[serde(
        rename = "SwarmTopologyManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub swarm_topology_manifest: ::std::option::Option<SwarmTopologyManifest>,
    #[serde(
        rename = "SyntheticGenerationProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub synthetic_generation_profile: ::std::option::Option<SyntheticGenerationProfile>,
    #[serde(
        rename = "System1ReflexPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub system1_reflex_policy: ::std::option::Option<System1ReflexPolicy>,
    #[serde(
        rename = "System2RemediationIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub system2_remediation_intent: ::std::option::Option<System2RemediationIntent>,
    #[serde(
        rename = "SystemFaultEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub system_fault_event: ::std::option::Option<SystemFaultEvent>,
    #[serde(
        rename = "TabularCellState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub tabular_cell_state: ::std::option::Option<TabularCellState>,
    #[serde(
        rename = "TabularEncodingProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub tabular_encoding_profile: ::std::option::Option<TabularEncodingProfile>,
    #[serde(
        rename = "TabularMatrixProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub tabular_matrix_profile: ::std::option::Option<TabularMatrixProfile>,
    #[serde(
        rename = "TargetTopologyProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub target_topology_profile: ::std::option::Option<TargetTopologyProfile>,
    #[serde(
        rename = "TaskAnnouncementIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub task_announcement_intent: ::std::option::Option<TaskAnnouncementIntent>,
    #[serde(
        rename = "TaskAwardReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub task_award_receipt: ::std::option::Option<TaskAwardReceipt>,
    #[serde(
        rename = "TaxonomicNodeState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub taxonomic_node_state: ::std::option::Option<TaxonomicNodeState>,
    #[serde(
        rename = "TaxonomicRestructureIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub taxonomic_restructure_intent: ::std::option::Option<TaxonomicRestructureIntent>,
    #[serde(
        rename = "TaxonomicRoutingPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub taxonomic_routing_policy: ::std::option::Option<TaxonomicRoutingPolicy>,
    #[serde(
        rename = "TelemetryBackpressureContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub telemetry_backpressure_contract: ::std::option::Option<TelemetryBackpressureContract>,
    #[serde(
        rename = "TelemetryContextProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub telemetry_context_profile: ::std::option::Option<TelemetryContextProfile>,
    #[serde(
        rename = "TelemetryScalarState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub telemetry_scalar_state: ::std::option::Option<TelemetryScalarState>,
    #[serde(
        rename = "TeleologicalIsometryReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub teleological_isometry_receipt: ::std::option::Option<TeleologicalIsometryReceipt>,
    #[serde(
        rename = "TemporalBoundsProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub temporal_bounds_profile: ::std::option::Option<TemporalBoundsProfile>,
    #[serde(
        rename = "TemporalCheckpointState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub temporal_checkpoint_state: ::std::option::Option<TemporalCheckpointState>,
    #[serde(
        rename = "TemporalConflictResolutionPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub temporal_conflict_resolution_policy:
        ::std::option::Option<TemporalConflictResolutionPolicy>,
    #[serde(
        rename = "TemporalEdgeInvalidationIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub temporal_edge_invalidation_intent: ::std::option::Option<TemporalEdgeInvalidationIntent>,
    #[serde(
        rename = "TemporalGraphCRDTManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub temporal_graph_crdt_manifest: ::std::option::Option<TemporalGraphCrdtManifest>,
    #[serde(
        rename = "TensorStructuralFormatProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub tensor_structural_format_profile: ::std::option::Option<TensorStructuralFormatProfile>,
    #[serde(
        rename = "TerminalBufferState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub terminal_buffer_state: ::std::option::Option<TerminalBufferState>,
    #[serde(
        rename = "TerminalCognitiveEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub terminal_cognitive_event: ::std::option::Option<TerminalCognitiveEvent>,
    #[serde(
        rename = "TerminalConditionContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub terminal_condition_contract: ::std::option::Option<TerminalConditionContract>,
    #[serde(
        rename = "TheoryOfMindSnapshot",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub theory_of_mind_snapshot: ::std::option::Option<TheoryOfMindSnapshot>,
    #[serde(
        rename = "ThoughtBranchState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub thought_branch_state: ::std::option::Option<ThoughtBranchState>,
    #[serde(
        rename = "TieBreakerPolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub tie_breaker_policy: ::std::option::Option<TieBreakerPolicy>,
    #[serde(
        rename = "TokenBurnReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub token_burn_receipt: ::std::option::Option<TokenBurnReceipt>,
    #[serde(
        rename = "ToolInvocationEvent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub tool_invocation_event: ::std::option::Option<ToolInvocationEvent>,
    #[serde(
        rename = "TopologicalFidelityReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub topological_fidelity_receipt: ::std::option::Option<TopologicalFidelityReceipt>,
    #[serde(
        rename = "TopologicalProjectionIntent",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub topological_projection_intent: ::std::option::Option<TopologicalProjectionIntent>,
    #[serde(
        rename = "TopologicalRetrievalContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub topological_retrieval_contract: ::std::option::Option<TopologicalRetrievalContract>,
    #[serde(
        rename = "TopologyHashReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub topology_hash_receipt: ::std::option::Option<TopologyHashReceipt>,
    #[serde(
        rename = "TraceContextState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub trace_context_state: ::std::option::Option<TraceContextState>,
    #[serde(
        rename = "TransformationMechanismProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub transformation_mechanism_profile: ::std::option::Option<TransformationMechanismProfile>,
    #[serde(
        rename = "TransitionEdgeProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub transition_edge_profile: ::std::option::Option<TransitionEdgeProfile>,
    #[serde(
        rename = "TruthMaintenancePolicy",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub truth_maintenance_policy: ::std::option::Option<TruthMaintenancePolicy>,
    #[serde(
        rename = "UpperOntologyClassProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub upper_ontology_class_profile: ::std::option::Option<UpperOntologyClassProfile>,
    #[serde(
        rename = "UtilityJustificationGraphReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub utility_justification_graph_receipt:
        ::std::option::Option<UtilityJustificationGraphReceipt>,
    #[serde(
        rename = "VectorEmbeddingState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub vector_embedding_state: ::std::option::Option<VectorEmbeddingState>,
    #[serde(
        rename = "VerifiableCredentialPresentationReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub verifiable_credential_presentation_receipt:
        ::std::option::Option<VerifiableCredentialPresentationReceipt>,
    #[serde(
        rename = "VerifiableEntropyReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub verifiable_entropy_receipt: ::std::option::Option<VerifiableEntropyReceipt>,
    #[serde(
        rename = "ViewportProjectionContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub viewport_projection_contract: ::std::option::Option<ViewportProjectionContract>,
    #[serde(
        rename = "VisualEncodingProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub visual_encoding_profile: ::std::option::Option<VisualEncodingProfile>,
    #[serde(
        rename = "VolumetricBoundingProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub volumetric_bounding_profile: ::std::option::Option<VolumetricBoundingProfile>,
    #[serde(
        rename = "VolumetricEdgeProfile",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub volumetric_edge_profile: ::std::option::Option<VolumetricEdgeProfile>,
    #[serde(
        rename = "VolumetricPartitionState",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub volumetric_partition_state: ::std::option::Option<VolumetricPartitionState>,
    #[serde(
        rename = "WetwareAttestationContract",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub wetware_attestation_contract: ::std::option::Option<WetwareAttestationContract>,
    #[serde(
        rename = "WorkflowManifest",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub workflow_manifest: ::std::option::Option<WorkflowManifest>,
    #[serde(
        rename = "ZeroKnowledgeReceipt",
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub zero_knowledge_receipt: ::std::option::Option<ZeroKnowledgeReceipt>,
}
impl ::std::default::Default for CoReasonSharedKernelOntology {
    fn default() -> Self {
        Self {
            activation_steering_contract: Default::default(),
            active_inference_contract: Default::default(),
            adjudication_intent: Default::default(),
            adjudication_receipt: Default::default(),
            adjudication_rubric_profile: Default::default(),
            adversarial_market_topology_manifest: Default::default(),
            agent_attestation_receipt: Default::default(),
            agent_bid_intent: Default::default(),
            algebraic_refinement_contract: Default::default(),
            ambient_state: Default::default(),
            analogical_mapping_task: Default::default(),
            anchoring_policy: Default::default(),
            any_action_space_capability: Default::default(),
            any_exploration_branch: Default::default(),
            any_intent: Default::default(),
            any_node_profile: Default::default(),
            any_panel_profile: Default::default(),
            any_presentation_intent: Default::default(),
            any_state_event: Default::default(),
            any_toolchain_state: Default::default(),
            any_topology_manifest: Default::default(),
            any_transition_edge: Default::default(),
            artifact_corruption_event: Default::default(),
            ast_gradient_receipt: Default::default(),
            asymptotic_complexity_receipt: Default::default(),
            atomic_proposition_state: Default::default(),
            attack_vector_profile: Default::default(),
            auction_mechanism_profile: Default::default(),
            auction_policy: Default::default(),
            auction_state: Default::default(),
            backpressure_policy: Default::default(),
            barge_in_interrupt_event: Default::default(),
            belief_modulation_receipt: Default::default(),
            belief_mutation_event: Default::default(),
            bounded_intervention_scope_policy: Default::default(),
            bounded_jsonrpc_intent: Default::default(),
            browser_dom_state: Default::default(),
            budget_exhaustion_event: Default::default(),
            bundle_content_hash_state: Default::default(),
            bypass_receipt: Default::default(),
            capability_forge_topology_manifest: Default::default(),
            capability_pointer_state: Default::default(),
            causal_attribution_state: Default::default(),
            causal_directed_edge_state: Default::default(),
            causal_explanation_event: Default::default(),
            causal_interval_profile: Default::default(),
            causal_propagation_intent: Default::default(),
            circuit_breaker_event: Default::default(),
            cognitive_action_space_manifest: Default::default(),
            cognitive_agent_node_profile: Default::default(),
            cognitive_critique_profile: Default::default(),
            cognitive_detailed_balance_contract: Default::default(),
            cognitive_dual_verification_receipt: Default::default(),
            cognitive_human_node_profile: Default::default(),
            cognitive_prediction_receipt: Default::default(),
            cognitive_reasoning_trace_state: Default::default(),
            cognitive_routing_contract: Default::default(),
            cognitive_sampling_policy: Default::default(),
            cognitive_state_profile: Default::default(),
            cognitive_swarm_deployment_manifest: Default::default(),
            cognitive_system_node_profile: Default::default(),
            cognitive_tier_profile: Default::default(),
            cognitive_uncertainty_profile: Default::default(),
            collective_intelligence_profile: Default::default(),
            composite_node_profile: Default::default(),
            compute_engine_profile: Default::default(),
            compute_provisioning_intent: Default::default(),
            compute_rate_contract: Default::default(),
            consensus_federation_topology_manifest: Default::default(),
            consensus_policy: Default::default(),
            constitutional_amendment_intent: Default::default(),
            constrained_decoding_policy: Default::default(),
            context_expansion_policy: Default::default(),
            contextual_semantic_resolution_intent: Default::default(),
            contextualized_source_state: Default::default(),
            continuous_manifold_mapping_contract: Default::default(),
            continuous_mutation_policy: Default::default(),
            continuous_observation_state: Default::default(),
            continuous_spatial_mutation_intent: Default::default(),
            council_topology_manifest: Default::default(),
            counterfactual_regret_event: Default::default(),
            crossover_mechanism_profile: Default::default(),
            crossover_policy: Default::default(),
            crosswalk_resolution_receipt: Default::default(),
            cryptographic_provenance_policy: Default::default(),
            crystallization_policy: Default::default(),
            custody_receipt: Default::default(),
            cyclic_edge_profile: Default::default(),
            dag_topology_manifest: Default::default(),
            defeasible_attack_event: Default::default(),
            defeasible_cascade_event: Default::default(),
            delegated_capability_manifest: Default::default(),
            deliberative_envelope: Default::default(),
            dempster_shafer_belief_vector: Default::default(),
            derivation_mode_profile: Default::default(),
            differentiable_logic_policy: Default::default(),
            digital_twin_topology_manifest: Default::default(),
            discourse_node_state: Default::default(),
            discourse_tree_manifest: Default::default(),
            distribution_profile: Default::default(),
            distribution_shape_profile: Default::default(),
            diversity_policy: Default::default(),
            document_knowledge_graph_manifest: Default::default(),
            document_layout_manifest: Default::default(),
            document_layout_region_state: Default::default(),
            drafting_intent: Default::default(),
            dynamic_convergence_sla: Default::default(),
            dynamic_layout_manifest: Default::default(),
            dynamic_manifold_projection_manifest: Default::default(),
            dynamic_routing_manifest: Default::default(),
            edge_mapping_contract: Default::default(),
            embodied_sensory_vector_profile: Default::default(),
            empirical_falsification_contract: Default::default(),
            empirical_statistical_profile: Default::default(),
            ensemble_topology_profile: Default::default(),
            ephemeral_namespace_partition_state: Default::default(),
            epistemic_argument_claim_state: Default::default(),
            epistemic_argument_graph_state: Default::default(),
            epistemic_attention_state: Default::default(),
            epistemic_axiom_state: Default::default(),
            epistemic_axiom_verification_receipt: Default::default(),
            epistemic_chain_graph_state: Default::default(),
            epistemic_compression_sla: Default::default(),
            epistemic_constraint_policy: Default::default(),
            epistemic_curriculum_manifest: Default::default(),
            epistemic_domain_graph_manifest: Default::default(),
            epistemic_escalation_contract: Default::default(),
            epistemic_flow_state_receipt: Default::default(),
            epistemic_grounded_task_manifest: Default::default(),
            epistemic_guardrails_manifest: Default::default(),
            epistemic_hydration_policy: Default::default(),
            epistemic_ledger_state: Default::default(),
            epistemic_log_event: Default::default(),
            epistemic_promotion_event: Default::default(),
            epistemic_provenance_receipt: Default::default(),
            epistemic_proxy_state: Default::default(),
            epistemic_proxy_state_any: Default::default(),
            epistemic_quarantine_snapshot: Default::default(),
            epistemic_rejection_receipt: Default::default(),
            epistemic_rigidity_policy: Default::default(),
            epistemic_scanning_policy: Default::default(),
            epistemic_security_policy: Default::default(),
            epistemic_security_profile: Default::default(),
            epistemic_seed_injection_policy: Default::default(),
            epistemic_sop_manifest: Default::default(),
            epistemic_starvation_event: Default::default(),
            epistemic_telemetry_event: Default::default(),
            epistemic_topological_proof_manifest: Default::default(),
            epistemic_transmutation_task: Default::default(),
            epistemic_upsampling_task: Default::default(),
            epistemic_zero_trust_contract: Default::default(),
            epistemic_zero_trust_receipt: Default::default(),
            escalation_contract: Default::default(),
            escalation_intent: Default::default(),
            escrow_policy: Default::default(),
            evaluator_optimizer_topology_manifest: Default::default(),
            eviction_policy: Default::default(),
            evidentiary_citation_state: Default::default(),
            evidentiary_grounding_sla: Default::default(),
            evidentiary_warrant_state: Default::default(),
            evolutionary_topology_manifest: Default::default(),
            execution_envelope_state: Default::default(),
            execution_sla: Default::default(),
            execution_substrate_profile: Default::default(),
            exogenous_epistemic_event: Default::default(),
            facet_matrix_profile: Default::default(),
            fallback_intent: Default::default(),
            fallback_sla: Default::default(),
            falsification_contract: Default::default(),
            fitness_objective_profile: Default::default(),
            formal_logic_premise: Default::default(),
            formal_verification_contract: Default::default(),
            formal_verification_receipt: Default::default(),
            fyi_intent: Default::default(),
            generative_manifold_sla: Default::default(),
            generative_taxonomy_manifest: Default::default(),
            global_governance_policy: Default::default(),
            global_semantic_invariant_profile: Default::default(),
            global_semantic_profile: Default::default(),
            grading_criterion_profile: Default::default(),
            grammar_panel_profile: Default::default(),
            graph_flattening_policy: Default::default(),
            guardrail_violation_event: Default::default(),
            hardware_enclave_receipt: Default::default(),
            hierarchical_dom_manifest: Default::default(),
            hoare_logic_proof_receipt: Default::default(),
            homomorphic_encryption_profile: Default::default(),
            http_transport_profile: Default::default(),
            human_directive_intent: Default::default(),
            hypothesis_generation_event: Default::default(),
            hypothesis_stake_receipt: Default::default(),
            hypothesis_superposition_state: Default::default(),
            ideation_phase_profile: Default::default(),
            illocutionary_force_profile: Default::default(),
            input_mapping_contract: Default::default(),
            insight_card_profile: Default::default(),
            intent_classification_receipt: Default::default(),
            intent_elicitation_topology_manifest: Default::default(),
            intervention_intent: Default::default(),
            intervention_policy: Default::default(),
            intervention_receipt: Default::default(),
            interventional_causal_task: Default::default(),
            json_primitive_state: Default::default(),
            jsonrpc_error_response_state: Default::default(),
            jsonrpc_error_state: Default::default(),
            kinematic_delta_manifest: Default::default(),
            kinematic_derivative_profile: Default::default(),
            kinetic_budget_policy: Default::default(),
            kinetic_separation_policy: Default::default(),
            latent_projection_intent: Default::default(),
            latent_schema_inference_intent: Default::default(),
            latent_scratchpad_receipt: Default::default(),
            latent_smoothing_profile: Default::default(),
            lifecycle_trigger_event: Default::default(),
            lineage_watermark_receipt: Default::default(),
            link_ml_validation_sla: Default::default(),
            logit_steganography_contract: Default::default(),
            macro_grid_profile: Default::default(),
            manifest_violation_receipt: Default::default(),
            manifold_alignment_metric_profile: Default::default(),
            market_contract: Default::default(),
            market_resolution_state: Default::default(),
            markov_blanket_rendering_policy: Default::default(),
            mcp_capability_whitelist_policy: Default::default(),
            mcp_client_intent: Default::default(),
            mcp_prompt_reference_state: Default::default(),
            mcp_resource_manifest: Default::default(),
            mcp_server_manifest: Default::default(),
            mcp_tool_definition: Default::default(),
            mechanistic_audit_contract: Default::default(),
            memoized_node_profile: Default::default(),
            multimodal_artifact_receipt: Default::default(),
            multimodal_token_anchor_state: Default::default(),
            mutation_policy: Default::default(),
            n_dimensional_tensor_manifest: Default::default(),
            neural_audit_attestation_receipt: Default::default(),
            neuro_symbolic_handoff_contract: Default::default(),
            neurosymbolic_inference_intent: Default::default(),
            neurosymbolic_ingestion_topology_manifest: Default::default(),
            neurosymbolic_verification_topology_manifest: Default::default(),
            node_cid_state: Default::default(),
            observability_lod_policy: Default::default(),
            observation_event: Default::default(),
            ontological_alignment_policy: Default::default(),
            ontological_crosswalk_intent: Default::default(),
            ontological_normalization_intent: Default::default(),
            ontological_reification_receipt: Default::default(),
            ontological_surface_projection_manifest: Default::default(),
            ontology_discovery_intent: Default::default(),
            optical_mapping_contract: Default::default(),
            optical_parsing_sla: Default::default(),
            optimization_direction_profile: Default::default(),
            oracle_execution_receipt: Default::default(),
            output_mapping_contract: Default::default(),
            override_intent: Default::default(),
            patch_operation_profile: Default::default(),
            peft_adapter_contract: Default::default(),
            permission_boundary_policy: Default::default(),
            persistence_commit_receipt: Default::default(),
            post_coordinated_semantic_state: Default::default(),
            post_quantum_signature_receipt: Default::default(),
            prediction_market_policy: Default::default(),
            prediction_market_state: Default::default(),
            presentation_manifest: Default::default(),
            procedural_metadata_manifest: Default::default(),
            process_reward_contract: Default::default(),
            profile_cid_state: Default::default(),
            qo_s_classification_profile: Default::default(),
            quarantine_intent: Default::default(),
            quorum_policy: Default::default(),
            rdf_export_receipt: Default::default(),
            rdf_serialization_intent: Default::default(),
            reasoning_engineering_policy: Default::default(),
            rhetorical_structure_profile: Default::default(),
            risk_level_policy: Default::default(),
            rollback_intent: Default::default(),
            routing_frontier_policy: Default::default(),
            sae_feature_activation_state: Default::default(),
            sae_latent_policy: Default::default(),
            salience_profile: Default::default(),
            scale_policy: Default::default(),
            schema_driven_extraction_sla: Default::default(),
            se3_transform_profile: Default::default(),
            secure_sub_session_state: Default::default(),
            self_correction_policy: Default::default(),
            semantic_discovery_intent: Default::default(),
            semantic_edge_state: Default::default(),
            semantic_firewall_policy: Default::default(),
            semantic_flow_policy: Default::default(),
            semantic_intent: Default::default(),
            semantic_mapping_heuristic_intent: Default::default(),
            semantic_node_state: Default::default(),
            semantic_relational_vector_state: Default::default(),
            semantic_slicing_policy: Default::default(),
            semantic_version_state: Default::default(),
            semantic_zoom_profile: Default::default(),
            shacl_validation_sla: Default::default(),
            shapley_attribution_receipt: Default::default(),
            side_effect_profile: Default::default(),
            simulation_convergence_sla: Default::default(),
            simulation_escrow_contract: Default::default(),
            smpc_topology_manifest: Default::default(),
            sparql_query_intent: Default::default(),
            sparql_query_result_receipt: Default::default(),
            spatial_billboard_contract: Default::default(),
            spatial_hardware_profile: Default::default(),
            spatial_kinematic_action_intent: Default::default(),
            spatial_reference_frame_manifest: Default::default(),
            spatial_render_material: Default::default(),
            spatial_tool_manifest: Default::default(),
            speculative_execution_policy: Default::default(),
            sse_transport_profile: Default::default(),
            state_contract: Default::default(),
            state_differential_manifest: Default::default(),
            state_hydration_manifest: Default::default(),
            state_mutation_intent: Default::default(),
            state_vector_profile: Default::default(),
            stdio_transport_profile: Default::default(),
            stochastic_node_state: Default::default(),
            stochastic_topology_manifest: Default::default(),
            strategic_thought_node_intent: Default::default(),
            streaming_disfluency_contract: Default::default(),
            structural_causal_graph_profile: Default::default(),
            substrate_hydration_manifest: Default::default(),
            swarm_topology_manifest: Default::default(),
            synthetic_generation_profile: Default::default(),
            system1_reflex_policy: Default::default(),
            system2_remediation_intent: Default::default(),
            system_fault_event: Default::default(),
            tabular_cell_state: Default::default(),
            tabular_encoding_profile: Default::default(),
            tabular_matrix_profile: Default::default(),
            target_topology_profile: Default::default(),
            task_announcement_intent: Default::default(),
            task_award_receipt: Default::default(),
            taxonomic_node_state: Default::default(),
            taxonomic_restructure_intent: Default::default(),
            taxonomic_routing_policy: Default::default(),
            telemetry_backpressure_contract: Default::default(),
            telemetry_context_profile: Default::default(),
            telemetry_scalar_state: Default::default(),
            teleological_isometry_receipt: Default::default(),
            temporal_bounds_profile: Default::default(),
            temporal_checkpoint_state: Default::default(),
            temporal_conflict_resolution_policy: Default::default(),
            temporal_edge_invalidation_intent: Default::default(),
            temporal_graph_crdt_manifest: Default::default(),
            tensor_structural_format_profile: Default::default(),
            terminal_buffer_state: Default::default(),
            terminal_cognitive_event: Default::default(),
            terminal_condition_contract: Default::default(),
            theory_of_mind_snapshot: Default::default(),
            thought_branch_state: Default::default(),
            tie_breaker_policy: Default::default(),
            token_burn_receipt: Default::default(),
            tool_invocation_event: Default::default(),
            topological_fidelity_receipt: Default::default(),
            topological_projection_intent: Default::default(),
            topological_retrieval_contract: Default::default(),
            topology_hash_receipt: Default::default(),
            trace_context_state: Default::default(),
            transformation_mechanism_profile: Default::default(),
            transition_edge_profile: Default::default(),
            truth_maintenance_policy: Default::default(),
            upper_ontology_class_profile: Default::default(),
            utility_justification_graph_receipt: Default::default(),
            vector_embedding_state: Default::default(),
            verifiable_credential_presentation_receipt: Default::default(),
            verifiable_entropy_receipt: Default::default(),
            viewport_projection_contract: Default::default(),
            visual_encoding_profile: Default::default(),
            volumetric_bounding_profile: Default::default(),
            volumetric_edge_profile: Default::default(),
            volumetric_partition_state: Default::default(),
            wetware_attestation_contract: Default::default(),
            workflow_manifest: Default::default(),
            zero_knowledge_receipt: Default::default(),
        }
    }
}
impl CoReasonSharedKernelOntology {
    pub fn builder() -> builder::CoReasonSharedKernelOntology {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the finite, discrete Markov Decision Process (MDP) Action Space and affordance landscape available to a specific execution node. As a ...Manifest suffix, this defines a frozen, N-dimensional coordinate state.\n\nCAUSAL AFFORDANCE: Projects the combined multi-dimensional matrix of capabilities into the agent's context, mathematically dictating which kinetic operations it can initiate via its `transition_matrix`. Optionally enforces kinetic separation.\n\nEPISTEMIC BOUNDS: The `action_space_cid` is geometrically constrained to a 128-char CID. A `@model_validator` strictly bounds the topology by enforcing uniqueness across all capability namespaces and ensures deterministic RFC 8785 representation by sorting the transition matrix.\n\nMCP ROUTING TRIGGERS: Markov Decision Process, Action Space, Affordance Theory, State Transition Matrix, Directed Cyclic Graph"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitiveActionSpaceManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the finite, discrete Markov Decision Process (MDP) Action Space and affordance landscape available to a specific execution node. As a ...Manifest suffix, this defines a frozen, N-dimensional coordinate state.\\n\\nCAUSAL AFFORDANCE: Projects the combined multi-dimensional matrix of capabilities into the agent's context, mathematically dictating which kinetic operations it can initiate via its `transition_matrix`. Optionally enforces kinetic separation.\\n\\nEPISTEMIC BOUNDS: The `action_space_cid` is geometrically constrained to a 128-char CID. A `@model_validator` strictly bounds the topology by enforcing uniqueness across all capability namespaces and ensures deterministic RFC 8785 representation by sorting the transition matrix.\\n\\nMCP ROUTING TRIGGERS: Markov Decision Process, Action Space, Affordance Theory, State Transition Matrix, Directed Cyclic Graph\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"action_space_cid\","]
#[doc = "    \"capabilities\","]
#[doc = "    \"entry_point_cid\","]
#[doc = "    \"transition_matrix\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"action_space_cid\": {"]
#[doc = "      \"title\": \"Action Space Cid\","]
#[doc = "      \"description\": \"The unique identifier for this curated environment of tools.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"capabilities\": {"]
#[doc = "      \"title\": \"Capabilities\","]
#[doc = "      \"description\": \"The State Space (S) of the MDP, indexed by their unique capability CIDs.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 500,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyActionSpaceCapability\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"capability_cid\": {"]
#[doc = "      \"description\": \"The content-addressed SHA-256 hash of the capability.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/BundleContentHashState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"entry_point_cid\": {"]
#[doc = "      \"title\": \"Entry Point Cid\","]
#[doc = "      \"description\": \"Defines the initial state (S_0) of the MDP.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"execution_fee_lmsr\": {"]
#[doc = "      \"title\": \"Execution Fee Lmsr\","]
#[doc = "      \"description\": \"The logarithmic market scoring rule threshold for thermodynamic execution.\","]
#[doc = "      \"type\": \"number\""]
#[doc = "    },"]
#[doc = "    \"kinetic_separation\": {"]
#[doc = "      \"description\": \"The bipartite graph constraint preventing toxic tool combinations.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/KineticSeparationPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"metadata_cid\": {"]
#[doc = "      \"description\": \"The content-addressed SHA-256 hash of the FAIR metadata.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/BundleContentHashState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"transition_matrix\": {"]
#[doc = "      \"title\": \"Transition Matrix\","]
#[doc = "      \"description\": \"The Stochastic Transition Matrix (P).\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 500,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"array\","]
#[doc = "        \"items\": {"]
#[doc = "          \"$ref\": \"#/$defs/AnyTransitionEdge\""]
#[doc = "        }"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"trusted_validators\": {"]
#[doc = "      \"title\": \"Trusted Validators\","]
#[doc = "      \"description\": \"A deterministic array of DIDs authorized to validate this manifest.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitiveActionSpaceManifest {
    #[doc = "The unique identifier for this curated environment of tools."]
    pub action_space_cid: ActionSpaceCid,
    #[doc = "The State Space (S) of the MDP, indexed by their unique capability CIDs."]
    pub capabilities: ::std::collections::HashMap<::std::string::String, AnyActionSpaceCapability>,
    #[doc = "The content-addressed SHA-256 hash of the capability."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub capability_cid: ::std::option::Option<BundleContentHashState>,
    #[doc = "Defines the initial state (S_0) of the MDP."]
    pub entry_point_cid: EntryPointCid,
    #[doc = "The logarithmic market scoring rule threshold for thermodynamic execution."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub execution_fee_lmsr: ::std::option::Option<f64>,
    #[doc = "The bipartite graph constraint preventing toxic tool combinations."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub kinetic_separation: ::std::option::Option<KineticSeparationPolicy>,
    #[doc = "The content-addressed SHA-256 hash of the FAIR metadata."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub metadata_cid: ::std::option::Option<BundleContentHashState>,
    #[doc = "The Stochastic Transition Matrix (P)."]
    pub transition_matrix:
        ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<AnyTransitionEdge>>,
    #[doc = "A deterministic array of DIDs authorized to validate this manifest."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub trusted_validators: ::std::vec::Vec<NodeCidState>,
}
impl CognitiveActionSpaceManifest {
    pub fn builder() -> builder::CognitiveActionSpaceManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements a stochastic actor traversing a Partially Observable Markov Decision Process (POMDP). It establishes the cognitive and physical constraints for autonomous swarm participants.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator to instantiate an independent generative trajectory capable of active inference, Representation Engineering (RepE) steering via `baseline_cognitive_state`, and non-monotonic test-time compute escalation via `escalation_policy`.\n\nEPISTEMIC BOUNDS: The node's operational variance is physically bounded by its thermodynamic Spot-Market budget (`compute_frontier`). The `@model_validator` deterministically sorts `peft_adapters` by `adapter_cid` for RFC 8785 canonical hashing. Type is strictly locked to `Literal[\"agent\"]`.\n\nMCP ROUTING TRIGGERS: POMDP, Stochastic Actor, Active Inference, Representation Engineering, Policy Gradient"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitiveAgentNodeProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements a stochastic actor traversing a Partially Observable Markov Decision Process (POMDP). It establishes the cognitive and physical constraints for autonomous swarm participants.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator to instantiate an independent generative trajectory capable of active inference, Representation Engineering (RepE) steering via `baseline_cognitive_state`, and non-monotonic test-time compute escalation via `escalation_policy`.\\n\\nEPISTEMIC BOUNDS: The node's operational variance is physically bounded by its thermodynamic Spot-Market budget (`compute_frontier`). The `@model_validator` deterministically sorts `peft_adapters` by `adapter_cid` for RFC 8785 canonical hashing. Type is strictly locked to `Literal[\\\"agent\\\"]`.\\n\\nMCP ROUTING TRIGGERS: POMDP, Stochastic Actor, Active Inference, Representation Engineering, Policy Gradient\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"description\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"action_space_cid\": {"]
#[doc = "      \"title\": \"Action Space Cid\","]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring the specific CognitiveActionSpaceManifest (curated tool environment) bound to this agent.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"active_attention_ray\": {"]
#[doc = "      \"description\": \"The continuous spatial vector representing the agent's localized cognitive focus prior to kinetic actuation.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EpistemicAttentionState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"active_inference_policy\": {"]
#[doc = "      \"description\": \"The formal contract demanding mathematical proof of Expected Information Gain before authorizing tool execution.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ActiveInferenceContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"agent_attestation\": {"]
#[doc = "      \"description\": \"The cryptographic identity passport and AI-BOM for the agent.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/AgentAttestationReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"analogical_policy\": {"]
#[doc = "      \"description\": \"The formal contract forcing the agent to execute cross-domain lateral thinking.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/AnalogicalMappingTask\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"anchoring_policy\": {"]
#[doc = "      \"description\": \"The declarative contract mathematically binding this agent to a core altruistic objective.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/AnchoringPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"audit_policy\": {"]
#[doc = "      \"description\": \"The adaptive trigger policy for executing deep mechanistic interpretability brain-scans on this agent.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/MechanisticAuditContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"baseline_cognitive_state\": {"]
#[doc = "      \"description\": \"The default biochemical 'mood' simulated for this agent via Representation Engineering.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/CognitiveStateProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"compute_frontier\": {"]
#[doc = "      \"description\": \"The dynamic spot-market compute requirements for this agent.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/RoutingFrontierPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"correction_policy\": {"]
#[doc = "      \"description\": \"The policy governing self-correction loops.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SelfCorrectionPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"description\": {"]
#[doc = "      \"title\": \"Description\","]
#[doc = "      \"description\": \"The semantic boundary defining the objective function of the execution node. [SITD-Gamma: Neurosymbolic Substrate Alignment]\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"domain_extensions\": {"]
#[doc = "      \"title\": \"Domain Extensions\","]
#[doc = "      \"description\": \"Passive, untyped extension point for vertical domain context. Strictly bounded to prevent JSON-bomb memory leaks. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"object\","]
#[doc = "          \"additionalProperties\": {"]
#[doc = "            \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"emitted_intents\": {"]
#[doc = "      \"title\": \"Emitted Intents\","]
#[doc = "      \"description\": \"The array of cognitive intents and structural proposals emitted by this agent.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyIntent\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"epistemic_policy\": {"]
#[doc = "      \"description\": \"The policy governing epistemic scanning.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EpistemicScanningPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"epistemic_rigidity\": {"]
#[doc = "      \"description\": \"The mathematical bounds defining acceptable probabilistic drift, hardware requirements, and remote decoding protocols for this agent's execution routing.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EpistemicRigidityPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"escalation_policy\": {"]
#[doc = "      \"description\": \"The mathematical boundary authorizing the agent to spin up Test-Time Compute.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EscalationContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"gflownet_balance_policy\": {"]
#[doc = "      \"description\": \"Authorizes trajectory balance optimization during non-monotonic reasoning.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/CognitiveDetailedBalanceContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"hardware\": {"]
#[doc = "      \"description\": \"The physical constraints binding this agent to a specific thermodynamic deployment topology.\","]
#[doc = "      \"$ref\": \"#/$defs/SpatialHardwareProfile\""]
#[doc = "    },"]
#[doc = "    \"intervention_policies\": {"]
#[doc = "      \"title\": \"Intervention Policies\","]
#[doc = "      \"description\": \"The declarative array of proactive oversight hooks bound to this node's lifecycle.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/InterventionPolicy\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"interventional_policy\": {"]
#[doc = "      \"description\": \"The formal contract authorizing the agent to mutate variables to prove Pearlian causation.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/InterventionalCausalTask\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this node's existence in the graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"logit_steganography\": {"]
#[doc = "      \"description\": \"The cryptographic contract forcing this agent to embed an undeniable provenance signature into its generative token stream.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/LogitSteganographyContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"markov_blanket\": {"]
#[doc = "      \"description\": \"The epistemic isolation boundary guarding this agent's internal generative states.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/MarkovBlanketRenderingPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"peft_adapters\": {"]
#[doc = "      \"title\": \"Peft Adapters\","]
#[doc = "      \"description\": \"The declarative array of ephemeral PEFT/LoRA weights required to be hot-swapped during this agent's execution.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/PeftAdapterContract\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"reflex_policy\": {"]
#[doc = "      \"description\": \"The policy governing System 1 reflex actions.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/System1ReflexPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"render_material\": {"]
#[doc = "      \"description\": \"The physics-agnostic visual identity or shader governing the spatial rendering of this node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SpatialRenderMaterial\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"secure_sub_session\": {"]
#[doc = "      \"description\": \"Declarative boundary for handling unredacted secrets within a temporarily isolated state partition.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SecureSubSessionState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"security\": {"]
#[doc = "      \"description\": \"The rigid cryptographic rules dictating the agent's isolation boundaries.\","]
#[doc = "      \"$ref\": \"#/$defs/EpistemicSecurityProfile\""]
#[doc = "    },"]
#[doc = "    \"semantic_zoom\": {"]
#[doc = "      \"description\": \"The mathematical Information Bottleneck thresholds dictating the semantic degradation of this specific node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticZoomProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"symbolic_handoff_policy\": {"]
#[doc = "      \"description\": \"The API-like contract allowing the agent to offload rigid logic to deterministic CPU solvers.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NeuroSymbolicHandoffContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for an Agent node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"agent\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitiveAgentNodeProfile {
    #[doc = "The globally unique decentralized identifier (DID) anchoring the specific CognitiveActionSpaceManifest (curated tool environment) bound to this agent."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub action_space_cid: ::std::option::Option<::std::string::String>,
    #[doc = "The continuous spatial vector representing the agent's localized cognitive focus prior to kinetic actuation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub active_attention_ray: ::std::option::Option<EpistemicAttentionState>,
    #[doc = "The formal contract demanding mathematical proof of Expected Information Gain before authorizing tool execution."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub active_inference_policy: ::std::option::Option<ActiveInferenceContract>,
    #[doc = "The cryptographic identity passport and AI-BOM for the agent."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub agent_attestation: ::std::option::Option<AgentAttestationReceipt>,
    #[doc = "The formal contract forcing the agent to execute cross-domain lateral thinking."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub analogical_policy: ::std::option::Option<AnalogicalMappingTask>,
    #[doc = "The declarative contract mathematically binding this agent to a core altruistic objective."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub anchoring_policy: ::std::option::Option<AnchoringPolicy>,
    #[doc = "The AI's declarative rationale for selecting this node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "The adaptive trigger policy for executing deep mechanistic interpretability brain-scans on this agent."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub audit_policy: ::std::option::Option<MechanisticAuditContract>,
    #[doc = "The default biochemical 'mood' simulated for this agent via Representation Engineering."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub baseline_cognitive_state: ::std::option::Option<CognitiveStateProfile>,
    #[doc = "The dynamic spot-market compute requirements for this agent."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub compute_frontier: ::std::option::Option<RoutingFrontierPolicy>,
    #[doc = "The policy governing self-correction loops."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub correction_policy: ::std::option::Option<SelfCorrectionPolicy>,
    #[doc = "The semantic boundary defining the objective function of the execution node. [SITD-Gamma: Neurosymbolic Substrate Alignment]"]
    pub description: Description,
    #[doc = "Passive, untyped extension point for vertical domain context. Strictly bounded to prevent JSON-bomb memory leaks. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub domain_extensions: ::std::option::Option<
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    >,
    #[doc = "The array of cognitive intents and structural proposals emitted by this agent."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub emitted_intents: ::std::vec::Vec<AnyIntent>,
    #[doc = "The policy governing epistemic scanning."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_policy: ::std::option::Option<EpistemicScanningPolicy>,
    #[doc = "The mathematical bounds defining acceptable probabilistic drift, hardware requirements, and remote decoding protocols for this agent's execution routing."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_rigidity: ::std::option::Option<EpistemicRigidityPolicy>,
    #[doc = "The mathematical boundary authorizing the agent to spin up Test-Time Compute."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub escalation_policy: ::std::option::Option<EscalationContract>,
    #[doc = "Authorizes trajectory balance optimization during non-monotonic reasoning."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub gflownet_balance_policy: ::std::option::Option<CognitiveDetailedBalanceContract>,
    #[doc = "The physical constraints binding this agent to a specific thermodynamic deployment topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub hardware: ::std::option::Option<SpatialHardwareProfile>,
    #[doc = "The declarative array of proactive oversight hooks bound to this node's lifecycle."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub intervention_policies: ::std::vec::Vec<InterventionPolicy>,
    #[doc = "The formal contract authorizing the agent to mutate variables to prove Pearlian causation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub interventional_policy: ::std::option::Option<InterventionalCausalTask>,
    #[doc = "Cryptographic/audit justification for this node's existence in the graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The cryptographic contract forcing this agent to embed an undeniable provenance signature into its generative token stream."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub logit_steganography: ::std::option::Option<LogitSteganographyContract>,
    #[doc = "The epistemic isolation boundary guarding this agent's internal generative states."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub markov_blanket: ::std::option::Option<MarkovBlanketRenderingPolicy>,
    #[doc = "The declarative array of ephemeral PEFT/LoRA weights required to be hot-swapped during this agent's execution."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub peft_adapters: ::std::vec::Vec<PeftAdapterContract>,
    #[doc = "The policy governing System 1 reflex actions."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub reflex_policy: ::std::option::Option<System1ReflexPolicy>,
    #[doc = "The physics-agnostic visual identity or shader governing the spatial rendering of this node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub render_material: ::std::option::Option<SpatialRenderMaterial>,
    #[doc = "Declarative boundary for handling unredacted secrets within a temporarily isolated state partition."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub secure_sub_session: ::std::option::Option<SecureSubSessionState>,
    #[doc = "The rigid cryptographic rules dictating the agent's isolation boundaries."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub security: ::std::option::Option<EpistemicSecurityProfile>,
    #[doc = "The mathematical Information Bottleneck thresholds dictating the semantic degradation of this specific node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_zoom: ::std::option::Option<SemanticZoomProfile>,
    #[doc = "The API-like contract allowing the agent to offload rigid logic to deterministic CPU solvers."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub symbolic_handoff_policy: ::std::option::Option<NeuroSymbolicHandoffContract>,
    #[doc = "Discriminator for an Agent node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl CognitiveAgentNodeProfile {
    pub fn builder() -> builder::CognitiveAgentNodeProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Step-Level Verification via Process Reward Models (PRMs) to evaluate and critique intermediate steps in non-monotonic reasoning trees.\n\nCAUSAL AFFORDANCE: Injects a dense latent supervision vector (`logical_flaw_embedding`) to mathematically repel the generative trajectory away from hallucinated or logically flawed probability manifolds during test-time compute.\n\nEPISTEMIC BOUNDS: Penalization magnitude strictly clamped by `epistemic_penalty_scalar` (`ge=0.0, le=1.0`) to prevent gradient explosion. Target is cryptographically locked via `reasoning_trace_hash` (SHA-256 pattern `^[a-f0-9]{64}$`).\n\nMCP ROUTING TRIGGERS: Process Reward Model, Step-Level Verification, Representation Engineering, Latent Repulsion, Test-Time Supervision"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitiveCritiqueProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Step-Level Verification via Process Reward Models (PRMs) to evaluate and critique intermediate steps in non-monotonic reasoning trees.\\n\\nCAUSAL AFFORDANCE: Injects a dense latent supervision vector (`logical_flaw_embedding`) to mathematically repel the generative trajectory away from hallucinated or logically flawed probability manifolds during test-time compute.\\n\\nEPISTEMIC BOUNDS: Penalization magnitude strictly clamped by `epistemic_penalty_scalar` (`ge=0.0, le=1.0`) to prevent gradient explosion. Target is cryptographically locked via `reasoning_trace_hash` (SHA-256 pattern `^[a-f0-9]{64}$`).\\n\\nMCP ROUTING TRIGGERS: Process Reward Model, Step-Level Verification, Representation Engineering, Latent Repulsion, Test-Time Supervision\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"epistemic_penalty_scalar\","]
#[doc = "    \"reasoning_trace_hash\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"epistemic_penalty_scalar\": {"]
#[doc = "      \"title\": \"Epistemic Penalty Scalar\","]
#[doc = "      \"description\": \"A continuous penalty applied to the branch's probability mass if normative drift or hallucination is detected.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"logical_flaw_embedding\": {"]
#[doc = "      \"description\": \"A dense latent space representation of the specific logical fallacy identified, used to mathematically repel future generation trajectories.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/VectorEmbeddingState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"reasoning_trace_hash\": {"]
#[doc = "      \"title\": \"Reasoning Trace Hash\","]
#[doc = "      \"description\": \"The cryptographic Merkle root of the specific ThoughtBranch being evaluated.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitiveCritiqueProfile {
    #[doc = "A continuous penalty applied to the branch's probability mass if normative drift or hallucination is detected."]
    pub epistemic_penalty_scalar: f64,
    #[doc = "A dense latent space representation of the specific logical fallacy identified, used to mathematically repel future generation trajectories."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub logical_flaw_embedding: ::std::option::Option<VectorEmbeddingState>,
    #[doc = "The cryptographic Merkle root of the specific ThoughtBranch being evaluated."]
    pub reasoning_trace_hash: ReasoningTraceHash,
}
impl CognitiveCritiqueProfile {
    pub fn builder() -> builder::CognitiveCritiqueProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Generative Flow Network (GFlowNet) trajectory balance conditions to ensure that the probability of generating a non-monotonic reasoning path is strictly proportional to its terminal reward.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator's sampling mechanism to continuously optimize for the detailed balance equations using the specified `flow_estimation_matrix`, ensuring proportional flow allocation across MDP branches.\n\nEPISTEMIC BOUNDS: Mathematical variance is strictly bounded by `target_balance_epsilon` (`ge=0.0, le=1.0`), preventing probability flow divergence. `local_exploration_k` (`gt=0, le=1`) physically caps exploratory branching.\n\nMCP ROUTING TRIGGERS: Generative Flow Networks, Detailed Balance, Markov Chain Monte Carlo, Trajectory Flow, Credit Assignment Problem"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitiveDetailedBalanceContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Generative Flow Network (GFlowNet) trajectory balance conditions to ensure that the probability of generating a non-monotonic reasoning path is strictly proportional to its terminal reward.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator's sampling mechanism to continuously optimize for the detailed balance equations using the specified `flow_estimation_matrix`, ensuring proportional flow allocation across MDP branches.\\n\\nEPISTEMIC BOUNDS: Mathematical variance is strictly bounded by `target_balance_epsilon` (`ge=0.0, le=1.0`), preventing probability flow divergence. `local_exploration_k` (`gt=0, le=1`) physically caps exploratory branching.\\n\\nMCP ROUTING TRIGGERS: Generative Flow Networks, Detailed Balance, Markov Chain Monte Carlo, Trajectory Flow, Credit Assignment Problem\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"flow_estimation_matrix\","]
#[doc = "    \"local_exploration_k\","]
#[doc = "    \"target_balance_epsilon\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"flow_estimation_matrix\": {"]
#[doc = "      \"title\": \"Flow Estimation Matrix\","]
#[doc = "      \"description\": \"The specific neural architecture used to estimate flow.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"local_exploration_k\": {"]
#[doc = "      \"title\": \"Local Exploration K\","]
#[doc = "      \"description\": \"The number of exploratory actions taken per state to optimize flow efficiently.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"target_balance_epsilon\": {"]
#[doc = "      \"title\": \"Target Balance Epsilon\","]
#[doc = "      \"description\": \"The mathematical tolerance for the detailed balance constraint.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitiveDetailedBalanceContract {
    #[doc = "The specific neural architecture used to estimate flow."]
    pub flow_estimation_matrix: FlowEstimationMatrix,
    #[doc = "The number of exploratory actions taken per state to optimize flow efficiently."]
    pub local_exploration_k: ::std::num::NonZeroU64,
    #[doc = "The mathematical tolerance for the detailed balance constraint."]
    pub target_balance_epsilon: f64,
}
impl CognitiveDetailedBalanceContract {
    pub fn builder() -> builder::CognitiveDetailedBalanceContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes a Byzantine-tolerant Multi-Agent Debate and Consensus\nprotocol (the \"Two-Man Rule\") to eliminate single-point epistemic failures. As a\n...Receipt suffix, this is a frozen historical fact on the Merkle-DAG.\n\nCAUSAL AFFORDANCE: Authorizes the final cryptographic lock on a reasoning trace or\nsemantic payload, proving that two independent cognitive agents achieved symmetric\nfactual alignment via trace_factual_alignment (bool).\n\nEPISTEMIC BOUNDS: The @model_validator enforce_dual_key_lock mathematically\nguarantees zero-trust isolation by demanding that primary_verifier_cid and\nsecondary_verifier_cid (both NodeCIDState) resolve to completely distinct\nDecentralized Identifiers (DIDs).\n\nMCP ROUTING TRIGGERS: Multi-Agent Debate, Byzantine Tolerance, Dual-Key\nCryptography, Symmetric Consensus, Zero-Trust Evaluation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitiveDualVerificationReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes a Byzantine-tolerant Multi-Agent Debate and Consensus\\nprotocol (the \\\"Two-Man Rule\\\") to eliminate single-point epistemic failures. As a\\n...Receipt suffix, this is a frozen historical fact on the Merkle-DAG.\\n\\nCAUSAL AFFORDANCE: Authorizes the final cryptographic lock on a reasoning trace or\\nsemantic payload, proving that two independent cognitive agents achieved symmetric\\nfactual alignment via trace_factual_alignment (bool).\\n\\nEPISTEMIC BOUNDS: The @model_validator enforce_dual_key_lock mathematically\\nguarantees zero-trust isolation by demanding that primary_verifier_cid and\\nsecondary_verifier_cid (both NodeCIDState) resolve to completely distinct\\nDecentralized Identifiers (DIDs).\\n\\nMCP ROUTING TRIGGERS: Multi-Agent Debate, Byzantine Tolerance, Dual-Key\\nCryptography, Symmetric Consensus, Zero-Trust Evaluation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"primary_verifier_cid\","]
#[doc = "    \"secondary_verifier_cid\","]
#[doc = "    \"trace_factual_alignment\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"primary_verifier_cid\": {"]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring the primary evaluating agent.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"secondary_verifier_cid\": {"]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring the independent secondary evaluating agent.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"trace_factual_alignment\": {"]
#[doc = "      \"title\": \"Trace Factual Alignment\","]
#[doc = "      \"description\": \"Strict Boolean indicating if BOTH agents mathematically agree on factual alignment.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitiveDualVerificationReceipt {
    #[doc = "The globally unique decentralized identifier (DID) anchoring the primary evaluating agent."]
    pub primary_verifier_cid: NodeCidState,
    #[doc = "The globally unique decentralized identifier (DID) anchoring the independent secondary evaluating agent."]
    pub secondary_verifier_cid: NodeCidState,
    #[doc = "Strict Boolean indicating if BOTH agents mathematically agree on factual alignment."]
    pub trace_factual_alignment: bool,
}
impl CognitiveDualVerificationReceipt {
    pub fn builder() -> builder::CognitiveDualVerificationReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Supervisory Control Theory within the causal DAG, instantiating an out-of-band Oracle node for Mixed-Initiative truth resolution.\n\nCAUSAL AFFORDANCE: Physically halts the continuous multi-agent generation loop, forcing the probability wave to suspend until external wetware (human) entropy is safely injected into the topological state.\n\nEPISTEMIC BOUNDS: To mathematically satisfy Byzantine Fault Tolerance (BFT), the `required_attestation` is mandatory. The orchestrator MUST NOT resolve this node without a cryptographically matching `WetwareAttestationContract`, verifying the human operator and preventing Sybil attacks.\n\nMCP ROUTING TRIGGERS: Supervisory Control Theory, Oracle Node, Mixed-Initiative, Proof of Humanity, Out-of-Band Entropy"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitiveHumanNodeProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Supervisory Control Theory within the causal DAG, instantiating an out-of-band Oracle node for Mixed-Initiative truth resolution.\\n\\nCAUSAL AFFORDANCE: Physically halts the continuous multi-agent generation loop, forcing the probability wave to suspend until external wetware (human) entropy is safely injected into the topological state.\\n\\nEPISTEMIC BOUNDS: To mathematically satisfy Byzantine Fault Tolerance (BFT), the `required_attestation` is mandatory. The orchestrator MUST NOT resolve this node without a cryptographically matching `WetwareAttestationContract`, verifying the human operator and preventing Sybil attacks.\\n\\nMCP ROUTING TRIGGERS: Supervisory Control Theory, Oracle Node, Mixed-Initiative, Proof of Humanity, Out-of-Band Entropy\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"description\","]
#[doc = "    \"required_attestation\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"active_attention_ray\": {"]
#[doc = "      \"description\": \"The continuous spatial vector representing the human operator's localized cognitive focus.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EpistemicAttentionState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"description\": {"]
#[doc = "      \"title\": \"Description\","]
#[doc = "      \"description\": \"The semantic boundary defining the objective function or computational perimeter of the execution node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"domain_extensions\": {"]
#[doc = "      \"title\": \"Domain Extensions\","]
#[doc = "      \"description\": \"Passive, untyped extension point for vertical domain context. Strictly bounded to prevent JSON-bomb memory leaks. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"object\","]
#[doc = "          \"additionalProperties\": {"]
#[doc = "            \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"intervention_policies\": {"]
#[doc = "      \"title\": \"Intervention Policies\","]
#[doc = "      \"description\": \"The declarative array of proactive oversight hooks bound to this node's lifecycle.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/InterventionPolicy\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this node's existence in the graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"markov_blanket\": {"]
#[doc = "      \"description\": \"The epistemic isolation boundary guarding this agent's internal generative states.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/MarkovBlanketRenderingPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"render_material\": {"]
#[doc = "      \"description\": \"The physics-agnostic visual identity or shader governing the spatial rendering of this node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SpatialRenderMaterial\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"required_attestation\": {"]
#[doc = "      \"title\": \"Required Attestation\","]
#[doc = "      \"description\": \"The mandatory cryptographic attestation URN required to verify the human operator's identity.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "    },"]
#[doc = "    \"semantic_zoom\": {"]
#[doc = "      \"description\": \"The mathematical Information Bottleneck thresholds dictating the semantic degradation of this specific node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticZoomProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a Human node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"human\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitiveHumanNodeProfile {
    #[doc = "The continuous spatial vector representing the human operator's localized cognitive focus."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub active_attention_ray: ::std::option::Option<EpistemicAttentionState>,
    #[doc = "The AI's declarative rationale for selecting this node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "The semantic boundary defining the objective function or computational perimeter of the execution node."]
    pub description: Description,
    #[doc = "Passive, untyped extension point for vertical domain context. Strictly bounded to prevent JSON-bomb memory leaks. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub domain_extensions: ::std::option::Option<
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    >,
    #[doc = "The declarative array of proactive oversight hooks bound to this node's lifecycle."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub intervention_policies: ::std::vec::Vec<InterventionPolicy>,
    #[doc = "Cryptographic/audit justification for this node's existence in the graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The epistemic isolation boundary guarding this agent's internal generative states."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub markov_blanket: ::std::option::Option<MarkovBlanketRenderingPolicy>,
    #[doc = "The physics-agnostic visual identity or shader governing the spatial rendering of this node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub render_material: ::std::option::Option<SpatialRenderMaterial>,
    #[doc = "The mandatory cryptographic attestation URN required to verify the human operator's identity."]
    pub required_attestation: RequiredAttestation,
    #[doc = "The mathematical Information Bottleneck thresholds dictating the semantic degradation of this specific node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_zoom: ::std::option::Option<SemanticZoomProfile>,
    #[doc = "Discriminator for a Human node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl CognitiveHumanNodeProfile {
    pub fn builder() -> builder::CognitiveHumanNodeProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Captures the pre-verification predictive distribution (Softmax logit outputs) of an LLM across a latent conceptual boundary.\n\nCAUSAL AFFORDANCE: Exposes the raw generative probability manifold to the orchestrator, enabling external mechanistic solvers to evaluate token divergence before crystallizing the probability wave into a permanent epistemic axiom.\n\nEPISTEMIC BOUNDS: Mathematical isolation enforced by binding predictions to a strict `source_chain_cid` CID. The prediction vector is physically capped by `predicted_top_k_tokens` (string `max_length=255`) to prevent unbounded tensor serialization.\n\nMCP ROUTING TRIGGERS: Predictive Distribution, Softmax Logits, Generative Manifold, Probability Wave Collapse, Entropy"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitivePredictionReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Captures the pre-verification predictive distribution (Softmax logit outputs) of an LLM across a latent conceptual boundary.\\n\\nCAUSAL AFFORDANCE: Exposes the raw generative probability manifold to the orchestrator, enabling external mechanistic solvers to evaluate token divergence before crystallizing the probability wave into a permanent epistemic axiom.\\n\\nEPISTEMIC BOUNDS: Mathematical isolation enforced by binding predictions to a strict `source_chain_cid` CID. The prediction vector is physically capped by `predicted_top_k_tokens` (string `max_length=255`) to prevent unbounded tensor serialization.\\n\\nMCP ROUTING TRIGGERS: Predictive Distribution, Softmax Logits, Generative Manifold, Probability Wave Collapse, Entropy\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"predicted_top_k_tokens\","]
#[doc = "    \"source_chain_cid\","]
#[doc = "    \"target_source_concept\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"predicted_top_k_tokens\": {"]
#[doc = "      \"title\": \"Predicted Top K Tokens\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"source_chain_cid\": {"]
#[doc = "      \"title\": \"Source Chain Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_source_concept\": {"]
#[doc = "      \"title\": \"Target Source Concept\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"cognitive_prediction\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitivePredictionReceipt {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    pub predicted_top_k_tokens: ::std::vec::Vec<PredictedTopKTokensItem>,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    pub source_chain_cid: SourceChainCid,
    pub target_source_concept: TargetSourceConcept,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl CognitivePredictionReceipt {
    pub fn builder() -> builder::CognitivePredictionReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative, frozen snapshot of a continuous proof trace resulting\nfrom a successfully resolved non-monotonic search, projecting internal System 2 thinking\ninto the observable graph. As a ...State suffix, this is a frozen N-dimensional\ncoordinate.\n\nCAUSAL AFFORDANCE: Binds the raw, unstructured Chain-of-Thought (trace_payload) to a\nformal EpistemicTopologicalProofManifest (source_proof_cid), injecting the internal\nmonologue into the verifiable DAG for downstream reward shaping (GRPO).\n\nEPISTEMIC BOUNDS: The token_length is restricted (ge=0, le=18446744073709551615). The textual\nreasoning is physically bounded to max_length=100000 to prevent context window\nexplosion. The trace_cid is locked to a 128-char CID.\n\nMCP ROUTING TRIGGERS: Chain of Thought, Non-Monotonic Trace, Proof Crystallization,\nLatent Monologue, Verifiable Reasoning"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitiveReasoningTraceState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative, frozen snapshot of a continuous proof trace resulting\\nfrom a successfully resolved non-monotonic search, projecting internal System 2 thinking\\ninto the observable graph. As a ...State suffix, this is a frozen N-dimensional\\ncoordinate.\\n\\nCAUSAL AFFORDANCE: Binds the raw, unstructured Chain-of-Thought (trace_payload) to a\\nformal EpistemicTopologicalProofManifest (source_proof_cid), injecting the internal\\nmonologue into the verifiable DAG for downstream reward shaping (GRPO).\\n\\nEPISTEMIC BOUNDS: The token_length is restricted (ge=0, le=18446744073709551615). The textual\\nreasoning is physically bounded to max_length=100000 to prevent context window\\nexplosion. The trace_cid is locked to a 128-char CID.\\n\\nMCP ROUTING TRIGGERS: Chain of Thought, Non-Monotonic Trace, Proof Crystallization,\\nLatent Monologue, Verifiable Reasoning\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"source_proof_cid\","]
#[doc = "    \"token_length\","]
#[doc = "    \"trace_cid\","]
#[doc = "    \"trace_payload\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"source_proof_cid\": {"]
#[doc = "      \"title\": \"Source Proof Cid\","]
#[doc = "      \"description\": \"The EpistemicTopologicalProofManifest CID this trace is mathematically anchored to.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"token_length\": {"]
#[doc = "      \"title\": \"Token Length\","]
#[doc = "      \"description\": \"The exact token consumption of the trace.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"trace_cid\": {"]
#[doc = "      \"title\": \"Trace Cid\","]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring this specific non-monotonic reasoning trace.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"trace_payload\": {"]
#[doc = "      \"title\": \"Trace Payload\","]
#[doc = "      \"description\": \"The natural language reasoning steps bounded by structural tags.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitiveReasoningTraceState {
    #[doc = "The EpistemicTopologicalProofManifest CID this trace is mathematically anchored to."]
    pub source_proof_cid: SourceProofCid,
    #[doc = "The exact token consumption of the trace."]
    pub token_length: u64,
    #[doc = "The globally unique decentralized identifier (DID) anchoring this specific non-monotonic reasoning trace."]
    pub trace_cid: TraceCid,
    #[doc = "The natural language reasoning steps bounded by structural tags."]
    pub trace_payload: TracePayload,
}
impl CognitiveReasoningTraceState {
    pub fn builder() -> builder::CognitiveReasoningTraceState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Overrides the default Softmax gating mechanism of a Sparse Mixture of Experts (MoE) architecture to enforce deterministic functional isolation.\n\nCAUSAL AFFORDANCE: Physically biases or mathematically masks out (-inf via `enforce_functional_isolation`) entire swaths of neural circuits, forcing continuous compute through highly specialized expert topological perimeters.\n\nEPISTEMIC BOUNDS: Limits structural instability by hard-bounding `dynamic_top_k` execution threads (`ge=1, le=18446744073709551615`). The `expert_logit_biases` spatial dictionary is bounded by cardinality (`max_length=1000`) with tensor biases clamped to `[ge=-1000.0, le=1000.0]`.\n\nMCP ROUTING TRIGGERS: Sparse Mixture of Experts, Softmax Gating, Logit Biasing, Functional Expert Routing, FSM Masking"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitiveRoutingContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Overrides the default Softmax gating mechanism of a Sparse Mixture of Experts (MoE) architecture to enforce deterministic functional isolation.\\n\\nCAUSAL AFFORDANCE: Physically biases or mathematically masks out (-inf via `enforce_functional_isolation`) entire swaths of neural circuits, forcing continuous compute through highly specialized expert topological perimeters.\\n\\nEPISTEMIC BOUNDS: Limits structural instability by hard-bounding `dynamic_top_k` execution threads (`ge=1, le=18446744073709551615`). The `expert_logit_biases` spatial dictionary is bounded by cardinality (`max_length=1000`) with tensor biases clamped to `[ge=-1000.0, le=1000.0]`.\\n\\nMCP ROUTING TRIGGERS: Sparse Mixture of Experts, Softmax Gating, Logit Biasing, Functional Expert Routing, FSM Masking\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"dynamic_top_k\","]
#[doc = "    \"routing_temperature\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"dynamic_top_k\": {"]
#[doc = "      \"title\": \"Dynamic Top K\","]
#[doc = "      \"description\": \"The exact number of functional experts the router must activate per token. High values simulate deep cognitive strain.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"enforce_functional_isolation\": {"]
#[doc = "      \"title\": \"Enforce Functional Isolation\","]
#[doc = "      \"description\": \"If True, the orchestrator applies a hard mask (-inf) to any expert not explicitly boosted in expert_logit_biases.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"expert_logit_biases\": {"]
#[doc = "      \"title\": \"Expert Logit Biases\","]
#[doc = "      \"description\": \"Explicit tensor biases applied to the router gate. Keys are expert IDs (e.g., 'expert_falsifier'), values are logit modifiers.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"number\","]
#[doc = "        \"maximum\": 1000.0,"]
#[doc = "        \"minimum\": -1000.0"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"routing_temperature\": {"]
#[doc = "      \"title\": \"Routing Temperature\","]
#[doc = "      \"description\": \"The temperature applied to the router's softmax gate, controlling how deterministically it picks experts.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitiveRoutingContract {
    #[doc = "The exact number of functional experts the router must activate per token. High values simulate deep cognitive strain."]
    pub dynamic_top_k: ::std::num::NonZeroU64,
    #[doc = "If True, the orchestrator applies a hard mask (-inf) to any expert not explicitly boosted in expert_logit_biases."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub enforce_functional_isolation: ::std::option::Option<bool>,
    #[doc = "Explicit tensor biases applied to the router gate. Keys are expert IDs (e.g., 'expert_falsifier'), values are logit modifiers."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub expert_logit_biases: ::std::collections::HashMap<::std::string::String, f64>,
    #[doc = "The temperature applied to the router's softmax gate, controlling how deterministically it picks experts."]
    pub routing_temperature: f64,
}
impl CognitiveRoutingContract {
    pub fn builder() -> builder::CognitiveRoutingContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements the Upper Confidence Bound (UCB) algorithm and Inverse Frequency Smoothing to regulate the exploration-exploitation geometry of Monte Carlo Tree Search (MCTS).\n\nCAUSAL AFFORDANCE: Physically regulates the search tree depth and dynamically prioritizes unexplored nodes, forcing the orchestrator to expand its epistemic search space before converging.\n\nEPISTEMIC BOUNDS: Graph traversal depth is rigidly cut off by max_complexity_hops (ge=1, le=18446744073709551615). The mathematical exploration bonus is constrained by inverse_frequency_smoothing_epsilon (le=1.0), preventing exponential divergence in node prioritization.\n\nMCP ROUTING TRIGGERS: Monte Carlo Tree Search, Upper Confidence Bound, Inverse Frequency Smoothing, Heuristic Exploration, Graph Traversal"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitiveSamplingPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements the Upper Confidence Bound (UCB) algorithm and Inverse Frequency Smoothing to regulate the exploration-exploitation geometry of Monte Carlo Tree Search (MCTS).\\n\\nCAUSAL AFFORDANCE: Physically regulates the search tree depth and dynamically prioritizes unexplored nodes, forcing the orchestrator to expand its epistemic search space before converging.\\n\\nEPISTEMIC BOUNDS: Graph traversal depth is rigidly cut off by max_complexity_hops (ge=1, le=18446744073709551615). The mathematical exploration bonus is constrained by inverse_frequency_smoothing_epsilon (le=1.0), preventing exponential divergence in node prioritization.\\n\\nMCP ROUTING TRIGGERS: Monte Carlo Tree Search, Upper Confidence Bound, Inverse Frequency Smoothing, Heuristic Exploration, Graph Traversal\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_complexity_hops\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"inverse_frequency_smoothing_epsilon\": {"]
#[doc = "      \"title\": \"Inverse Frequency Smoothing Epsilon\","]
#[doc = "      \"description\": \"The epsilon constant ensuring unsampled nodes are mathematically prioritized.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"max_complexity_hops\": {"]
#[doc = "      \"title\": \"Max Complexity Hops\","]
#[doc = "      \"description\": \"The absolute physical limit on path length N.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitiveSamplingPolicy {
    #[doc = "The epsilon constant ensuring unsampled nodes are mathematically prioritized."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub inverse_frequency_smoothing_epsilon: ::std::option::Option<f64>,
    #[doc = "The absolute physical limit on path length N."]
    pub max_complexity_hops: ::std::num::NonZeroU64,
}
impl CognitiveSamplingPolicy {
    pub fn builder() -> builder::CognitiveSamplingPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Tracks the continuous Partially Observable Markov Decision Process (POMDP) belief distribution and dictates the active cognitive heuristic.\n\nCAUSAL AFFORDANCE: Orchestrates multi-dimensional state progression, determining if the agent explores via high `divergence_tolerance` or exploits via constrained caution vectors. Embeds steering and routing contracts for mechanistic control.\n\nEPISTEMIC BOUNDS: Relies on strict Pydantic bounding of internal indices (`urgency_index`, `caution_index`, `divergence_tolerance`) to continuous probability distributions mathematically locked between `[ge=0.0, le=1.0]`.\n\nMCP ROUTING TRIGGERS: POMDP, Continuous Belief Distribution, Heuristic Routing, State Progression, Cognitive Constraining"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitiveStateProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Tracks the continuous Partially Observable Markov Decision Process (POMDP) belief distribution and dictates the active cognitive heuristic.\\n\\nCAUSAL AFFORDANCE: Orchestrates multi-dimensional state progression, determining if the agent explores via high `divergence_tolerance` or exploits via constrained caution vectors. Embeds steering and routing contracts for mechanistic control.\\n\\nEPISTEMIC BOUNDS: Relies on strict Pydantic bounding of internal indices (`urgency_index`, `caution_index`, `divergence_tolerance`) to continuous probability distributions mathematically locked between `[ge=0.0, le=1.0]`.\\n\\nMCP ROUTING TRIGGERS: POMDP, Continuous Belief Distribution, Heuristic Routing, State Progression, Cognitive Constraining\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"caution_index\","]
#[doc = "    \"divergence_tolerance\","]
#[doc = "    \"urgency_index\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"activation_steering\": {"]
#[doc = "      \"description\": \"The precise mathematical contract for altering the residual stream to enforce this constraint.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ActivationSteeringContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"caution_index\": {"]
#[doc = "      \"title\": \"Caution Index\","]
#[doc = "      \"description\": \"Drives precision; high caution injects analytical/falsification steering vectors.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"divergence_tolerance\": {"]
#[doc = "      \"title\": \"Divergence Tolerance\","]
#[doc = "      \"description\": \"The 'curiosity' metric; dictates how far the router is allowed to stray from high-probability distributions.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"moe_routing_directive\": {"]
#[doc = "      \"description\": \"The structural mandate overriding default token routing to enforce this cognitive state.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/CognitiveRoutingContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"semantic_slicing\": {"]
#[doc = "      \"description\": \"The mathematical data starvation mechanism bounding the working memory context.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticSlicingPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"urgency_index\": {"]
#[doc = "      \"title\": \"Urgency Index\","]
#[doc = "      \"description\": \"Drives structural constraints; high urgency forces fast heuristic routing.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitiveStateProfile {
    #[doc = "The precise mathematical contract for altering the residual stream to enforce this constraint."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub activation_steering: ::std::option::Option<ActivationSteeringContract>,
    #[doc = "Drives precision; high caution injects analytical/falsification steering vectors."]
    pub caution_index: f64,
    #[doc = "The 'curiosity' metric; dictates how far the router is allowed to stray from high-probability distributions."]
    pub divergence_tolerance: f64,
    #[doc = "The structural mandate overriding default token routing to enforce this cognitive state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub moe_routing_directive: ::std::option::Option<CognitiveRoutingContract>,
    #[doc = "The mathematical data starvation mechanism bounding the working memory context."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_slicing: ::std::option::Option<SemanticSlicingPolicy>,
    #[doc = "Drives structural constraints; high urgency forces fast heuristic routing."]
    pub urgency_index: f64,
}
impl CognitiveStateProfile {
    pub fn builder() -> builder::CognitiveStateProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Simplifies bootstrapping a multi-agent routing topology.\n\n    CAUSAL AFFORDANCE: Physically authorizes the orchestrator to deploy a multi-agent routing topology.\n\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\n\n    MCP ROUTING TRIGGERS: Cognitive Swarm, Agent Deployment, Routing Topology, Bootstrapping Macro"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitiveSwarmDeploymentManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Simplifies bootstrapping a multi-agent routing topology.\\n\\n    CAUSAL AFFORDANCE: Physically authorizes the orchestrator to deploy a multi-agent routing topology.\\n\\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\\n\\n    MCP ROUTING TRIGGERS: Cognitive Swarm, Agent Deployment, Routing Topology, Bootstrapping Macro\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"agent_node_count\","]
#[doc = "    \"consensus_mechanism\","]
#[doc = "    \"swarm_objective_prompt\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"agent_node_count\": {"]
#[doc = "      \"title\": \"Agent Node Count\","]
#[doc = "      \"description\": \"Number of nodes.\","]
#[doc = "      \"type\": \"integer\""]
#[doc = "    },"]
#[doc = "    \"consensus_mechanism\": {"]
#[doc = "      \"title\": \"Consensus Mechanism\","]
#[doc = "      \"description\": \"Consensus mechanism.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"majority\","]
#[doc = "        \"prediction_market\","]
#[doc = "        \"pbft\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"swarm_objective_prompt\": {"]
#[doc = "      \"title\": \"Swarm Objective Prompt\","]
#[doc = "      \"description\": \"The main goal.\","]
#[doc = "      \"type\": \"string\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false,"]
#[doc = "  \"x-domain-cluster\": \"cognitive_routing\","]
#[doc = "  \"x-synergistic-classes\": ["]
#[doc = "    \"TaxonomicRoutingPolicy\","]
#[doc = "    \"CognitiveAgentNodeProfile\","]
#[doc = "    \"SemanticRelationalVectorState\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitiveSwarmDeploymentManifest {
    #[doc = "Number of nodes."]
    pub agent_node_count: i64,
    #[doc = "Consensus mechanism."]
    pub consensus_mechanism: ConsensusMechanism,
    #[doc = "The main goal."]
    pub swarm_objective_prompt: ::std::string::String,
}
impl CognitiveSwarmDeploymentManifest {
    pub fn builder() -> builder::CognitiveSwarmDeploymentManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Encapsulates pure functional logic (Lambda Calculus) and Finite State Machine (FSM) mechanics to represent a completely deterministic, side-effect-free system capability.\n\nCAUSAL AFFORDANCE: Executes rigid, zero-variance procedural logic without invoking the expensive stochastic policy gradients required by foundational LLM models.\n\nEPISTEMIC BOUNDS: This node defines NO additional fields beyond inherited `CoreasonBaseState` constraints, including the rigorous `domain_extensions` volumetric depth limits. The type discriminator is locked to `Literal[\"system\"]`.\n\nMCP ROUTING TRIGGERS: Lambda Calculus, Finite State Machine, Referential Transparency, Deterministic Execution, Zero Variance"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitiveSystemNodeProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Encapsulates pure functional logic (Lambda Calculus) and Finite State Machine (FSM) mechanics to represent a completely deterministic, side-effect-free system capability.\\n\\nCAUSAL AFFORDANCE: Executes rigid, zero-variance procedural logic without invoking the expensive stochastic policy gradients required by foundational LLM models.\\n\\nEPISTEMIC BOUNDS: This node defines NO additional fields beyond inherited `CoreasonBaseState` constraints, including the rigorous `domain_extensions` volumetric depth limits. The type discriminator is locked to `Literal[\\\"system\\\"]`.\\n\\nMCP ROUTING TRIGGERS: Lambda Calculus, Finite State Machine, Referential Transparency, Deterministic Execution, Zero Variance\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"description\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"asymptotic_complexity\": {"]
#[doc = "      \"description\": \"Big-O computational bounds.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/AsymptoticComplexityReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"description\": {"]
#[doc = "      \"title\": \"Description\","]
#[doc = "      \"description\": \"The semantic boundary defining the objective function or computational perimeter of the execution node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"domain_extensions\": {"]
#[doc = "      \"title\": \"Domain Extensions\","]
#[doc = "      \"description\": \"Passive, untyped extension point for vertical domain context. Strictly bounded to prevent JSON-bomb memory leaks. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"object\","]
#[doc = "          \"additionalProperties\": {"]
#[doc = "            \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"execution_substrate\": {"]
#[doc = "      \"description\": \"The mathematical functor blueprint authorizing the runtime to hydrate a specific open-source engine (e.g., SymbolicAI) for this node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ExecutionSubstrateProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"hoare_proof\": {"]
#[doc = "      \"description\": \"Formal mathematical proof of pre/post conditions.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/HoareLogicProofReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"intervention_policies\": {"]
#[doc = "      \"title\": \"Intervention Policies\","]
#[doc = "      \"description\": \"The declarative array of proactive oversight hooks bound to this node's lifecycle.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/InterventionPolicy\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this node's existence in the graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"markov_blanket\": {"]
#[doc = "      \"description\": \"The epistemic isolation boundary guarding this agent's internal generative states.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/MarkovBlanketRenderingPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"render_material\": {"]
#[doc = "      \"description\": \"The physics-agnostic visual identity or shader governing the spatial rendering of this node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SpatialRenderMaterial\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"semantic_zoom\": {"]
#[doc = "      \"description\": \"The mathematical Information Bottleneck thresholds dictating the semantic degradation of this specific node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticZoomProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a System node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"system\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitiveSystemNodeProfile {
    #[doc = "The AI's declarative rationale for selecting this node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "Big-O computational bounds."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub asymptotic_complexity: ::std::option::Option<AsymptoticComplexityReceipt>,
    #[doc = "The semantic boundary defining the objective function or computational perimeter of the execution node."]
    pub description: Description,
    #[doc = "Passive, untyped extension point for vertical domain context. Strictly bounded to prevent JSON-bomb memory leaks. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub domain_extensions: ::std::option::Option<
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    >,
    #[doc = "The mathematical functor blueprint authorizing the runtime to hydrate a specific open-source engine (e.g., SymbolicAI) for this node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub execution_substrate: ::std::option::Option<ExecutionSubstrateProfile>,
    #[doc = "Formal mathematical proof of pre/post conditions."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub hoare_proof: ::std::option::Option<HoareLogicProofReceipt>,
    #[doc = "The declarative array of proactive oversight hooks bound to this node's lifecycle."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub intervention_policies: ::std::vec::Vec<InterventionPolicy>,
    #[doc = "Cryptographic/audit justification for this node's existence in the graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The epistemic isolation boundary guarding this agent's internal generative states."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub markov_blanket: ::std::option::Option<MarkovBlanketRenderingPolicy>,
    #[doc = "The physics-agnostic visual identity or shader governing the spatial rendering of this node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub render_material: ::std::option::Option<SpatialRenderMaterial>,
    #[doc = "The mathematical Information Bottleneck thresholds dictating the semantic degradation of this specific node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_zoom: ::std::option::Option<SemanticZoomProfile>,
    #[doc = "Discriminator for a System node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl CognitiveSystemNodeProfile {
    pub fn builder() -> builder::CognitiveSystemNodeProfile {
        Default::default()
    }
}
#[doc = "`CognitiveTierProfile`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"working\","]
#[doc = "    \"episodic\","]
#[doc = "    \"semantic\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum CognitiveTierProfile {
    #[serde(rename = "working")]
    Working,
    #[serde(rename = "episodic")]
    Episodic,
    #[serde(rename = "semantic")]
    Semantic,
}
impl ::std::fmt::Display for CognitiveTierProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Working => f.write_str("working"),
            Self::Episodic => f.write_str("episodic"),
            Self::Semantic => f.write_str("semantic"),
        }
    }
}
impl ::std::str::FromStr for CognitiveTierProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "working" => Ok(Self::Working),
            "episodic" => Ok(Self::Episodic),
            "semantic" => Ok(Self::Semantic),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for CognitiveTierProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CognitiveTierProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CognitiveTierProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Pearlian Structural Causal Models (SCMs) and Variational Free Energy to mathematically quantify and partition irreducible aleatoric noise from actionable epistemic knowledge gaps.\n\nCAUSAL AFFORDANCE: Unlocks non-monotonic logic via Pearlian do-operators, computing exactly when to trigger a structural abductive escalation or active inference loop via the `requires_abductive_escalation` flag.\n\nEPISTEMIC BOUNDS: Enforces absolute mathematical float boundaries `[ge=0.0, le=1.0]` on `aleatoric_entropy`, `epistemic_uncertainty`, and `semantic_consistency_score`, mathematically preventing probability wave overflow across all three continuous dimensions.\n\nMCP ROUTING TRIGGERS: Structural Causal Models, Active Inference, Variational Free Energy, Aleatoric Entropy, Pearlian Do-Calculus"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CognitiveUncertaintyProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Pearlian Structural Causal Models (SCMs) and Variational Free Energy to mathematically quantify and partition irreducible aleatoric noise from actionable epistemic knowledge gaps.\\n\\nCAUSAL AFFORDANCE: Unlocks non-monotonic logic via Pearlian do-operators, computing exactly when to trigger a structural abductive escalation or active inference loop via the `requires_abductive_escalation` flag.\\n\\nEPISTEMIC BOUNDS: Enforces absolute mathematical float boundaries `[ge=0.0, le=1.0]` on `aleatoric_entropy`, `epistemic_uncertainty`, and `semantic_consistency_score`, mathematically preventing probability wave overflow across all three continuous dimensions.\\n\\nMCP ROUTING TRIGGERS: Structural Causal Models, Active Inference, Variational Free Energy, Aleatoric Entropy, Pearlian Do-Calculus\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"aleatoric_noise_ratio\","]
#[doc = "    \"epistemic_knowledge_gap\","]
#[doc = "    \"requires_abductive_escalation\","]
#[doc = "    \"semantic_consistency_score\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"aleatoric_noise_ratio\": {"]
#[doc = "      \"title\": \"Aleatoric Noise Ratio\","]
#[doc = "      \"description\": \"Measures inherent string ambiguity.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"epistemic_knowledge_gap\": {"]
#[doc = "      \"title\": \"Epistemic Knowledge Gap\","]
#[doc = "      \"description\": \"Measures missing structural context (U_e).\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"requires_abductive_escalation\": {"]
#[doc = "      \"title\": \"Requires Abductive Escalation\","]
#[doc = "      \"description\": \"True if epistemic_uncertainty breaches the safety threshold, requiring structural mandate escalation.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"semantic_consistency_score\": {"]
#[doc = "      \"title\": \"Semantic Consistency Score\","]
#[doc = "      \"description\": \"Counterfactual Geometries representing alternative timeline vectors.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CognitiveUncertaintyProfile {
    #[doc = "Measures inherent string ambiguity."]
    pub aleatoric_noise_ratio: f64,
    #[doc = "Measures missing structural context (U_e)."]
    pub epistemic_knowledge_gap: f64,
    #[doc = "True if epistemic_uncertainty breaches the safety threshold, requiring structural mandate escalation."]
    pub requires_abductive_escalation: bool,
    #[doc = "Counterfactual Geometries representing alternative timeline vectors."]
    pub semantic_consistency_score: f64,
}
impl CognitiveUncertaintyProfile {
    pub fn builder() -> builder::CognitiveUncertaintyProfile {
        Default::default()
    }
}
#[doc = "The raw Colang (.co) state machine configuration."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Colang Payload\","]
#[doc = "  \"description\": \"The raw Colang (.co) state machine configuration.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ColangPayload(::std::string::String);
impl ::std::ops::Deref for ColangPayload {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ColangPayload> for ::std::string::String {
    fn from(value: ColangPayload) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ColangPayload {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ColangPayload {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ColangPayload {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ColangPayload {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ColangPayload {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The Colang specification version."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Colang Version\","]
#[doc = "  \"description\": \"The Colang specification version.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"1.0\","]
#[doc = "    \"2.0\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ColangVersion {
    #[serde(rename = "1.0")]
    X10,
    #[serde(rename = "2.0")]
    X20,
}
impl ::std::fmt::Display for ColangVersion {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::X10 => f.write_str("1.0"),
            Self::X20 => f.write_str("2.0"),
        }
    }
}
impl ::std::str::FromStr for ColangVersion {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "1.0" => Ok(Self::X10),
            "2.0" => Ok(Self::X20),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ColangVersion {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ColangVersion {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ColangVersion {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Integrated Information Theory (IIT) and synergy metrics\nto quantify system-level emergence in the neurosymbolic swarm. As a ...Profile suffix,\nthis is a declarative property descriptor.\n\nCAUSAL AFFORDANCE: Provides the orchestrator with macroscopic topological variables to\nevaluate whether the multi-agent ensemble is producing non-linear, synergistic output\nversus independent parallel processing.\n\nEPISTEMIC BOUNDS: coordination_score and information_integration are upper-clamped at\nle=1.0 to represent normalized mutual information. synergy_index is capped at\nle=18446744073709551615.0 to prevent scalar explosion. Note: no lower ge bounds are enforced on\nthese fields.\n\nMCP ROUTING TRIGGERS: Integrated Information Theory, Systemic Emergence, Conditional\nMutual Information, Synergy Index, Multi-Agent Coupling"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CollectiveIntelligenceProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Integrated Information Theory (IIT) and synergy metrics\\nto quantify system-level emergence in the neurosymbolic swarm. As a ...Profile suffix,\\nthis is a declarative property descriptor.\\n\\nCAUSAL AFFORDANCE: Provides the orchestrator with macroscopic topological variables to\\nevaluate whether the multi-agent ensemble is producing non-linear, synergistic output\\nversus independent parallel processing.\\n\\nEPISTEMIC BOUNDS: coordination_score and information_integration are upper-clamped at\\nle=1.0 to represent normalized mutual information. synergy_index is capped at\\nle=18446744073709551615.0 to prevent scalar explosion. Note: no lower ge bounds are enforced on\\nthese fields.\\n\\nMCP ROUTING TRIGGERS: Integrated Information Theory, Systemic Emergence, Conditional\\nMutual Information, Synergy Index, Multi-Agent Coupling\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"coordination_score\","]
#[doc = "    \"information_integration\","]
#[doc = "    \"synergy_index\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"coordination_score\": {"]
#[doc = "      \"title\": \"Coordination Score\","]
#[doc = "      \"description\": \"The temporal alignment measuring the extent to which agents coordinate their actions over time.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"information_integration\": {"]
#[doc = "      \"title\": \"Information Integration\","]
#[doc = "      \"description\": \"The conditional mutual information quantifying the information flow and tight coupling between agents.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"synergy_index\": {"]
#[doc = "      \"title\": \"Synergy Index\","]
#[doc = "      \"description\": \"The mathematical measure of the degree of emergence. A high SI indicates strong positive emergence.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CollectiveIntelligenceProfile {
    #[doc = "The temporal alignment measuring the extent to which agents coordinate their actions over time."]
    pub coordination_score: f64,
    #[doc = "The conditional mutual information quantifying the information flow and tight coupling between agents."]
    pub information_integration: f64,
    #[doc = "The mathematical measure of the degree of emergence. A high SI indicates strong positive emergence."]
    pub synergy_index: f64,
}
impl CollectiveIntelligenceProfile {
    pub fn builder() -> builder::CollectiveIntelligenceProfile {
        Default::default()
    }
}
#[doc = "The command executable to run (e.g., 'node', 'python')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Command\","]
#[doc = "  \"description\": \"The command executable to run (e.g., 'node', 'python').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Command(::std::string::String);
impl ::std::ops::Deref for Command {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Command> for ::std::string::String {
    fn from(value: Command) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Command {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Command {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Command {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Command {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Command {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The internal TemporalGraphCRDTManifest CID that was flushed."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Committed Temporal Crdt Cid\","]
#[doc = "  \"description\": \"The internal TemporalGraphCRDTManifest CID that was flushed.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CommittedTemporalCrdtCid(::std::string::String);
impl ::std::ops::Deref for CommittedTemporalCrdtCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CommittedTemporalCrdtCid> for ::std::string::String {
    fn from(value: CommittedTemporalCrdtCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CommittedTemporalCrdtCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CommittedTemporalCrdtCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CommittedTemporalCrdtCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CommittedTemporalCrdtCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CommittedTemporalCrdtCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`CompetingHypothesesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CompetingHypothesesItem(::std::string::String);
impl ::std::ops::Deref for CompetingHypothesesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CompetingHypothesesItem> for ::std::string::String {
    fn from(value: CompetingHypothesesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CompetingHypothesesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CompetingHypothesesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CompetingHypothesesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CompetingHypothesesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CompetingHypothesesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The deterministic cryptographic coordinate linking the failure geometry to the execution timeline."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Compilation Attempt Cid\","]
#[doc = "  \"description\": \"The deterministic cryptographic coordinate linking the failure geometry to the execution timeline.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CompilationAttemptCid(::std::string::String);
impl ::std::ops::Deref for CompilationAttemptCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CompilationAttemptCid> for ::std::string::String {
    fn from(value: CompilationAttemptCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CompilationAttemptCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CompilationAttemptCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CompilationAttemptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CompilationAttemptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CompilationAttemptCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SHA-256 fingerprint of the verified proof object that the Rust/C++ orchestrator must load and check."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Compiled Proof Hash\","]
#[doc = "  \"description\": \"The SHA-256 fingerprint of the verified proof object that the Rust/C++ orchestrator must load and check.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CompiledProofHash(::std::string::String);
impl ::std::ops::Deref for CompiledProofHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CompiledProofHash> for ::std::string::String {
    fn from(value: CompiledProofHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CompiledProofHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CompiledProofHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CompiledProofHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CompiledProofHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CompiledProofHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The URN of the backend used to compile the CFG or Regex into a DFA/PDA (e.g., 'urn:coreason:compiler:xgrammar')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Compiler Backend\","]
#[doc = "  \"description\": \"The URN of the backend used to compile the CFG or Regex into a DFA/PDA (e.g., 'urn:coreason:compiler:xgrammar').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CompilerBackend(::std::string::String);
impl ::std::ops::Deref for CompilerBackend {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CompilerBackend> for ::std::string::String {
    fn from(value: CompilerBackend) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CompilerBackend {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^urn:coreason:.*$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^urn:coreason:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CompilerBackend {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CompilerBackend {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CompilerBackend {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CompilerBackend {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements a Fractal Graph Abstraction, allowing the recursive encapsulation of entire workflow sub-topologies within a single, unified macroscopic vertex.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator to suspend the parent graph, injecting state variables into the isolated topology (`AnyTopologyManifest`) via `input_mappings`, and extracting terminal output via `output_mappings`.\n\nEPISTEMIC BOUNDS: The `@model_validator` `_enforce_canonical_sort_mappings` deterministically sorts `input_mappings` by `parent_key` and `output_mappings` by `child_key`, guaranteeing zero-variance RFC 8785 canonical Merkle-DAG hashes across distributed nodes.\n\nMCP ROUTING TRIGGERS: Fractal Graph Abstraction, Recursive Encapsulation, State Projection, Bijective Mapping, Sub-Topology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CompositeNodeProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements a Fractal Graph Abstraction, allowing the recursive encapsulation of entire workflow sub-topologies within a single, unified macroscopic vertex.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator to suspend the parent graph, injecting state variables into the isolated topology (`AnyTopologyManifest`) via `input_mappings`, and extracting terminal output via `output_mappings`.\\n\\nEPISTEMIC BOUNDS: The `@model_validator` `_enforce_canonical_sort_mappings` deterministically sorts `input_mappings` by `parent_key` and `output_mappings` by `child_key`, guaranteeing zero-variance RFC 8785 canonical Merkle-DAG hashes across distributed nodes.\\n\\nMCP ROUTING TRIGGERS: Fractal Graph Abstraction, Recursive Encapsulation, State Projection, Bijective Mapping, Sub-Topology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"description\","]
#[doc = "    \"topology\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"description\": {"]
#[doc = "      \"title\": \"Description\","]
#[doc = "      \"description\": \"The semantic boundary defining the objective function or computational perimeter of the execution node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"domain_extensions\": {"]
#[doc = "      \"title\": \"Domain Extensions\","]
#[doc = "      \"description\": \"Passive, untyped extension point for vertical domain context. Strictly bounded to prevent JSON-bomb memory leaks. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"object\","]
#[doc = "          \"additionalProperties\": {"]
#[doc = "            \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"input_mappings\": {"]
#[doc = "      \"title\": \"Input Mappings\","]
#[doc = "      \"description\": \"Explicit state projection inputs.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/InputMappingContract\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"intervention_policies\": {"]
#[doc = "      \"title\": \"Intervention Policies\","]
#[doc = "      \"description\": \"The declarative array of proactive oversight hooks bound to this node's lifecycle.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/InterventionPolicy\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this node's existence in the graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"markov_blanket\": {"]
#[doc = "      \"description\": \"The epistemic isolation boundary guarding this agent's internal generative states.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/MarkovBlanketRenderingPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"output_mappings\": {"]
#[doc = "      \"title\": \"Output Mappings\","]
#[doc = "      \"description\": \"Explicit state projection outputs.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/OutputMappingContract\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"render_material\": {"]
#[doc = "      \"description\": \"The physics-agnostic visual identity or shader governing the spatial rendering of this node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SpatialRenderMaterial\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"semantic_zoom\": {"]
#[doc = "      \"description\": \"The mathematical Information Bottleneck thresholds dictating the semantic degradation of this specific node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticZoomProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology\": {"]
#[doc = "      \"description\": \"The encapsulated subgraph to execute.\","]
#[doc = "      \"$ref\": \"#/$defs/AnyTopologyManifest\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a Composite node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"composite\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CompositeNodeProfile {
    #[doc = "The AI's declarative rationale for selecting this node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "The semantic boundary defining the objective function or computational perimeter of the execution node."]
    pub description: Description,
    #[doc = "Passive, untyped extension point for vertical domain context. Strictly bounded to prevent JSON-bomb memory leaks. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub domain_extensions: ::std::option::Option<
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    >,
    #[doc = "Explicit state projection inputs."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub input_mappings: ::std::vec::Vec<InputMappingContract>,
    #[doc = "The declarative array of proactive oversight hooks bound to this node's lifecycle."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub intervention_policies: ::std::vec::Vec<InterventionPolicy>,
    #[doc = "Cryptographic/audit justification for this node's existence in the graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The epistemic isolation boundary guarding this agent's internal generative states."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub markov_blanket: ::std::option::Option<MarkovBlanketRenderingPolicy>,
    #[doc = "Explicit state projection outputs."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub output_mappings: ::std::vec::Vec<OutputMappingContract>,
    #[doc = "The physics-agnostic visual identity or shader governing the spatial rendering of this node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub render_material: ::std::option::Option<SpatialRenderMaterial>,
    #[doc = "The mathematical Information Bottleneck thresholds dictating the semantic degradation of this specific node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_zoom: ::std::option::Option<SemanticZoomProfile>,
    #[doc = "The encapsulated subgraph to execute."]
    pub topology: AnyTopologyManifest,
    #[doc = "Discriminator for a Composite node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl CompositeNodeProfile {
    pub fn builder() -> builder::CompositeNodeProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Acts as the liquid compute substrate abstraction, defining the\nfoundational LLM matrix available on the Spot Market for dynamic routing. As a ...Profile\nsuffix, this is a declarative, frozen snapshot of a compute geometry.\n\nCAUSAL AFFORDANCE: Projects the physical LLM capabilities, contextual memory constraints,\nand thermodynamic rate cards (ComputeRateContract) into the orchestrator's active routing\nmanifold, allowing cost-aware topological planning.\n\nEPISTEMIC BOUNDS: The token working memory is mathematically bounded by\ncontext_window_size (le=18446744073709551615). To guarantee RFC 8785 canonical hashing across\ndisparate nodes, the capabilities and supported_functional_experts arrays are strictly\nsorted at instantiation via @model_validator.\n\nMCP ROUTING TRIGGERS: Liquid Compute, Spot Market Routing, Foundation Model Matrix,\nThermodynamic Rate Card, Substrate Abstraction"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ComputeEngineProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Acts as the liquid compute substrate abstraction, defining the\\nfoundational LLM matrix available on the Spot Market for dynamic routing. As a ...Profile\\nsuffix, this is a declarative, frozen snapshot of a compute geometry.\\n\\nCAUSAL AFFORDANCE: Projects the physical LLM capabilities, contextual memory constraints,\\nand thermodynamic rate cards (ComputeRateContract) into the orchestrator's active routing\\nmanifold, allowing cost-aware topological planning.\\n\\nEPISTEMIC BOUNDS: The token working memory is mathematically bounded by\\ncontext_window_size (le=18446744073709551615). To guarantee RFC 8785 canonical hashing across\\ndisparate nodes, the capabilities and supported_functional_experts arrays are strictly\\nsorted at instantiation via @model_validator.\\n\\nMCP ROUTING TRIGGERS: Liquid Compute, Spot Market Routing, Foundation Model Matrix,\\nThermodynamic Rate Card, Substrate Abstraction\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"capabilities\","]
#[doc = "    \"context_window_size\","]
#[doc = "    \"foundation_matrix_name\","]
#[doc = "    \"provider\","]
#[doc = "    \"rate_card\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"capabilities\": {"]
#[doc = "      \"title\": \"Capabilities\","]
#[doc = "      \"description\": \"The explicit, structurally bounded array of capabilities authorized for this model.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000"]
#[doc = "    },"]
#[doc = "    \"context_window_size\": {"]
#[doc = "      \"title\": \"Context Window Size\","]
#[doc = "      \"description\": \"The maximum context window size in tokens.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"foundation_matrix_name\": {"]
#[doc = "      \"title\": \"Foundation Matrix Name\","]
#[doc = "      \"description\": \"The identifier of the underlying model.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"provider\": {"]
#[doc = "      \"title\": \"Provider\","]
#[doc = "      \"description\": \"The name of the provider hosting the model.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"rate_card\": {"]
#[doc = "      \"description\": \"The economic cost definition associated with the model.\","]
#[doc = "      \"$ref\": \"#/$defs/ComputeRateContract\""]
#[doc = "    },"]
#[doc = "    \"supported_functional_experts\": {"]
#[doc = "      \"title\": \"Supported Functional Experts\","]
#[doc = "      \"description\": \"The declarative array of specialized functional expert clusters (e.g., 'falsifier', 'synthesizer') physically present in this model's architecture.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ComputeEngineProfile {
    #[doc = "The explicit, structurally bounded array of capabilities authorized for this model."]
    pub capabilities: ::std::vec::Vec<CapabilitiesItem>,
    #[doc = "The maximum context window size in tokens."]
    pub context_window_size: u64,
    #[doc = "The identifier of the underlying model."]
    pub foundation_matrix_name: FoundationMatrixName,
    #[doc = "The name of the provider hosting the model."]
    pub provider: Provider,
    #[doc = "The economic cost definition associated with the model."]
    pub rate_card: ComputeRateContract,
    #[doc = "The declarative array of specialized functional expert clusters (e.g., 'falsifier', 'synthesizer') physically present in this model's architecture."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub supported_functional_experts: ::std::vec::Vec<SupportedFunctionalExpertsItem>,
}
impl ComputeEngineProfile {
    pub fn builder() -> builder::ComputeEngineProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A Kinetic execution trigger used to request the physical instantiation of new execution substrates. This intent is delegated to SkyPilot for multi-cloud spot-market orchestration.\n\nCAUSAL AFFORDANCE: Triggers the expansion loop in the Governance Plane, authorizing the PulumiActuator (backed by SkyPilot) to provision GPU/CPU nodes across AWS, GCP, Azure, or Vast.ai.\n\nEPISTEMIC BOUNDS: Requires a strictly defined `HardwareProfile` and `EscrowPolicy` to prevent thermodynamic runaway. Cost estimates are validated against the `ComputeRateContract`.\n\nMCP ROUTING TRIGGERS: SkyPilot Orchestration, Multi-Cloud Provisioning, Spot-Market Acquisition, Thermodynamic Expansion, Substrate Instantiation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ComputeProvisioningIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A Kinetic execution trigger used to request the physical instantiation of new execution substrates. This intent is delegated to SkyPilot for multi-cloud spot-market orchestration.\\n\\nCAUSAL AFFORDANCE: Triggers the expansion loop in the Governance Plane, authorizing the PulumiActuator (backed by SkyPilot) to provision GPU/CPU nodes across AWS, GCP, Azure, or Vast.ai.\\n\\nEPISTEMIC BOUNDS: Requires a strictly defined `HardwareProfile` and `EscrowPolicy` to prevent thermodynamic runaway. Cost estimates are validated against the `ComputeRateContract`.\\n\\nMCP ROUTING TRIGGERS: SkyPilot Orchestration, Multi-Cloud Provisioning, Spot-Market Acquisition, Thermodynamic Expansion, Substrate Instantiation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_budget\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"autostop_idle_minutes\": {"]
#[doc = "      \"title\": \"Autostop Idle Minutes\","]
#[doc = "      \"description\": \"The idle timeout after which SkyPilot will automatically terminate the cluster.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"hardware_profile\": {"]
#[doc = "      \"description\": \"The target physical hardware specification (e.g., A100:8).\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SpatialHardwareProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_budget\": {"]
#[doc = "      \"title\": \"Max Budget\","]
#[doc = "      \"description\": \"The maximum atomic cost budget allowable for the provisioned compute.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"provisioning_engine\": {"]
#[doc = "      \"title\": \"Provisioning Engine\","]
#[doc = "      \"description\": \"The underlying orchestration engine (Mandatory: SkyPilot).\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"skypilot\""]
#[doc = "    },"]
#[doc = "    \"qos_class\": {"]
#[doc = "      \"description\": \"The Quality of Service priority, used by the compute spot market for semantic load shedding.\","]
#[doc = "      \"$ref\": \"#/$defs/QoSClassificationProfile\""]
#[doc = "    },"]
#[doc = "    \"required_capabilities\": {"]
#[doc = "      \"title\": \"Required Capabilities\","]
#[doc = "      \"description\": \"The minimal functional capabilities required by the requested compute.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The discriminative topological boundary for compute provisioning intents.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"compute_provisioning\""]
#[doc = "    },"]
#[doc = "    \"use_spot\": {"]
#[doc = "      \"title\": \"Use Spot\","]
#[doc = "      \"description\": \"If True, SkyPilot will hunt for the cheapest spot instances and handle managed recovery.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ComputeProvisioningIntent {
    #[doc = "The idle timeout after which SkyPilot will automatically terminate the cluster."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub autostop_idle_minutes: ::std::option::Option<i64>,
    #[doc = "The target physical hardware specification (e.g., A100:8)."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub hardware_profile: ::std::option::Option<SpatialHardwareProfile>,
    #[doc = "The maximum atomic cost budget allowable for the provisioned compute."]
    pub max_budget: u64,
    #[doc = "The underlying orchestration engine (Mandatory: SkyPilot)."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub provisioning_engine: ::std::option::Option<::std::string::String>,
    #[doc = "The Quality of Service priority, used by the compute spot market for semantic load shedding."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub qos_class: ::std::option::Option<QoSClassificationProfile>,
    #[doc = "The minimal functional capabilities required by the requested compute."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub required_capabilities: ::std::vec::Vec<RequiredCapabilitiesItem>,
    #[doc = "The discriminative topological boundary for compute provisioning intents."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "If True, SkyPilot will hunt for the cheapest spot instances and handle managed recovery."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub use_spot: ::std::option::Option<bool>,
}
impl ComputeProvisioningIntent {
    pub fn builder() -> builder::ComputeProvisioningIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: The immutable economic physics engine defining the Thermodynamic Cost of token generation across the network.\n\nCAUSAL AFFORDANCE: Allows the swarm orchestrator to mathematically project the budget exhaustion of a specific Latent Scratchpad trace or MCTS rollout before committing to the execution graph.\n\nEPISTEMIC BOUNDS: Strict integer boundaries (`le=18446744073709551615`) on `cost_per_million_input_tokens` and `cost_per_million_output_tokens` ensure economic execution vectors cannot overflow the Epistemic Ledger. Eliminates IEEE 754 precision loss.\n\nMCP ROUTING TRIGGERS: Thermodynamic Cost, Monte Carlo Tree Search, Economic Escrow, Token Burn, Budget Calculation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ComputeRateContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: The immutable economic physics engine defining the Thermodynamic Cost of token generation across the network.\\n\\nCAUSAL AFFORDANCE: Allows the swarm orchestrator to mathematically project the budget exhaustion of a specific Latent Scratchpad trace or MCTS rollout before committing to the execution graph.\\n\\nEPISTEMIC BOUNDS: Strict integer boundaries (`le=18446744073709551615`) on `cost_per_million_input_tokens` and `cost_per_million_output_tokens` ensure economic execution vectors cannot overflow the Epistemic Ledger. Eliminates IEEE 754 precision loss.\\n\\nMCP ROUTING TRIGGERS: Thermodynamic Cost, Monte Carlo Tree Search, Economic Escrow, Token Burn, Budget Calculation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"cost_per_million_input_tokens\","]
#[doc = "    \"cost_per_million_output_tokens\","]
#[doc = "    \"magnitude_unit\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"cost_per_million_input_tokens\": {"]
#[doc = "      \"title\": \"Cost Per Million Input Tokens\","]
#[doc = "      \"description\": \"The atomic integer cost per 1 million input tokens provided to the model.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"cost_per_million_output_tokens\": {"]
#[doc = "      \"title\": \"Cost Per Million Output Tokens\","]
#[doc = "      \"description\": \"The atomic integer cost per 1 million output tokens generated by the model.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"magnitude_unit\": {"]
#[doc = "      \"title\": \"Magnitude Unit\","]
#[doc = "      \"description\": \"The magnitude unit of the associated costs.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ComputeRateContract {
    #[doc = "The atomic integer cost per 1 million input tokens provided to the model."]
    pub cost_per_million_input_tokens: u64,
    #[doc = "The atomic integer cost per 1 million output tokens generated by the model."]
    pub cost_per_million_output_tokens: u64,
    #[doc = "The magnitude unit of the associated costs."]
    pub magnitude_unit: MagnitudeUnit,
}
impl ComputeRateContract {
    pub fn builder() -> builder::ComputeRateContract {
        Default::default()
    }
}
#[doc = "The discrete architectural boundary of the node."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Compute Tier\","]
#[doc = "  \"description\": \"The discrete architectural boundary of the node.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ComputeTier(::std::string::String);
impl ::std::ops::Deref for ComputeTier {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ComputeTier> for ::std::string::String {
    fn from(value: ComputeTier) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ComputeTier {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^urn:coreason:.*$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^urn:coreason:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ComputeTier {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ComputeTier {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ComputeTier {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ComputeTier {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The unique geometric coordinate representing this specific assembled concept."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Concept Cid\","]
#[doc = "  \"description\": \"The unique geometric coordinate representing this specific assembled concept.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ConceptCid(::std::string::String);
impl ::std::ops::Deref for ConceptCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ConceptCid> for ::std::string::String {
    fn from(value: ConceptCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ConceptCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ConceptCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ConceptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ConceptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ConceptCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this falsification test to the Merkle-DAG."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Condition Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this falsification test to the Merkle-DAG.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ConditionCid(::std::string::String);
impl ::std::ops::Deref for ConditionCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ConditionCid> for ::std::string::String {
    fn from(value: ConditionCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ConditionCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ConditionCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ConditionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ConditionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ConditionCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A Zero-Cost Macro abstraction that deterministically projects a Practical Byzantine Fault Tolerance (pBFT) consensus ring into a multi-agent workflow. As a ...Manifest suffix, this defines a frozen coordinate of a topological structure.\n\nCAUSAL AFFORDANCE: Unrolls into a base CouncilTopologyManifest, enforcing strict quorum rules and sequential adjudication to guarantee ledger alignment and truth maintenance across a decentralized, zero-trust swarm.\n\nEPISTEMIC BOUNDS: Mathematically ensures Byzantine security by requiring a minimum of 3 participant_cids. The adjudicator_cid is physically isolated from the voting pool via the verify_adjudicator_isolation hook. The participant_cids array is deterministically sorted for invariant hashing.\n\nMCP ROUTING TRIGGERS: Practical Byzantine Fault Tolerance, pBFT, Distributed Consensus, Sybil Resistance, Macro Abstraction"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ConsensusFederationTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A Zero-Cost Macro abstraction that deterministically projects a Practical Byzantine Fault Tolerance (pBFT) consensus ring into a multi-agent workflow. As a ...Manifest suffix, this defines a frozen coordinate of a topological structure.\\n\\nCAUSAL AFFORDANCE: Unrolls into a base CouncilTopologyManifest, enforcing strict quorum rules and sequential adjudication to guarantee ledger alignment and truth maintenance across a decentralized, zero-trust swarm.\\n\\nEPISTEMIC BOUNDS: Mathematically ensures Byzantine security by requiring a minimum of 3 participant_cids. The adjudicator_cid is physically isolated from the voting pool via the verify_adjudicator_isolation hook. The participant_cids array is deterministically sorted for invariant hashing.\\n\\nMCP ROUTING TRIGGERS: Practical Byzantine Fault Tolerance, pBFT, Distributed Consensus, Sybil Resistance, Macro Abstraction\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"adjudicator_cid\","]
#[doc = "    \"participant_cids\","]
#[doc = "    \"quorum_rules\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"adjudicator_cid\": {"]
#[doc = "      \"description\": \"The orchestrating sequencer for the PBFT consensus.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"participant_cids\": {"]
#[doc = "      \"title\": \"Participant Cids\","]
#[doc = "      \"description\": \"The nodes forming the PBFT ring.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 3"]
#[doc = "    },"]
#[doc = "    \"quorum_rules\": {"]
#[doc = "      \"description\": \"The strict BFT tolerance bounds.\","]
#[doc = "      \"$ref\": \"#/$defs/QuorumPolicy\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for federation macro.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"macro_federation\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ConsensusFederationTopologyManifest {
    #[doc = "The orchestrating sequencer for the PBFT consensus."]
    pub adjudicator_cid: NodeCidState,
    #[doc = "The nodes forming the PBFT ring."]
    pub participant_cids: ::std::vec::Vec<NodeCidState>,
    #[doc = "The strict BFT tolerance bounds."]
    pub quorum_rules: QuorumPolicy,
    #[doc = "Discriminator for federation macro."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl ConsensusFederationTopologyManifest {
    pub fn builder() -> builder::ConsensusFederationTopologyManifest {
        Default::default()
    }
}
#[doc = "Consensus mechanism."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Consensus Mechanism\","]
#[doc = "  \"description\": \"Consensus mechanism.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"majority\","]
#[doc = "    \"prediction_market\","]
#[doc = "    \"pbft\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ConsensusMechanism {
    #[serde(rename = "majority")]
    Majority,
    #[serde(rename = "prediction_market")]
    PredictionMarket,
    #[serde(rename = "pbft")]
    Pbft,
}
impl ::std::fmt::Display for ConsensusMechanism {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Majority => f.write_str("majority"),
            Self::PredictionMarket => f.write_str("prediction_market"),
            Self::Pbft => f.write_str("pbft"),
        }
    }
}
impl ::std::str::FromStr for ConsensusMechanism {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "majority" => Ok(Self::Majority),
            "prediction_market" => Ok(Self::PredictionMarket),
            "pbft" => Ok(Self::Pbft),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ConsensusMechanism {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ConsensusMechanism {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ConsensusMechanism {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Social Choice Theory and Distributed Consensus mechanisms\nto systematically synthesize a singular, crystallized truth from a multi-agent council.\nAs a ...Policy suffix, this object defines rigid mathematical boundaries.\n\nCAUSAL AFFORDANCE: Triggers deterministic tie-breaking (via optional\ntie_breaker_node_cid: NodeCIDState) or algorithmic market resolution (via\noptional prediction_market_rules: PredictionMarketPolicy) when agents deadlock,\nforcefully collapsing the debate probability wave to maintain systemic liveness.\n\nEPISTEMIC BOUNDS: The max_debate_rounds (optional int) is clamped to le=18446744073709551615 to\ncomputationally solve the Halting Problem for runaway arguments. The strategy Literal\n[\"unanimous\", \"majority\", \"debate_rounds\", \"prediction_market\", \"pbft\"] constrains\nthe combinatorial space. The @model_validator requires quorum_rules if strategy is\n\"pbft\".\n\nMCP ROUTING TRIGGERS: Social Choice Theory, Mechanism Design, Condorcet's Jury Theorem,\nAlgorithmic Consensus, Deadlock Resolution"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ConsensusPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Social Choice Theory and Distributed Consensus mechanisms\\nto systematically synthesize a singular, crystallized truth from a multi-agent council.\\nAs a ...Policy suffix, this object defines rigid mathematical boundaries.\\n\\nCAUSAL AFFORDANCE: Triggers deterministic tie-breaking (via optional\\ntie_breaker_node_cid: NodeCIDState) or algorithmic market resolution (via\\noptional prediction_market_rules: PredictionMarketPolicy) when agents deadlock,\\nforcefully collapsing the debate probability wave to maintain systemic liveness.\\n\\nEPISTEMIC BOUNDS: The max_debate_rounds (optional int) is clamped to le=18446744073709551615 to\\ncomputationally solve the Halting Problem for runaway arguments. The strategy Literal\\n[\\\"unanimous\\\", \\\"majority\\\", \\\"debate_rounds\\\", \\\"prediction_market\\\", \\\"pbft\\\"] constrains\\nthe combinatorial space. The @model_validator requires quorum_rules if strategy is\\n\\\"pbft\\\".\\n\\nMCP ROUTING TRIGGERS: Social Choice Theory, Mechanism Design, Condorcet's Jury Theorem,\\nAlgorithmic Consensus, Deadlock Resolution\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"strategy\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_debate_rounds\": {"]
#[doc = "      \"title\": \"Max Debate Rounds\","]
#[doc = "      \"description\": \"The maximum number of argument/rebuttal cycles permitted before forced adjudication.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"prediction_market_rules\": {"]
#[doc = "      \"description\": \"The strict algorithmic mechanism rules required if the strategy is prediction_market.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/PredictionMarketPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"quorum_rules\": {"]
#[doc = "      \"description\": \"The strict Byzantine fault tolerance limits required if the strategy is 'pbft'.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/QuorumPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"strategy\": {"]
#[doc = "      \"title\": \"Strategy\","]
#[doc = "      \"description\": \"The mathematical rule for reaching agreement.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"unanimous\","]
#[doc = "        \"majority\","]
#[doc = "        \"debate_rounds\","]
#[doc = "        \"prediction_market\","]
#[doc = "        \"pbft\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"tie_breaker_node_cid\": {"]
#[doc = "      \"description\": \"The node authorized to break deadlocks if unanimity or majority fails.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ConsensusPolicy {
    #[doc = "The maximum number of argument/rebuttal cycles permitted before forced adjudication."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_debate_rounds: ::std::option::Option<u64>,
    #[doc = "The strict algorithmic mechanism rules required if the strategy is prediction_market."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prediction_market_rules: ::std::option::Option<PredictionMarketPolicy>,
    #[doc = "The strict Byzantine fault tolerance limits required if the strategy is 'pbft'."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub quorum_rules: ::std::option::Option<QuorumPolicy>,
    #[doc = "The mathematical rule for reaching agreement."]
    pub strategy: Strategy,
    #[doc = "The node authorized to break deadlocks if unanimity or majority fails."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub tie_breaker_node_cid: ::std::option::Option<NodeCidState>,
}
impl ConsensusPolicy {
    pub fn builder() -> builder::ConsensusPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents a non-monotonic structural revision trigger within a Defeasible Logic framework, engineered to adapt the GovernancePolicy to out-of-distribution environments.\n\nCAUSAL AFFORDANCE: Triggers an active topological mutation (Pearlian intervention) to resolve logical friction, applying a strict RFC 6902 JSON Patch (`proposed_patch`) to the underlying alignment manifold.\n\nEPISTEMIC BOUNDS: Cryptographically anchored to the specific `drift_event_cid` (regex bounded CID `^[a-zA-Z0-9_.:-]+$`) that mathematically justified the revision. The payload is constrained to a JSON Schema object (`proposed_patch`).\n\nMCP ROUTING TRIGGERS: Defeasible Logic, Non-Monotonic Revision, Out-of-Distribution Adaptation, Normative Drift Resolution, Pearlian Intervention"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ConstitutionalAmendmentIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents a non-monotonic structural revision trigger within a Defeasible Logic framework, engineered to adapt the GovernancePolicy to out-of-distribution environments.\\n\\nCAUSAL AFFORDANCE: Triggers an active topological mutation (Pearlian intervention) to resolve logical friction, applying a strict RFC 6902 JSON Patch (`proposed_patch`) to the underlying alignment manifold.\\n\\nEPISTEMIC BOUNDS: Cryptographically anchored to the specific `drift_event_cid` (regex bounded CID `^[a-zA-Z0-9_.:-]+$`) that mathematically justified the revision. The payload is constrained to a JSON Schema object (`proposed_patch`).\\n\\nMCP ROUTING TRIGGERS: Defeasible Logic, Non-Monotonic Revision, Out-of-Distribution Adaptation, Normative Drift Resolution, Pearlian Intervention\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"drift_event_cid\","]
#[doc = "    \"justification\","]
#[doc = "    \"proposed_patch\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"drift_event_cid\": {"]
#[doc = "      \"title\": \"Drift Event Cid\","]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring the GuardrailViolationEvent that justified triggering this proposal.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"The AI's natural language structural/logical argument for why this patch resolves the contradiction without violating the root AnchoringPolicy.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"proposed_patch\": {"]
#[doc = "      \"title\": \"Proposed Patch\","]
#[doc = "      \"description\": \"A strict, structurally bounded JSON Patch (RFC 6902) proposed by the AI to mutate the GovernancePolicy.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The strict discriminator for this intervention payload.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"constitutional_amendment\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ConstitutionalAmendmentIntent {
    #[doc = "The globally unique decentralized identifier (DID) anchoring the GuardrailViolationEvent that justified triggering this proposal."]
    pub drift_event_cid: DriftEventCid,
    #[doc = "The AI's natural language structural/logical argument for why this patch resolves the contradiction without violating the root AnchoringPolicy."]
    pub justification: Justification,
    #[doc = "A strict, structurally bounded JSON Patch (RFC 6902) proposed by the AI to mutate the GovernancePolicy."]
    pub proposed_patch: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "The strict discriminator for this intervention payload."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl ConstitutionalAmendmentIntent {
    pub fn builder() -> builder::ConstitutionalAmendmentIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A rigid mathematical boundary enforcing systemic constraints globally. Dictates the hardware-level execution limits for the token sampling phase by converting structural formatting from a probabilistic neural suggestion into a deterministic physics problem.\n\nCAUSAL AFFORDANCE: Enforces rigid isolation perimeters and limits subgraph generation by physically suffocating invalid token probabilities. Instructs the inference engine (e.g., Outlines, XGrammar) to compile a DFA/PDA and mechanically overwrite illegal token logits to negative infinity.\n\nEPISTEMIC BOUNDS: Strict categorical literal on `enforcement_strategy`. The `compiler_backend` is constrained via URN pattern. The `validate_grammar_requirements` `@model_validator` mandates `formal_grammar_string` is non-null if the strategy expects a Context-Free Grammar (CFG).\n\nMCP ROUTING TRIGGERS: FSM Logit Masking, Constrained Decoding, Tokenizer Interception, Hardware Execution Boundary, Pushdown Automaton"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ConstrainedDecodingPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A rigid mathematical boundary enforcing systemic constraints globally. Dictates the hardware-level execution limits for the token sampling phase by converting structural formatting from a probabilistic neural suggestion into a deterministic physics problem.\\n\\nCAUSAL AFFORDANCE: Enforces rigid isolation perimeters and limits subgraph generation by physically suffocating invalid token probabilities. Instructs the inference engine (e.g., Outlines, XGrammar) to compile a DFA/PDA and mechanically overwrite illegal token logits to negative infinity.\\n\\nEPISTEMIC BOUNDS: Strict categorical literal on `enforcement_strategy`. The `compiler_backend` is constrained via URN pattern. The `validate_grammar_requirements` `@model_validator` mandates `formal_grammar_string` is non-null if the strategy expects a Context-Free Grammar (CFG).\\n\\nMCP ROUTING TRIGGERS: FSM Logit Masking, Constrained Decoding, Tokenizer Interception, Hardware Execution Boundary, Pushdown Automaton\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"compiler_backend\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"compiler_backend\": {"]
#[doc = "      \"title\": \"Compiler Backend\","]
#[doc = "      \"description\": \"The URN of the backend used to compile the CFG or Regex into a DFA/PDA (e.g., 'urn:coreason:compiler:xgrammar').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "    },"]
#[doc = "    \"enforcement_strategy\": {"]
#[doc = "      \"title\": \"Enforcement Strategy\","]
#[doc = "      \"description\": \"The mechanistic strategy for intercepting the LLM forward pass.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"fsm_logit_mask\","]
#[doc = "        \"lmql_query\","]
#[doc = "        \"guidance_program\","]
#[doc = "        \"ebnf_grammar\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"formal_grammar_string\": {"]
#[doc = "      \"title\": \"Formal Grammar String\","]
#[doc = "      \"description\": \"The raw LMQL query string, Guidance program, or EBNF grammar. Required if the enforcement_strategy is not standard JSON/Regex masking.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"terminate_on_eos_leak\": {"]
#[doc = "      \"title\": \"Terminate On Eos Leak\","]
#[doc = "      \"description\": \"If True, mathematically forces the engine to halt if the LLM attempts to generate an EOS token before the FSM reaches an accepting state.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ConstrainedDecodingPolicy {
    #[doc = "The URN of the backend used to compile the CFG or Regex into a DFA/PDA (e.g., 'urn:coreason:compiler:xgrammar')."]
    pub compiler_backend: CompilerBackend,
    #[doc = "The mechanistic strategy for intercepting the LLM forward pass."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub enforcement_strategy: ::std::option::Option<EnforcementStrategy>,
    #[doc = "The raw LMQL query string, Guidance program, or EBNF grammar. Required if the enforcement_strategy is not standard JSON/Regex masking."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub formal_grammar_string: ::std::option::Option<::std::string::String>,
    #[doc = "If True, mathematically forces the engine to halt if the LLM attempts to generate an EOS token before the FSM reaches an accepting state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub terminate_on_eos_leak: ::std::option::Option<bool>,
}
impl ConstrainedDecodingPolicy {
    pub fn builder() -> builder::ConstrainedDecodingPolicy {
        Default::default()
    }
}
#[doc = "`ConstraintCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Constraint Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ConstraintCid(::std::string::String);
impl ::std::ops::Deref for ConstraintCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ConstraintCid> for ::std::string::String {
    fn from(value: ConstraintCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ConstraintCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ConstraintCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ConstraintCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ConstraintCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ConstraintCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Governs the structural logic for Hierarchical Navigable Small World\n(HNSW) context hydration and dynamic text block aggregation. As a ...Policy suffix, this\nobject defines rigid mathematical boundaries that the orchestrator must enforce globally.\n\nCAUSAL AFFORDANCE: Triggers the physical expansion of the active working memory partition,\nauthorizing the orchestrator to mathematically merge adjacent semantic nodes or sliding\nwindows via the selected expansion_paradigm (sliding_window, hierarchical_merge, or\ndocument_summary).\n\nEPISTEMIC BOUNDS: Strictly capped by max_token_budget (gt=0, le=18446744073709551615) to prevent\nGPU VRAM exhaustion. Further bounded by the optional spatial geometry\nparent_merge_threshold (ge=0.0, le=1.0) and the optional temporal window\nsurrounding_sentences_k (ge=1, le=18446744073709551615).\n\nMCP ROUTING TRIGGERS: Hierarchical Navigable Small World, Context Hydration, Token Budget\nOptimization, Semantic Merging"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ContextExpansionPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Governs the structural logic for Hierarchical Navigable Small World\\n(HNSW) context hydration and dynamic text block aggregation. As a ...Policy suffix, this\\nobject defines rigid mathematical boundaries that the orchestrator must enforce globally.\\n\\nCAUSAL AFFORDANCE: Triggers the physical expansion of the active working memory partition,\\nauthorizing the orchestrator to mathematically merge adjacent semantic nodes or sliding\\nwindows via the selected expansion_paradigm (sliding_window, hierarchical_merge, or\\ndocument_summary).\\n\\nEPISTEMIC BOUNDS: Strictly capped by max_token_budget (gt=0, le=18446744073709551615) to prevent\\nGPU VRAM exhaustion. Further bounded by the optional spatial geometry\\nparent_merge_threshold (ge=0.0, le=1.0) and the optional temporal window\\nsurrounding_sentences_k (ge=1, le=18446744073709551615).\\n\\nMCP ROUTING TRIGGERS: Hierarchical Navigable Small World, Context Hydration, Token Budget\\nOptimization, Semantic Merging\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"expansion_paradigm\","]
#[doc = "    \"max_token_budget\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"expansion_paradigm\": {"]
#[doc = "      \"title\": \"Expansion Paradigm\","]
#[doc = "      \"description\": \"The mathematical paradigm governing how context is expanded.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"sliding_window\","]
#[doc = "        \"hierarchical_merge\","]
#[doc = "        \"document_summary\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_token_budget\": {"]
#[doc = "      \"title\": \"Max Token Budget\","]
#[doc = "      \"description\": \"The maximum physical token allowance for expansion.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"parent_merge_threshold\": {"]
#[doc = "      \"title\": \"Parent Merge Threshold\","]
#[doc = "      \"description\": \"The geometric cosine similarity threshold required to merge parent nodes.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.0,"]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"surrounding_sentences_k\": {"]
#[doc = "      \"title\": \"Surrounding Sentences K\","]
#[doc = "      \"description\": \"The strict temporal window of surrounding sentences.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"minimum\": 1.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ContextExpansionPolicy {
    #[doc = "The mathematical paradigm governing how context is expanded."]
    pub expansion_paradigm: ExpansionParadigm,
    #[doc = "The maximum physical token allowance for expansion."]
    pub max_token_budget: ::std::num::NonZeroU64,
    #[doc = "The geometric cosine similarity threshold required to merge parent nodes."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub parent_merge_threshold: ::std::option::Option<f64>,
    #[doc = "The strict temporal window of surrounding sentences."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub surrounding_sentences_k: ::std::option::Option<::std::num::NonZeroU64>,
}
impl ContextExpansionPolicy {
    pub fn builder() -> builder::ContextExpansionPolicy {
        Default::default()
    }
}
#[doc = "The prompt explaining what information the swarm is missing."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Context Prompt\","]
#[doc = "  \"description\": \"The prompt explaining what information the swarm is missing.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ContextPrompt(::std::string::String);
impl ::std::ops::Deref for ContextPrompt {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ContextPrompt> for ::std::string::String {
    fn from(value: ContextPrompt) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ContextPrompt {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ContextPrompt {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ContextPrompt {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ContextPrompt {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ContextPrompt {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A summary of the context requiring intervention."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Context Summary\","]
#[doc = "  \"description\": \"A summary of the context requiring intervention.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ContextSummary(::std::string::String);
impl ::std::ops::Deref for ContextSummary {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ContextSummary> for ::std::string::String {
    fn from(value: ContextSummary) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ContextSummary {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ContextSummary {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ContextSummary {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ContextSummary {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ContextSummary {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`ContextWindowCidsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ContextWindowCidsItem(::std::string::String);
impl ::std::ops::Deref for ContextWindowCidsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ContextWindowCidsItem> for ::std::string::String {
    fn from(value: ContextWindowCidsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ContextWindowCidsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ContextWindowCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ContextWindowCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ContextWindowCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ContextWindowCidsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`ContextualEnvelopeItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ContextualEnvelopeItem(::std::string::String);
impl ::std::ops::Deref for ContextualEnvelopeItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ContextualEnvelopeItem> for ::std::string::String {
    fn from(value: ContextualEnvelopeItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ContextualEnvelopeItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ContextualEnvelopeItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ContextualEnvelopeItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ContextualEnvelopeItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ContextualEnvelopeItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Acts as the kinetic trigger forcing the orchestrator to dynamically resolve a raw, untyped SemanticRelationalVectorState against a global standard ontology using optimal transport metrics, entirely bypassing legacy ETL string-matching.\n\n    CAUSAL AFFORDANCE: Physically authorizes the orchestrator to execute the defined optimal transport resolution.\n\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\n\n    MCP ROUTING TRIGGERS: Semantic Resolution, Optimal Transport, ETL Bypass, Dynamic Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ContextualSemanticResolutionIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Acts as the kinetic trigger forcing the orchestrator to dynamically resolve a raw, untyped SemanticRelationalVectorState against a global standard ontology using optimal transport metrics, entirely bypassing legacy ETL string-matching.\\n\\n    CAUSAL AFFORDANCE: Physically authorizes the orchestrator to execute the defined optimal transport resolution.\\n\\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\\n\\n    MCP ROUTING TRIGGERS: Semantic Resolution, Optimal Transport, ETL Bypass, Dynamic Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"alignment_metric\","]
#[doc = "    \"encoding_profile\","]
#[doc = "    \"minimum_isometry_threshold\","]
#[doc = "    \"source_record_cid\","]
#[doc = "    \"target_ontology_graph_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"alignment_metric\": {"]
#[doc = "      \"description\": \"The optimal transport or algebraic distance metric used for evaluation.\","]
#[doc = "      \"$ref\": \"#/$defs/ManifoldAlignmentMetricProfile\""]
#[doc = "    },"]
#[doc = "    \"encoding_profile\": {"]
#[doc = "      \"description\": \"The method requested for compressing the source row into a continuous tensor.\","]
#[doc = "      \"$ref\": \"#/$defs/TabularEncodingProfile\""]
#[doc = "    },"]
#[doc = "    \"minimum_isometry_threshold\": {"]
#[doc = "      \"title\": \"Minimum Isometry Threshold\","]
#[doc = "      \"description\": \"Mathematical circuit breaker. If the distance evaluates below this threshold, resolution is aborted to prevent semantic hallucination.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"source_record_cid\": {"]
#[doc = "      \"title\": \"Source Record Cid\","]
#[doc = "      \"description\": \"An explicit cryptographic pointer to the raw SemanticRelationalVectorState pending resolution.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_ontology_graph_cid\": {"]
#[doc = "      \"title\": \"Target Ontology Graph Cid\","]
#[doc = "      \"description\": \"A pointer to the specific standard vocabulary subgraph (e.g., an OMOP schema graph).\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for contextual semantic resolution.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"contextual_semantic_resolution\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ContextualSemanticResolutionIntent {
    #[doc = "The optimal transport or algebraic distance metric used for evaluation."]
    pub alignment_metric: ManifoldAlignmentMetricProfile,
    #[doc = "The method requested for compressing the source row into a continuous tensor."]
    pub encoding_profile: TabularEncodingProfile,
    #[doc = "Mathematical circuit breaker. If the distance evaluates below this threshold, resolution is aborted to prevent semantic hallucination."]
    pub minimum_isometry_threshold: f64,
    #[doc = "An explicit cryptographic pointer to the raw SemanticRelationalVectorState pending resolution."]
    pub source_record_cid: SourceRecordCid,
    #[doc = "A pointer to the specific standard vocabulary subgraph (e.g., an OMOP schema graph)."]
    pub target_ontology_graph_cid: TargetOntologyGraphCid,
    #[doc = "Discriminator for contextual semantic resolution."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl ContextualSemanticResolutionIntent {
    pub fn builder() -> builder::ContextualSemanticResolutionIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Projects a semantically unified spatial token footprint representing the strictly bounded source projection.\n\n    CAUSAL AFFORDANCE: Authorizes downstream parsing tasks to isolate exact dimensional target strings while strictly maintaining chronological relationships via the topological envelope.\n\n    EPISTEMIC BOUNDS: Limits structural explosion by constraining target sequences and contextual items mathematically to max_length=100000. Contains a strict topological exemption preventing array sorting.\n\n    MCP ROUTING TRIGGERS: Semantic Envelope, Contextual Projection, Spatial Token Footprint, Source Entity, Topos Sorting"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ContextualizedSourceState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Projects a semantically unified spatial token footprint representing the strictly bounded source projection.\\n\\n    CAUSAL AFFORDANCE: Authorizes downstream parsing tasks to isolate exact dimensional target strings while strictly maintaining chronological relationships via the topological envelope.\\n\\n    EPISTEMIC BOUNDS: Limits structural explosion by constraining target sequences and contextual items mathematically to max_length=100000. Contains a strict topological exemption preventing array sorting.\\n\\n    MCP ROUTING TRIGGERS: Semantic Envelope, Contextual Projection, Spatial Token Footprint, Source Entity, Topos Sorting\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"contextual_envelope\","]
#[doc = "    \"source_system_provenance_flag\","]
#[doc = "    \"target_string\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"contextual_envelope\": {"]
#[doc = "      \"title\": \"Contextual Envelope\","]
#[doc = "      \"description\": \"The strictly bounded array of adjacent token clusters forming the semantic proximity matrix.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 100000"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 10000,"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"source_system_provenance_flag\": {"]
#[doc = "      \"title\": \"Source System Provenance Flag\","]
#[doc = "      \"description\": \"The mathematical boolean boundary indicating strict physical provenance to an external host.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"target_string\": {"]
#[doc = "      \"title\": \"Target String\","]
#[doc = "      \"description\": \"The strictly bounded, un-redacted 1D string projection of the semantic artifact undergoing evaluation.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ContextualizedSourceState {
    #[doc = "The strictly bounded array of adjacent token clusters forming the semantic proximity matrix."]
    pub contextual_envelope: ::std::vec::Vec<ContextualEnvelopeItem>,
    #[doc = "The mathematical boolean boundary indicating strict physical provenance to an external host."]
    pub source_system_provenance_flag: bool,
    #[doc = "The strictly bounded, un-redacted 1D string projection of the semantic artifact undergoing evaluation."]
    pub target_string: TargetString,
}
impl ContextualizedSourceState {
    pub fn builder() -> builder::ContextualizedSourceState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Profunctor Optics for mapping continuous N-dimensional spatial tensors (e.g., NeRFs, VQ-VAEs) into discrete semantic graph coordinates.\nCAUSAL AFFORDANCE: Authorizes the spatial rendering engine to mathematically fuse a physical coordinate (SE3) with an abstract SemanticNodeState.\nEPISTEMIC BOUNDS: Strict bounding on volumetric distance and isometry preservation.\nMCP ROUTING TRIGGERS: Cross-Modal Isomorphism, Semantic Fusion, Volumetric Projection, Profunctor Optics"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ContinuousManifoldMappingContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Profunctor Optics for mapping continuous N-dimensional spatial tensors (e.g., NeRFs, VQ-VAEs) into discrete semantic graph coordinates.\\nCAUSAL AFFORDANCE: Authorizes the spatial rendering engine to mathematically fuse a physical coordinate (SE3) with an abstract SemanticNodeState.\\nEPISTEMIC BOUNDS: Strict bounding on volumetric distance and isometry preservation.\\nMCP ROUTING TRIGGERS: Cross-Modal Isomorphism, Semantic Fusion, Volumetric Projection, Profunctor Optics\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"isometry_preservation_score\","]
#[doc = "    \"source_semantic_node_cid\","]
#[doc = "    \"target_spatial_transform\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"isometry_preservation_score\": {"]
#[doc = "      \"title\": \"Isometry Preservation Score\","]
#[doc = "      \"description\": \"Calculated geometric alignment between the semantic embedding and spatial tensor.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"source_semantic_node_cid\": {"]
#[doc = "      \"description\": \"The discrete semantic concept being spatially anchored.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"target_spatial_transform\": {"]
#[doc = "      \"description\": \"The absolute SE(3) physical coordinate mapping.\","]
#[doc = "      \"$ref\": \"#/$defs/SE3TransformProfile\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for manifold mapping.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"manifold_mapping\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ContinuousManifoldMappingContract {
    #[doc = "Calculated geometric alignment between the semantic embedding and spatial tensor."]
    pub isometry_preservation_score: f64,
    #[doc = "The discrete semantic concept being spatially anchored."]
    pub source_semantic_node_cid: NodeCidState,
    #[doc = "The absolute SE(3) physical coordinate mapping."]
    pub target_spatial_transform: Se3TransformProfile,
    #[doc = "Discriminator for manifold mapping."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl ContinuousManifoldMappingContract {
    pub fn builder() -> builder::ContinuousManifoldMappingContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Queueing Theory and Micro-Batching Stream Processing\nheuristics for continuous, high-velocity graph updates without violating Eventual\nConsistency. As a ...Policy suffix, this defines rigid mathematical boundaries.\n\nCAUSAL AFFORDANCE: Dictates the thermodynamic flow of the orchestrator, determining\nexactly when to buffer and when to force-commit volatile StateMutationIntent\nmatrices to the EpistemicLedgerState via the mutation_paradigm\nLiteral [\"append_only\", \"merge_on_resolve\"].\n\nEPISTEMIC BOUNDS: Physically prevents Out-Of-Memory (OOM) VRAM crashes by\nmathematically enforcing max_uncommitted_edges (gt=0, le=18446744073709551615). The\n@model_validator enforce_append_only_vram_bound further crushes this limit to\n<= 10000 for append_only operations. The commit cycle is temporally guillotined\nby micro_batch_interval_ms (gt=0, le=18446744073709551615).\n\nMCP ROUTING TRIGGERS: Queueing Theory, Stream Processing, Micro-Batching,\nBackpressure, Buffer Memory Bounding"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ContinuousMutationPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Queueing Theory and Micro-Batching Stream Processing\\nheuristics for continuous, high-velocity graph updates without violating Eventual\\nConsistency. As a ...Policy suffix, this defines rigid mathematical boundaries.\\n\\nCAUSAL AFFORDANCE: Dictates the thermodynamic flow of the orchestrator, determining\\nexactly when to buffer and when to force-commit volatile StateMutationIntent\\nmatrices to the EpistemicLedgerState via the mutation_paradigm\\nLiteral [\\\"append_only\\\", \\\"merge_on_resolve\\\"].\\n\\nEPISTEMIC BOUNDS: Physically prevents Out-Of-Memory (OOM) VRAM crashes by\\nmathematically enforcing max_uncommitted_edges (gt=0, le=18446744073709551615). The\\n@model_validator enforce_append_only_vram_bound further crushes this limit to\\n<= 10000 for append_only operations. The commit cycle is temporally guillotined\\nby micro_batch_interval_ms (gt=0, le=18446744073709551615).\\n\\nMCP ROUTING TRIGGERS: Queueing Theory, Stream Processing, Micro-Batching,\\nBackpressure, Buffer Memory Bounding\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_uncommitted_edges\","]
#[doc = "    \"micro_batch_interval_ms\","]
#[doc = "    \"mutation_paradigm\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_uncommitted_edges\": {"]
#[doc = "      \"title\": \"Max Uncommitted Edges\","]
#[doc = "      \"description\": \"Backpressure threshold before forcing a commit.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"micro_batch_interval_ms\": {"]
#[doc = "      \"title\": \"Micro Batch Interval Ms\","]
#[doc = "      \"description\": \"Temporal bound for flushing the stream.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"mutation_paradigm\": {"]
#[doc = "      \"title\": \"Mutation Paradigm\","]
#[doc = "      \"description\": \"Forces non-destructive graph mutations.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"append_only\","]
#[doc = "        \"merge_on_resolve\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ContinuousMutationPolicy {
    #[doc = "Backpressure threshold before forcing a commit."]
    pub max_uncommitted_edges: ::std::num::NonZeroU64,
    #[doc = "Temporal bound for flushing the stream."]
    pub micro_batch_interval_ms: ::std::num::NonZeroU64,
    #[doc = "Forces non-destructive graph mutations."]
    pub mutation_paradigm: MutationParadigm,
}
impl ContinuousMutationPolicy {
    pub fn builder() -> builder::ContinuousMutationPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the geometric snapshot of a continuous stream and its \"forget gate\" disfluency rules, acting as a declarative snapshot of continuous token flows.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator to continuously process and retain token buffers governed by a temporal decay matrix.\n\nEPISTEMIC BOUNDS: The `token_buffer` is mathematically capped at `max_length=1000000` (Topological Exemption: DO NOT SORT). Each token restricted to `max_length=10000`. `temporal_decay_matrix` forces bounded temporal scaling (`ge=0.0, le=1.0`).\n\nMCP ROUTING TRIGGERS: Continuous Observation, State Space Models, Temporal Decay, Forget Gate, Streaming Disfluency"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ContinuousObservationState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the geometric snapshot of a continuous stream and its \\\"forget gate\\\" disfluency rules, acting as a declarative snapshot of continuous token flows.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator to continuously process and retain token buffers governed by a temporal decay matrix.\\n\\nEPISTEMIC BOUNDS: The `token_buffer` is mathematically capped at `max_length=1000000` (Topological Exemption: DO NOT SORT). Each token restricted to `max_length=10000`. `temporal_decay_matrix` forces bounded temporal scaling (`ge=0.0, le=1.0`).\\n\\nMCP ROUTING TRIGGERS: Continuous Observation, State Space Models, Temporal Decay, Forget Gate, Streaming Disfluency\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"latest_confidence_score\","]
#[doc = "    \"stream_cid\","]
#[doc = "    \"temporal_decay_matrix\","]
#[doc = "    \"token_buffer\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"latest_confidence_score\": {"]
#[doc = "      \"title\": \"Latest Confidence Score\","]
#[doc = "      \"description\": \"The certainty score of the latest token prediction.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"stream_cid\": {"]
#[doc = "      \"title\": \"Stream Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) for the continuous observation stream.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"temporal_decay_matrix\": {"]
#[doc = "      \"title\": \"Temporal Decay Matrix\","]
#[doc = "      \"description\": \"The mathematical decay map applied to historical token indices.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"number\","]
#[doc = "        \"maximum\": 1.0,"]
#[doc = "        \"minimum\": 0.0"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"token_buffer\": {"]
#[doc = "      \"title\": \"Token Buffer\","]
#[doc = "      \"description\": \"The array of ingested tokens representing the continuous stream. AGENT INSTRUCTION: Topological Exemption applied. Do NOT sort this array, as its chronological sequence is its mathematical state.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 10000"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000000,"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ContinuousObservationState {
    #[doc = "The certainty score of the latest token prediction."]
    pub latest_confidence_score: f64,
    #[doc = "A Content Identifier (CID) for the continuous observation stream."]
    pub stream_cid: StreamCid,
    #[doc = "The mathematical decay map applied to historical token indices."]
    pub temporal_decay_matrix: ::std::collections::HashMap<::std::string::String, f64>,
    #[doc = "The array of ingested tokens representing the continuous stream. AGENT INSTRUCTION: Topological Exemption applied. Do NOT sort this array, as its chronological sequence is its mathematical state."]
    pub token_buffer: ::std::vec::Vec<TokenBufferItem>,
}
impl ContinuousObservationState {
    pub fn builder() -> builder::ContinuousObservationState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes an Affine Conflict-free Replicated Data Type (CRDT) to execute Optimistic Concurrency Control across geometric manipulations.\n\nCAUSAL AFFORDANCE: Authorizes a participant to kinetically drag, rotate, or scale a topological node. The orchestrator uses the provided Lamport clock to mathematically resolve Spherical Linear Interpolation (SLERP) and translation collisions between concurrent actors.\n\nEPISTEMIC BOUNDS: The mutation strictly targets a verified `NodeCIDState`. The `lamport_clock` (`ge=0, le=18446744073709551615`) prevents temporal overflow during logical state reconciliation.\n\nMCP ROUTING TRIGGERS: Optimistic Locking, Affine CRDT, Spherical Linear Interpolation, Continuous Reconciliation, Kinematic Drag"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ContinuousSpatialMutationIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes an Affine Conflict-free Replicated Data Type (CRDT) to execute Optimistic Concurrency Control across geometric manipulations.\\n\\nCAUSAL AFFORDANCE: Authorizes a participant to kinetically drag, rotate, or scale a topological node. The orchestrator uses the provided Lamport clock to mathematically resolve Spherical Linear Interpolation (SLERP) and translation collisions between concurrent actors.\\n\\nEPISTEMIC BOUNDS: The mutation strictly targets a verified `NodeCIDState`. The `lamport_clock` (`ge=0, le=18446744073709551615`) prevents temporal overflow during logical state reconciliation.\\n\\nMCP ROUTING TRIGGERS: Optimistic Locking, Affine CRDT, Spherical Linear Interpolation, Continuous Reconciliation, Kinematic Drag\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"lamport_clock\","]
#[doc = "    \"proposed_transform\","]
#[doc = "    \"target_node_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"lamport_clock\": {"]
#[doc = "      \"title\": \"Lamport Clock\","]
#[doc = "      \"description\": \"The logical clock scalar dictating Last-Writer-Wins consensus for the geometric shift.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"proposed_transform\": {"]
#[doc = "      \"description\": \"The requested absolute SE(3) spatial terminus.\","]
#[doc = "      \"$ref\": \"#/$defs/SE3TransformProfile\""]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"description\": \"The specific topology vertex undergoing spatial mutation.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The discriminative topological boundary for spatial mutation intents.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"continuous_spatial_mutation\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ContinuousSpatialMutationIntent {
    #[doc = "The logical clock scalar dictating Last-Writer-Wins consensus for the geometric shift."]
    pub lamport_clock: u64,
    #[doc = "The requested absolute SE(3) spatial terminus."]
    pub proposed_transform: Se3TransformProfile,
    #[doc = "The specific topology vertex undergoing spatial mutation."]
    pub target_node_cid: NodeCidState,
    #[doc = "The discriminative topological boundary for spatial mutation intents."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl ContinuousSpatialMutationIntent {
    pub fn builder() -> builder::ContinuousSpatialMutationIntent {
        Default::default()
    }
}
#[doc = "The networking mode defining the P2P boundary for enterprise compliance."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Coreason Network Mode\","]
#[doc = "  \"description\": \"The networking mode defining the P2P boundary for enterprise compliance.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"P2P\","]
#[doc = "    \"STRICT_GENESIS\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum CoreasonNetworkMode {
    #[serde(rename = "P2P")]
    P2p,
    #[serde(rename = "STRICT_GENESIS")]
    StrictGenesis,
}
impl ::std::fmt::Display for CoreasonNetworkMode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::P2p => f.write_str("P2P"),
            Self::StrictGenesis => f.write_str("STRICT_GENESIS"),
        }
    }
}
impl ::std::str::FromStr for CoreasonNetworkMode {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "P2P" => Ok(Self::P2p),
            "STRICT_GENESIS" => Ok(Self::StrictGenesis),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for CoreasonNetworkMode {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CoreasonNetworkMode {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CoreasonNetworkMode {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`CorruptionClass`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Corruption Class\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"drm_locked\","]
#[doc = "    \"malformed_bytes\","]
#[doc = "    \"ocr_failure\","]
#[doc = "    \"unsupported_format\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum CorruptionClass {
    #[serde(rename = "drm_locked")]
    DrmLocked,
    #[serde(rename = "malformed_bytes")]
    MalformedBytes,
    #[serde(rename = "ocr_failure")]
    OcrFailure,
    #[serde(rename = "unsupported_format")]
    UnsupportedFormat,
}
impl ::std::fmt::Display for CorruptionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::DrmLocked => f.write_str("drm_locked"),
            Self::MalformedBytes => f.write_str("malformed_bytes"),
            Self::OcrFailure => f.write_str("ocr_failure"),
            Self::UnsupportedFormat => f.write_str("unsupported_format"),
        }
    }
}
impl ::std::str::FromStr for CorruptionClass {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "drm_locked" => Ok(Self::DrmLocked),
            "malformed_bytes" => Ok(Self::MalformedBytes),
            "ocr_failure" => Ok(Self::OcrFailure),
            "unsupported_format" => Ok(Self::UnsupportedFormat),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for CorruptionClass {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CorruptionClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CorruptionClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Social Choice Theory, Condorcet's Jury Theorem, and Practical Byzantine Fault Tolerance (pBFT) to synthesize an authoritative truth from a multi-agent network.\n\nCAUSAL AFFORDANCE: Unlocks decentralized truth-synthesis by routing conflicting proposals through a strict `consensus_policy`, ultimately collapsing the epistemic probability wave via the designated `adjudicator_cid`. Cognitive heterogeneity is enforced by `diversity_policy`.\n\nEPISTEMIC BOUNDS: The `@model_validator` `enforce_funded_byzantine_slashing` enforces a strict economic interlock: if the `consensus_policy` demands `slash_escrow` via pBFT, it halts instantiation unless a funded `council_escrow` is present. `check_adjudicator_cid` verifies the adjudicator exists in the nodes registry.\n\nMCP ROUTING TRIGGERS: Social Choice Theory, PBFT Consensus, Multi-Agent Debate, Byzantine Fault Tolerance, Slashing Condition"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CouncilTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Social Choice Theory, Condorcet's Jury Theorem, and Practical Byzantine Fault Tolerance (pBFT) to synthesize an authoritative truth from a multi-agent network.\\n\\nCAUSAL AFFORDANCE: Unlocks decentralized truth-synthesis by routing conflicting proposals through a strict `consensus_policy`, ultimately collapsing the epistemic probability wave via the designated `adjudicator_cid`. Cognitive heterogeneity is enforced by `diversity_policy`.\\n\\nEPISTEMIC BOUNDS: The `@model_validator` `enforce_funded_byzantine_slashing` enforces a strict economic interlock: if the `consensus_policy` demands `slash_escrow` via pBFT, it halts instantiation unless a funded `council_escrow` is present. `check_adjudicator_cid` verifies the adjudicator exists in the nodes registry.\\n\\nMCP ROUTING TRIGGERS: Social Choice Theory, PBFT Consensus, Multi-Agent Debate, Byzantine Fault Tolerance, Slashing Condition\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"adjudicator_cid\","]
#[doc = "    \"nodes\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"adjudicator_cid\": {"]
#[doc = "      \"description\": \"The NodeCIDState of the adjudicator that synthesizes the council's output.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"consensus_policy\": {"]
#[doc = "      \"description\": \"The explicit ruleset governing how the council resolves disagreements.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ConsensusPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"council_escrow\": {"]
#[doc = "      \"description\": \"The strictly typed mathematical surface area to lock funds specifically for PBFT council execution and slashing.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EscrowPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"diversity_policy\": {"]
#[doc = "      \"description\": \"Constraints enforcing cognitive heterogeneity across the council.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/DiversityPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"epistemic_enforcement\": {"]
#[doc = "      \"description\": \"Ties the topology to the Truth Maintenance layer.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TruthMaintenancePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this topology's configuration.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"lifecycle_phase\": {"]
#[doc = "      \"title\": \"Lifecycle Phase\","]
#[doc = "      \"description\": \"The execution phase of the graph. 'draft' allows incomplete structural state.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"draft\","]
#[doc = "        \"live\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"nodes\": {"]
#[doc = "      \"title\": \"Nodes\","]
#[doc = "      \"description\": \"Flat registry of all nodes in this topology.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyNodeProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"observability\": {"]
#[doc = "      \"description\": \"The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ObservabilityLODPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"ontological_alignment\": {"]
#[doc = "      \"description\": \"The pre-flight execution gate forcing agents to mathematically align their latent semantics before participating in the topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/OntologicalAlignmentPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"semantic_flow\": {"]
#[doc = "      \"description\": \"The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticFlowPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"shared_state_contract\": {"]
#[doc = "      \"description\": \"The schema-on-write contract governing the internal state of this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StateContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a Council topology.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"council\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CouncilTopologyManifest {
    #[doc = "The NodeCIDState of the adjudicator that synthesizes the council's output."]
    pub adjudicator_cid: NodeCidState,
    #[doc = "The AI's declarative rationale for selecting this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "The explicit ruleset governing how the council resolves disagreements."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub consensus_policy: ::std::option::Option<ConsensusPolicy>,
    #[doc = "The strictly typed mathematical surface area to lock funds specifically for PBFT council execution and slashing."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub council_escrow: ::std::option::Option<EscrowPolicy>,
    #[doc = "Constraints enforcing cognitive heterogeneity across the council."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub diversity_policy: ::std::option::Option<DiversityPolicy>,
    #[doc = "Ties the topology to the Truth Maintenance layer."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_enforcement: ::std::option::Option<TruthMaintenancePolicy>,
    #[doc = "Cryptographic/audit justification for this topology's configuration."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The execution phase of the graph. 'draft' allows incomplete structural state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub lifecycle_phase: ::std::option::Option<LifecyclePhase>,
    #[doc = "Flat registry of all nodes in this topology."]
    pub nodes: ::std::collections::HashMap<::std::string::String, AnyNodeProfile>,
    #[doc = "The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub observability: ::std::option::Option<ObservabilityLodPolicy>,
    #[doc = "The pre-flight execution gate forcing agents to mathematically align their latent semantics before participating in the topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub ontological_alignment: ::std::option::Option<OntologicalAlignmentPolicy>,
    #[doc = "The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_flow: ::std::option::Option<SemanticFlowPolicy>,
    #[doc = "The schema-on-write contract governing the internal state of this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub shared_state_contract: ::std::option::Option<StateContract>,
    #[doc = "Discriminator for a Council topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl CouncilTopologyManifest {
    pub fn builder() -> builder::CouncilTopologyManifest {
        Default::default()
    }
}
#[doc = "The specific alternative action or do-calculus intervention applied in the simulation."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Counterfactual Intervention\","]
#[doc = "  \"description\": \"The specific alternative action or do-calculus intervention applied in the simulation.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CounterfactualIntervention(::std::string::String);
impl ::std::ops::Deref for CounterfactualIntervention {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CounterfactualIntervention> for ::std::string::String {
    fn from(value: CounterfactualIntervention) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CounterfactualIntervention {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CounterfactualIntervention {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CounterfactualIntervention {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CounterfactualIntervention {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CounterfactualIntervention {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Employs Counterfactual Regret Minimization (CFR) and Pearlian Do-Calculus to execute simulated alternative timelines for policy refinement.\n\nCAUSAL AFFORDANCE: Commits a simulated causal divergence (intervention) into the ledger, mathematically quantifying the opportunity cost (regret) to backpropagate stateless adjustments to the routing policy.\n\nEPISTEMIC BOUNDS: Anchored to `historical_event_cid` (128-char CID). Expected utilities and `epistemic_regret` are physically capped at `le=18446744073709551615.0`. `policy_mutation_gradients` restrict tensor adjustments.\n\nMCP ROUTING TRIGGERS: Counterfactual Regret Minimization, Pearlian Do-Calculus, Opportunity Cost, Alternative Timeline, Policy Gradient Update"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CounterfactualRegretEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Employs Counterfactual Regret Minimization (CFR) and Pearlian Do-Calculus to execute simulated alternative timelines for policy refinement.\\n\\nCAUSAL AFFORDANCE: Commits a simulated causal divergence (intervention) into the ledger, mathematically quantifying the opportunity cost (regret) to backpropagate stateless adjustments to the routing policy.\\n\\nEPISTEMIC BOUNDS: Anchored to `historical_event_cid` (128-char CID). Expected utilities and `epistemic_regret` are physically capped at `le=18446744073709551615.0`. `policy_mutation_gradients` restrict tensor adjustments.\\n\\nMCP ROUTING TRIGGERS: Counterfactual Regret Minimization, Pearlian Do-Calculus, Opportunity Cost, Alternative Timeline, Policy Gradient Update\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"counterfactual_intervention\","]
#[doc = "    \"epistemic_regret\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"expected_utility_actual\","]
#[doc = "    \"expected_utility_simulated\","]
#[doc = "    \"historical_event_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"counterfactual_intervention\": {"]
#[doc = "      \"title\": \"Counterfactual Intervention\","]
#[doc = "      \"description\": \"The specific alternative action or do-calculus intervention applied in the simulation.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"epistemic_regret\": {"]
#[doc = "      \"title\": \"Epistemic Regret\","]
#[doc = "      \"description\": \"The mathematical variance (simulated - actual) representing the opportunity cost of the historical decision.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"expected_utility_actual\": {"]
#[doc = "      \"title\": \"Expected Utility Actual\","]
#[doc = "      \"description\": \"The calculated utility of the trajectory that was actually executed.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"expected_utility_simulated\": {"]
#[doc = "      \"title\": \"Expected Utility Simulated\","]
#[doc = "      \"description\": \"The calculated utility of the simulated counterfactual trajectory.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"historical_event_cid\": {"]
#[doc = "      \"title\": \"Historical Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the specific historical state node where the agent mathematically diverged to simulate an alternative path.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"policy_mutation_gradients\": {"]
#[doc = "      \"title\": \"Policy Mutation Gradients\","]
#[doc = "      \"description\": \"The stateless routing gradient adjustments derived from the calculated regret, used to self-correct future routing.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"number\","]
#[doc = "        \"maximum\": 1000.0,"]
#[doc = "        \"minimum\": -1000.0"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for a counterfactual regret event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"counterfactual_regret\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CounterfactualRegretEvent {
    #[doc = "The specific alternative action or do-calculus intervention applied in the simulation."]
    pub counterfactual_intervention: CounterfactualIntervention,
    #[doc = "The mathematical variance (simulated - actual) representing the opportunity cost of the historical decision."]
    pub epistemic_regret: f64,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The calculated utility of the trajectory that was actually executed."]
    pub expected_utility_actual: f64,
    #[doc = "The calculated utility of the simulated counterfactual trajectory."]
    pub expected_utility_simulated: f64,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the specific historical state node where the agent mathematically diverged to simulate an alternative path."]
    pub historical_event_cid: HistoricalEventCid,
    #[doc = "The stateless routing gradient adjustments derived from the calculated regret, used to self-correct future routing."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub policy_mutation_gradients: ::std::collections::HashMap<::std::string::String, f64>,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "Discriminator type for a counterfactual regret event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl CounterfactualRegretEvent {
    pub fn builder() -> builder::CounterfactualRegretEvent {
        Default::default()
    }
}
#[doc = "Unique identifier for the grading criterion."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Criterion Cid\","]
#[doc = "  \"description\": \"Unique identifier for the grading criterion.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CriterionCid(::std::string::String);
impl ::std::ops::Deref for CriterionCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CriterionCid> for ::std::string::String {
    fn from(value: CriterionCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CriterionCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CriterionCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CriterionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CriterionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CriterionCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`CrossoverMechanismProfile`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"uniform_blend\","]
#[doc = "    \"single_point\","]
#[doc = "    \"heuristic\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum CrossoverMechanismProfile {
    #[serde(rename = "uniform_blend")]
    UniformBlend,
    #[serde(rename = "single_point")]
    SinglePoint,
    #[serde(rename = "heuristic")]
    Heuristic,
}
impl ::std::fmt::Display for CrossoverMechanismProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::UniformBlend => f.write_str("uniform_blend"),
            Self::SinglePoint => f.write_str("single_point"),
            Self::Heuristic => f.write_str("heuristic"),
        }
    }
}
impl ::std::str::FromStr for CrossoverMechanismProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "uniform_blend" => Ok(Self::UniformBlend),
            "single_point" => Ok(Self::SinglePoint),
            "heuristic" => Ok(Self::Heuristic),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for CrossoverMechanismProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CrossoverMechanismProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CrossoverMechanismProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes the chromosomal crossover and genetic recombination\nheuristics for blending latent feature vectors of elite parent agents. As a ...Policy\nsuffix, this object defines rigid mathematical boundaries that the orchestrator must\nenforce globally.\n\nCAUSAL AFFORDANCE: Executes the deterministic interpolation of N-dimensional properties\nfrom successful agents using a specific geometric strategy (CrossoverMechanismProfile)\nto breed the next generation's starting state.\n\nEPISTEMIC BOUNDS: The blending_factor is strictly constrained to a fractional\ninterpolation ratio (ge=0.0, le=1.0) to mathematically prevent extrapolated state drift\nbeyond the parents' bounding box. Relies on optional verifiable_entropy\n(VerifiableEntropyReceipt) to ensure unbiased recombination.\n\nMCP ROUTING TRIGGERS: Genetic Recombination, Chromosomal Crossover, Vector\nInterpolation, Elitism, Reproduction Heuristic"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CrossoverPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes the chromosomal crossover and genetic recombination\\nheuristics for blending latent feature vectors of elite parent agents. As a ...Policy\\nsuffix, this object defines rigid mathematical boundaries that the orchestrator must\\nenforce globally.\\n\\nCAUSAL AFFORDANCE: Executes the deterministic interpolation of N-dimensional properties\\nfrom successful agents using a specific geometric strategy (CrossoverMechanismProfile)\\nto breed the next generation's starting state.\\n\\nEPISTEMIC BOUNDS: The blending_factor is strictly constrained to a fractional\\ninterpolation ratio (ge=0.0, le=1.0) to mathematically prevent extrapolated state drift\\nbeyond the parents' bounding box. Relies on optional verifiable_entropy\\n(VerifiableEntropyReceipt) to ensure unbiased recombination.\\n\\nMCP ROUTING TRIGGERS: Genetic Recombination, Chromosomal Crossover, Vector\\nInterpolation, Elitism, Reproduction Heuristic\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"blending_factor\","]
#[doc = "    \"strategy_profile\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"blending_factor\": {"]
#[doc = "      \"title\": \"Blending Factor\","]
#[doc = "      \"description\": \"The proportional mix ratio when merging vector properties.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"strategy_profile\": {"]
#[doc = "      \"description\": \"The heuristic method for blending successful parent agents.\","]
#[doc = "      \"$ref\": \"#/$defs/CrossoverMechanismProfile\""]
#[doc = "    },"]
#[doc = "    \"verifiable_entropy\": {"]
#[doc = "      \"description\": \"The cryptographic envelope proving the fairness of the applied crossover logic.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/VerifiableEntropyReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CrossoverPolicy {
    #[doc = "The proportional mix ratio when merging vector properties."]
    pub blending_factor: f64,
    #[doc = "The heuristic method for blending successful parent agents."]
    pub strategy_profile: CrossoverMechanismProfile,
    #[doc = "The cryptographic envelope proving the fairness of the applied crossover logic."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub verifiable_entropy: ::std::option::Option<VerifiableEntropyReceipt>,
}
impl CrossoverPolicy {
    pub fn builder() -> builder::CrossoverPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: The immutable, cryptographically frozen result of an OntoGPT semantic grounding pass.\n\nCAUSAL AFFORDANCE: Commits the successful translation of raw strings to formal CURIEs into the Epistemic Ledger, physically preserving traceability and preventing 'Traceability Collapse'.\n\nEPISTEMIC BOUNDS: The `resolved_curies` dictionary mathematically locks arbitrary strings to strict W3C CURIE regex patterns (`^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$`). The alignment certainty is captured by the `grounding_confidence` tri-vector.\n\nMCP ROUTING TRIGGERS: Epistemic Provenance, Crosswalk Resolution, Grounding Receipt, Ontology Access Kit, CURIE"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CrosswalkResolutionReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: The immutable, cryptographically frozen result of an OntoGPT semantic grounding pass.\\n\\nCAUSAL AFFORDANCE: Commits the successful translation of raw strings to formal CURIEs into the Epistemic Ledger, physically preserving traceability and preventing 'Traceability Collapse'.\\n\\nEPISTEMIC BOUNDS: The `resolved_curies` dictionary mathematically locks arbitrary strings to strict W3C CURIE regex patterns (`^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$`). The alignment certainty is captured by the `grounding_confidence` tri-vector.\\n\\nMCP ROUTING TRIGGERS: Epistemic Provenance, Crosswalk Resolution, Grounding Receipt, Ontology Access Kit, CURIE\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"grounding_confidence\","]
#[doc = "    \"receipt_cid\","]
#[doc = "    \"resolved_curies\","]
#[doc = "    \"target_graph_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"grounding_confidence\": {"]
#[doc = "      \"description\": \"Quantifies the semantic alignment and epistemic conflict of the applied crosswalk.\","]
#[doc = "      \"$ref\": \"#/$defs/DempsterShaferBeliefVector\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"receipt_cid\": {"]
#[doc = "      \"title\": \"Receipt Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"resolved_curies\": {"]
#[doc = "      \"title\": \"Resolved Curies\","]
#[doc = "      \"description\": \"Strict dictionary mapping the original strings to formal W3C CURIEs.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"pattern\": \"^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"target_graph_cid\": {"]
#[doc = "      \"title\": \"Target Graph Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"crosswalk_resolution\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CrosswalkResolutionReceipt {
    pub event_cid: EventCid,
    #[doc = "Quantifies the semantic alignment and epistemic conflict of the applied crosswalk."]
    pub grounding_confidence: DempsterShaferBeliefVector,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    pub receipt_cid: ReceiptCid,
    #[doc = "Strict dictionary mapping the original strings to formal W3C CURIEs."]
    pub resolved_curies: ::std::collections::HashMap<
        ::std::string::String,
        CrosswalkResolutionReceiptResolvedCuriesValue,
    >,
    pub target_graph_cid: TargetGraphCid,
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl CrosswalkResolutionReceipt {
    pub fn builder() -> builder::CrosswalkResolutionReceipt {
        Default::default()
    }
}
#[doc = "`CrosswalkResolutionReceiptResolvedCuriesValue`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CrosswalkResolutionReceiptResolvedCuriesValue(::std::string::String);
impl ::std::ops::Deref for CrosswalkResolutionReceiptResolvedCuriesValue {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CrosswalkResolutionReceiptResolvedCuriesValue> for ::std::string::String {
    fn from(value: CrosswalkResolutionReceiptResolvedCuriesValue) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CrosswalkResolutionReceiptResolvedCuriesValue {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| {
                ::regress::Regex::new("^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$").unwrap()
            });
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CrosswalkResolutionReceiptResolvedCuriesValue {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String>
    for CrosswalkResolutionReceiptResolvedCuriesValue
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String>
    for CrosswalkResolutionReceiptResolvedCuriesValue
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CrosswalkResolutionReceiptResolvedCuriesValue {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The base64-encoded succinct cryptographic proof payload."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Cryptographic Blob\","]
#[doc = "  \"description\": \"The base64-encoded succinct cryptographic proof payload.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 5000000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CryptographicBlob(::std::string::String);
impl ::std::ops::Deref for CryptographicBlob {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CryptographicBlob> for ::std::string::String {
    fn from(value: CryptographicBlob) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CryptographicBlob {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 5000000usize {
            return Err("longer than 5000000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CryptographicBlob {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CryptographicBlob {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CryptographicBlob {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CryptographicBlob {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SHA-256 null-hash representing the skipped state to satisfy the Epistemic Ledger."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Cryptographic Null Hash\","]
#[doc = "  \"description\": \"The SHA-256 null-hash representing the skipped state to satisfy the Epistemic Ledger.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CryptographicNullHash(::std::string::String);
impl ::std::ops::Deref for CryptographicNullHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CryptographicNullHash> for ::std::string::String {
    fn from(value: CryptographicNullHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CryptographicNullHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CryptographicNullHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CryptographicNullHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CryptographicNullHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CryptographicNullHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The strictly formatted (Base64url/Hex/Multibase) signature or proof."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Cryptographic Payload\","]
#[doc = "  \"description\": \"The strictly formatted (Base64url/Hex/Multibase) signature or proof.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000,"]
#[doc = "  \"pattern\": \"^[A-Za-z0-9+/=_-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CryptographicPayload(::std::string::String);
impl ::std::ops::Deref for CryptographicPayload {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CryptographicPayload> for ::std::string::String {
    fn from(value: CryptographicPayload) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CryptographicPayload {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[A-Za-z0-9+/=_-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[A-Za-z0-9+/=_-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CryptographicPayload {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CryptographicPayload {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CryptographicPayload {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CryptographicPayload {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The base64-encoded cryptographic proof (e.g., ZK-SNARKs, zkVM receipts, or programmable trust attestations) proving the claims without revealing the private key."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Cryptographic Proof Blob\","]
#[doc = "  \"description\": \"The base64-encoded cryptographic proof (e.g., ZK-SNARKs, zkVM receipts, or programmable trust attestations) proving the claims without revealing the private key.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CryptographicProofBlob(::std::string::String);
impl ::std::ops::Deref for CryptographicProofBlob {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CryptographicProofBlob> for ::std::string::String {
    fn from(value: CryptographicProofBlob) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CryptographicProofBlob {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CryptographicProofBlob {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CryptographicProofBlob {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CryptographicProofBlob {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CryptographicProofBlob {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A foundational base class/mixin for all future deterministic nodes, enforcing Homotopy Type Theory (HoTT) principles where execution identity is indistinguishable from causal path equivalence.\n\nCAUSAL AFFORDANCE: Binds the execution artifact directly to the projection intent, severing execution if the hash chain to the stochastic origin is broken.\n\nEPISTEMIC BOUNDS: Enforces an immutable cryptographic link via `provenance_trace_cid` matching a strict CID regex pattern.\n\nMCP ROUTING TRIGGERS: Homotopy Type Theory, Cryptographic Provenance, Execution Causal Chain, Merkle-DAG Identity, Path Equivalence"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CryptographicProvenancePolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A foundational base class/mixin for all future deterministic nodes, enforcing Homotopy Type Theory (HoTT) principles where execution identity is indistinguishable from causal path equivalence.\\n\\nCAUSAL AFFORDANCE: Binds the execution artifact directly to the projection intent, severing execution if the hash chain to the stochastic origin is broken.\\n\\nEPISTEMIC BOUNDS: Enforces an immutable cryptographic link via `provenance_trace_cid` matching a strict CID regex pattern.\\n\\nMCP ROUTING TRIGGERS: Homotopy Type Theory, Cryptographic Provenance, Execution Causal Chain, Merkle-DAG Identity, Path Equivalence\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"properties\": {"]
#[doc = "    \"provenance_trace_cid\": {"]
#[doc = "      \"title\": \"Provenance Trace Cid\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CryptographicProvenancePolicy {
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub provenance_trace_cid: ::std::option::Option<::std::string::String>,
}
impl ::std::default::Default for CryptographicProvenancePolicy {
    fn default() -> Self {
        Self {
            provenance_trace_cid: Default::default(),
        }
    }
}
impl CryptographicProvenancePolicy {
    pub fn builder() -> builder::CryptographicProvenancePolicy {
        Default::default()
    }
}
#[doc = "A base64 string proving the cryptographic delegation."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Cryptographic Signature\","]
#[doc = "  \"description\": \"A base64 string proving the cryptographic delegation.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 10000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CryptographicSignature(::std::string::String);
impl ::std::ops::Deref for CryptographicSignature {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CryptographicSignature> for ::std::string::String {
    fn from(value: CryptographicSignature) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CryptographicSignature {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 10000usize {
            return Err("longer than 10000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CryptographicSignature {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CryptographicSignature {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CryptographicSignature {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CryptographicSignature {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: CrystallizationPolicy governs Systemic Memory Consolidation (analogous\nto Hebbian Learning). It is a mathematical threshold that determines exactly when noisy,\nhigh-entropy episodic logs are statistically proven enough to be promoted into permanent semantic axioms.\n\nCAUSAL AFFORDANCE: Instructs the swarm to execute Inductive Logic Programming. It authorizes the\norchestrator to collapse a massive subgraph of repetitive ObservationEvent nodes into a single,\ndense SemanticNodeState, drastically reducing future inference costs.\n\nEPISTEMIC BOUNDS: The aleatoric_entropy_threshold float (le=0.1) dictates the maximum statistical\nvariance allowed before compression is physically authorized. It mathematically mandates a sample\nsize of min_observations_required (ge=10) to prevent premature epistemic convergence.\n\nMCP ROUTING TRIGGERS: Hebbian Learning, Memory Consolidation, Inductive Logic Programming, Aleatoric Entropy, Knowledge Distillation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CrystallizationPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: CrystallizationPolicy governs Systemic Memory Consolidation (analogous\\nto Hebbian Learning). It is a mathematical threshold that determines exactly when noisy,\\nhigh-entropy episodic logs are statistically proven enough to be promoted into permanent semantic axioms.\\n\\nCAUSAL AFFORDANCE: Instructs the swarm to execute Inductive Logic Programming. It authorizes the\\norchestrator to collapse a massive subgraph of repetitive ObservationEvent nodes into a single,\\ndense SemanticNodeState, drastically reducing future inference costs.\\n\\nEPISTEMIC BOUNDS: The aleatoric_entropy_threshold float (le=0.1) dictates the maximum statistical\\nvariance allowed before compression is physically authorized. It mathematically mandates a sample\\nsize of min_observations_required (ge=10) to prevent premature epistemic convergence.\\n\\nMCP ROUTING TRIGGERS: Hebbian Learning, Memory Consolidation, Inductive Logic Programming, Aleatoric Entropy, Knowledge Distillation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"aleatoric_entropy_threshold\","]
#[doc = "    \"min_observations_required\","]
#[doc = "    \"target_cognitive_tier\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"aleatoric_entropy_threshold\": {"]
#[doc = "      \"title\": \"Aleatoric Entropy Threshold\","]
#[doc = "      \"description\": \"The entropy variance must fall below this mathematical threshold to prove absolute certainty before compression is authorized.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 0.1"]
#[doc = "    },"]
#[doc = "    \"min_observations_required\": {"]
#[doc = "      \"title\": \"Min Observations Required\","]
#[doc = "      \"description\": \"The minimum number of episodic logs needed to statistically prove a crystallized rule.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 10.0"]
#[doc = "    },"]
#[doc = "    \"target_cognitive_tier\": {"]
#[doc = "      \"title\": \"Target Cognitive Tier\","]
#[doc = "      \"description\": \"The destination tier where the compressed rule will be stored.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"semantic\","]
#[doc = "        \"working\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CrystallizationPolicy {
    #[doc = "The entropy variance must fall below this mathematical threshold to prove absolute certainty before compression is authorized."]
    pub aleatoric_entropy_threshold: f64,
    #[doc = "The minimum number of episodic logs needed to statistically prove a crystallized rule."]
    pub min_observations_required: i64,
    #[doc = "The destination tier where the compressed rule will be stored."]
    pub target_cognitive_tier: TargetCognitiveTier,
}
impl CrystallizationPolicy {
    pub fn builder() -> builder::CrystallizationPolicy {
        Default::default()
    }
}
#[doc = "`CrystallizedLedgerCidsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CrystallizedLedgerCidsItem(::std::string::String);
impl ::std::ops::Deref for CrystallizedLedgerCidsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CrystallizedLedgerCidsItem> for ::std::string::String {
    fn from(value: CrystallizedLedgerCidsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CrystallizedLedgerCidsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CrystallizedLedgerCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CrystallizedLedgerCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CrystallizedLedgerCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CrystallizedLedgerCidsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The resulting permanent W3C DID / The globally unique decentralized identifier (DID) anchoring the newly minted knowledge node."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Crystallized Semantic Node Cid\","]
#[doc = "  \"description\": \"The resulting permanent W3C DID / The globally unique decentralized identifier (DID) anchoring the newly minted knowledge node.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CrystallizedSemanticNodeCid(::std::string::String);
impl ::std::ops::Deref for CrystallizedSemanticNodeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CrystallizedSemanticNodeCid> for ::std::string::String {
    fn from(value: CrystallizedSemanticNodeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CrystallizedSemanticNodeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CrystallizedSemanticNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CrystallizedSemanticNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CrystallizedSemanticNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CrystallizedSemanticNodeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Spatial Execution Bounds where the agent interacts."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Current Url\","]
#[doc = "  \"description\": \"Spatial Execution Bounds where the agent interacts.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CurrentUrl(::std::string::String);
impl ::std::ops::Deref for CurrentUrl {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CurrentUrl> for ::std::string::String {
    fn from(value: CurrentUrl) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CurrentUrl {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CurrentUrl {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CurrentUrl {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CurrentUrl {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CurrentUrl {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Unique CID for this training epoch release."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Curriculum Cid\","]
#[doc = "  \"description\": \"Unique CID for this training epoch release.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CurriculumCid(::std::string::String);
impl ::std::ops::Deref for CurriculumCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CurriculumCid> for ::std::string::String {
    fn from(value: CurriculumCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CurriculumCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CurriculumCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CurriculumCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CurriculumCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CurriculumCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The mathematical spline geometry used to interpolate the space between vertices."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Curve Class\","]
#[doc = "  \"description\": \"The mathematical spline geometry used to interpolate the space between vertices.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"straight\","]
#[doc = "    \"bezier\","]
#[doc = "    \"catmull_rom\","]
#[doc = "    \"riemannian_geodesic\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum CurveClass {
    #[serde(rename = "straight")]
    Straight,
    #[serde(rename = "bezier")]
    Bezier,
    #[serde(rename = "catmull_rom")]
    CatmullRom,
    #[serde(rename = "riemannian_geodesic")]
    RiemannianGeodesic,
}
impl ::std::fmt::Display for CurveClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Straight => f.write_str("straight"),
            Self::Bezier => f.write_str("bezier"),
            Self::CatmullRom => f.write_str("catmull_rom"),
            Self::RiemannianGeodesic => f.write_str("riemannian_geodesic"),
        }
    }
}
impl ::std::str::FromStr for CurveClass {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "straight" => Ok(Self::Straight),
            "bezier" => Ok(Self::Bezier),
            "catmull_rom" => Ok(Self::CatmullRom),
            "riemannian_geodesic" => Ok(Self::RiemannianGeodesic),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for CurveClass {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CurveClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CurveClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "Unique identifier for this chain-of-custody entry."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Custody Cid\","]
#[doc = "  \"description\": \"Unique identifier for this chain-of-custody entry.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct CustodyCid(::std::string::String);
impl ::std::ops::Deref for CustodyCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<CustodyCid> for ::std::string::String {
    fn from(value: CustodyCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for CustodyCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for CustodyCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for CustodyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for CustodyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for CustodyCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the successful execution of an SemanticFlowPolicy redaction on the Merkle-DAG. Enforced as fully immutable via `ConfigDict(frozen=True)`.\n\nCAUSAL AFFORDANCE: Unlocks strict audit compliance by mathematically mapping the optional toxic `pre_redaction_hash` to the mandatory safe `post_redaction_hash`, proving non-repudiation via the `applied_policy_cid`.\n\nEPISTEMIC BOUNDS: Temporal geometry strictly clamped to `redaction_timestamp_unix_nano` (`ge=0, le=253402300799000000000`). Both hashes are locked to immutable SHA-256 hexadecimal bounds (`^[a-f0-9]{64}$`). `pre_redaction_hash` is optional (`default=None`) for isolated audit vaults.\n\nMCP ROUTING TRIGGERS: Chain of Custody, Cryptographic Provenance, Merkle-DAG Audit, Non-Repudiation, Data Isomorphism"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CustodyReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the successful execution of an SemanticFlowPolicy redaction on the Merkle-DAG. Enforced as fully immutable via `ConfigDict(frozen=True)`.\\n\\nCAUSAL AFFORDANCE: Unlocks strict audit compliance by mathematically mapping the optional toxic `pre_redaction_hash` to the mandatory safe `post_redaction_hash`, proving non-repudiation via the `applied_policy_cid`.\\n\\nEPISTEMIC BOUNDS: Temporal geometry strictly clamped to `redaction_timestamp_unix_nano` (`ge=0, le=253402300799000000000`). Both hashes are locked to immutable SHA-256 hexadecimal bounds (`^[a-f0-9]{64}$`). `pre_redaction_hash` is optional (`default=None`) for isolated audit vaults.\\n\\nMCP ROUTING TRIGGERS: Chain of Custody, Cryptographic Provenance, Merkle-DAG Audit, Non-Repudiation, Data Isomorphism\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"applied_policy_cid\","]
#[doc = "    \"custody_cid\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"post_redaction_hash\","]
#[doc = "    \"redaction_timestamp_unix_nano\","]
#[doc = "    \"source_node_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"applied_policy_cid\": {"]
#[doc = "      \"title\": \"Applied Policy Cid\","]
#[doc = "      \"description\": \"The deterministic capability pointer representing the SemanticFlowPolicy successfully applied.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"custody_cid\": {"]
#[doc = "      \"title\": \"Custody Cid\","]
#[doc = "      \"description\": \"Unique identifier for this chain-of-custody entry.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"post_redaction_hash\": {"]
#[doc = "      \"title\": \"Post Redaction Hash\","]
#[doc = "      \"description\": \"The definitive SHA-256 hash of the sanitized, mathematically clean payload.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"pre_redaction_hash\": {"]
#[doc = "      \"title\": \"Pre Redaction Hash\","]
#[doc = "      \"description\": \"Optional SHA-256 hash of the raw toxic data for isolated audit vaults.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"redaction_timestamp_unix_nano\": {"]
#[doc = "      \"title\": \"Redaction Timestamp Unix Nano\","]
#[doc = "      \"description\": \"The precise temporal point the redaction was completed.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 2.5340230079900002e+20,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"source_node_cid\": {"]
#[doc = "      \"title\": \"Source Node Cid\","]
#[doc = "      \"description\": \"The execution node that emitted the original payload.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"custody_receipt\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CustodyReceipt {
    #[doc = "The deterministic capability pointer representing the SemanticFlowPolicy successfully applied."]
    pub applied_policy_cid: AppliedPolicyCid,
    #[doc = "Unique identifier for this chain-of-custody entry."]
    pub custody_cid: CustodyCid,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The definitive SHA-256 hash of the sanitized, mathematically clean payload."]
    pub post_redaction_hash: PostRedactionHash,
    #[doc = "Optional SHA-256 hash of the raw toxic data for isolated audit vaults."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub pre_redaction_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The precise temporal point the redaction was completed."]
    pub redaction_timestamp_unix_nano: i64,
    #[doc = "The execution node that emitted the original payload."]
    pub source_node_cid: SourceNodeCid,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl CustodyReceipt {
    pub fn builder() -> builder::CustodyReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents a self-referential or cyclic Markov edge for deep recursive execution, utilizing Thermodynamic Discounting to prevent infinite loops. As a ...Profile suffix, this is a declarative, frozen snapshot of a routing geometry.\n\nCAUSAL AFFORDANCE: Authorizes recursive tool calls or non-monotonic backward execution. The orchestrator must apply the Bellman `discount_factor` to the compute budget during each traversal loop.\n\nEPISTEMIC BOUNDS: Structural repetition is checked by applying a geometric decay factor (`discount_factor` ge=0.0, le=1.0). An `@model_validator` mathematically prevents un-haltable infinite recursion if the `discount_factor` equals 1.0 without a strict `max_causal_depth` explicitly defined in the `terminal_condition`.\n\nMCP ROUTING TRIGGERS: Markov Decision Process, Cyclic Edge, Bellman Equation, Thermodynamic Discounting, Recursive Traversal"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"CyclicEdgeProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents a self-referential or cyclic Markov edge for deep recursive execution, utilizing Thermodynamic Discounting to prevent infinite loops. As a ...Profile suffix, this is a declarative, frozen snapshot of a routing geometry.\\n\\nCAUSAL AFFORDANCE: Authorizes recursive tool calls or non-monotonic backward execution. The orchestrator must apply the Bellman `discount_factor` to the compute budget during each traversal loop.\\n\\nEPISTEMIC BOUNDS: Structural repetition is checked by applying a geometric decay factor (`discount_factor` ge=0.0, le=1.0). An `@model_validator` mathematically prevents un-haltable infinite recursion if the `discount_factor` equals 1.0 without a strict `max_causal_depth` explicitly defined in the `terminal_condition`.\\n\\nMCP ROUTING TRIGGERS: Markov Decision Process, Cyclic Edge, Bellman Equation, Thermodynamic Discounting, Recursive Traversal\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"compute_weight_magnitude\","]
#[doc = "    \"discount_factor\","]
#[doc = "    \"probability_weight\","]
#[doc = "    \"terminal_condition\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"compute_weight_magnitude\": {"]
#[doc = "      \"title\": \"Compute Weight Magnitude\","]
#[doc = "      \"description\": \"The thermodynamic cost to traverse this edge.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"discount_factor\": {"]
#[doc = "      \"title\": \"Discount Factor\","]
#[doc = "      \"description\": \"The Bellman Equation gamma applied to the budget on each cyclic loop.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"eval_strategy\": {"]
#[doc = "      \"title\": \"Eval Strategy\","]
#[doc = "      \"description\": \"The evaluation strategy: 'strict' pre-fetches schemas, 'lazy' uses Coalgebraic Thunking to prevent State-Space Explosion.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"strict\","]
#[doc = "        \"lazy\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"payload_mappings\": {"]
#[doc = "      \"title\": \"Payload Mappings\","]
#[doc = "      \"description\": \"The algebraic translation matrix mapping the source's Covariant output to the Contravariant input.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EdgeMappingContract\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"probability_weight\": {"]
#[doc = "      \"title\": \"Probability Weight\","]
#[doc = "      \"description\": \"The stochastic heuristic preference of this path.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"target_intent\": {"]
#[doc = "      \"description\": \"Dynamic discovery intent for bridging nodes.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticDiscoveryIntent\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"title\": \"Target Node Cid\","]
#[doc = "      \"description\": \"The coinductive pointer to the destination capability.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"terminal_condition\": {"]
#[doc = "      \"description\": \"The mandatory structural conditions guaranteed to eventually halt traversal.\","]
#[doc = "      \"$ref\": \"#/$defs/TerminalConditionContract\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for a cyclic edge.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"cyclic\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct CyclicEdgeProfile {
    #[doc = "The thermodynamic cost to traverse this edge."]
    pub compute_weight_magnitude: u64,
    #[doc = "The Bellman Equation gamma applied to the budget on each cyclic loop."]
    pub discount_factor: f64,
    #[doc = "The evaluation strategy: 'strict' pre-fetches schemas, 'lazy' uses Coalgebraic Thunking to prevent State-Space Explosion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub eval_strategy: ::std::option::Option<EvalStrategy>,
    #[doc = "The algebraic translation matrix mapping the source's Covariant output to the Contravariant input."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub payload_mappings: ::std::vec::Vec<EdgeMappingContract>,
    #[doc = "The stochastic heuristic preference of this path."]
    pub probability_weight: f64,
    #[doc = "Dynamic discovery intent for bridging nodes."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub target_intent: ::std::option::Option<SemanticDiscoveryIntent>,
    #[doc = "The coinductive pointer to the destination capability."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub target_node_cid: ::std::option::Option<::std::string::String>,
    #[doc = "The mandatory structural conditions guaranteed to eventually halt traversal."]
    pub terminal_condition: TerminalConditionContract,
    #[doc = "Discriminator type for a cyclic edge."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl CyclicEdgeProfile {
    pub fn builder() -> builder::CyclicEdgeProfile {
        Default::default()
    }
}
#[doc = "The cryptographic nonce tightly binding this signature to the specific Merkle-DAG node."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Dag Node Nonce\","]
#[doc = "  \"description\": \"The cryptographic nonce tightly binding this signature to the specific Merkle-DAG node.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DagNodeNonce(::std::string::String);
impl ::std::ops::Deref for DagNodeNonce {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DagNodeNonce> for ::std::string::String {
    fn from(value: DagNodeNonce) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DagNodeNonce {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DagNodeNonce {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DagNodeNonce {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DagNodeNonce {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DagNodeNonce {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes a Directed Acyclic Graph (DAG) for deterministic, chronologically ordered task execution, guaranteeing strict topological sorting of operations.\n\nCAUSAL AFFORDANCE: Forces the orchestrator to evaluate causal edges and execute rigorous DFS loop-detection to verify the `allow_cycles` constraint before initiating kinetic node compute. Backpressure governs edge flow control.\n\nEPISTEMIC BOUNDS: Algorithmic complexity is mathematically bound by `max_depth` (`ge=1, le=18446744073709551615`) and `max_fan_out` (`ge=1, le=18446744073709551615`). The `@model_validator` actively measures these constraints during traversal. Edges are deterministically sorted. Physical execution safety is delegated to runtime Admission Controllers.\n\nMCP ROUTING TRIGGERS: Directed Acyclic Graph, Kahn's Algorithm, Topological Sort, Causal Edge, Algorithmic Complexity"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DAGTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes a Directed Acyclic Graph (DAG) for deterministic, chronologically ordered task execution, guaranteeing strict topological sorting of operations.\\n\\nCAUSAL AFFORDANCE: Forces the orchestrator to evaluate causal edges and execute rigorous DFS loop-detection to verify the `allow_cycles` constraint before initiating kinetic node compute. Backpressure governs edge flow control.\\n\\nEPISTEMIC BOUNDS: Algorithmic complexity is mathematically bound by `max_depth` (`ge=1, le=18446744073709551615`) and `max_fan_out` (`ge=1, le=18446744073709551615`). The `@model_validator` actively measures these constraints during traversal. Edges are deterministically sorted. Physical execution safety is delegated to runtime Admission Controllers.\\n\\nMCP ROUTING TRIGGERS: Directed Acyclic Graph, Kahn's Algorithm, Topological Sort, Causal Edge, Algorithmic Complexity\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_depth\","]
#[doc = "    \"max_fan_out\","]
#[doc = "    \"nodes\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"allow_cycles\": {"]
#[doc = "      \"title\": \"Allow Cycles\","]
#[doc = "      \"description\": \"Configuration indicating if cycles are allowed during validation.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"backpressure\": {"]
#[doc = "      \"description\": \"Declarative backpressure constraints for the graph edges.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/BackpressurePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"edges\": {"]
#[doc = "      \"title\": \"Edges\","]
#[doc = "      \"description\": \"The strict, topologically bounded matrix of directed causal edges.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"array\","]
#[doc = "        \"maxItems\": 2,"]
#[doc = "        \"minItems\": 2,"]
#[doc = "        \"prefixItems\": ["]
#[doc = "          {"]
#[doc = "            \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "          }"]
#[doc = "        ]"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"epistemic_enforcement\": {"]
#[doc = "      \"description\": \"Ties the topology to the Truth Maintenance layer.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TruthMaintenancePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this topology's configuration.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"lifecycle_phase\": {"]
#[doc = "      \"title\": \"Lifecycle Phase\","]
#[doc = "      \"description\": \"The execution phase of the graph. 'draft' allows incomplete structural state.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"draft\","]
#[doc = "        \"live\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_depth\": {"]
#[doc = "      \"title\": \"Max Depth\","]
#[doc = "      \"description\": \"The maximum recursive depth of the routing DAG.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"max_fan_out\": {"]
#[doc = "      \"title\": \"Max Fan Out\","]
#[doc = "      \"description\": \"The maximum number of parallel child nodes.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"nodes\": {"]
#[doc = "      \"title\": \"Nodes\","]
#[doc = "      \"description\": \"Flat registry of all nodes in this topology.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyNodeProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"observability\": {"]
#[doc = "      \"description\": \"The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ObservabilityLODPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"semantic_flow\": {"]
#[doc = "      \"description\": \"The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticFlowPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"shared_state_contract\": {"]
#[doc = "      \"description\": \"The schema-on-write contract governing the internal state of this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StateContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"speculative_boundaries\": {"]
#[doc = "      \"title\": \"Speculative Boundaries\","]
#[doc = "      \"description\": \"Topological bounds for non-monotonic test-time compute branching.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/SpeculativeExecutionPolicy\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a DAG topology.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"dag\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false,"]
#[doc = "  \"x-domain-cluster\": \"cognitive_routing\","]
#[doc = "  \"x-synergistic-classes\": ["]
#[doc = "    \"TaxonomicRoutingPolicy\","]
#[doc = "    \"CognitiveAgentNodeProfile\","]
#[doc = "    \"SemanticRelationalVectorState\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DagTopologyManifest {
    #[doc = "Configuration indicating if cycles are allowed during validation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub allow_cycles: ::std::option::Option<bool>,
    #[doc = "The AI's declarative rationale for selecting this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "Declarative backpressure constraints for the graph edges."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub backpressure: ::std::option::Option<BackpressurePolicy>,
    #[doc = "The strict, topologically bounded matrix of directed causal edges."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub edges: ::std::vec::Vec<[::serde_json::Value; 2usize]>,
    #[doc = "Ties the topology to the Truth Maintenance layer."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_enforcement: ::std::option::Option<TruthMaintenancePolicy>,
    #[doc = "Cryptographic/audit justification for this topology's configuration."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The execution phase of the graph. 'draft' allows incomplete structural state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub lifecycle_phase: ::std::option::Option<LifecyclePhase>,
    #[doc = "The maximum recursive depth of the routing DAG."]
    pub max_depth: ::std::num::NonZeroU64,
    #[doc = "The maximum number of parallel child nodes."]
    pub max_fan_out: ::std::num::NonZeroU64,
    #[doc = "Flat registry of all nodes in this topology."]
    pub nodes: ::std::collections::HashMap<::std::string::String, AnyNodeProfile>,
    #[doc = "The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub observability: ::std::option::Option<ObservabilityLodPolicy>,
    #[doc = "The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_flow: ::std::option::Option<SemanticFlowPolicy>,
    #[doc = "The schema-on-write contract governing the internal state of this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub shared_state_contract: ::std::option::Option<StateContract>,
    #[doc = "Topological bounds for non-monotonic test-time compute branching."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub speculative_boundaries: ::std::vec::Vec<SpeculativeExecutionPolicy>,
    #[doc = "Discriminator for a DAG topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl DagTopologyManifest {
    pub fn builder() -> builder::DagTopologyManifest {
        Default::default()
    }
}
#[doc = "`DeadlockedClaimsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DeadlockedClaimsItem(::std::string::String);
impl ::std::ops::Deref for DeadlockedClaimsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DeadlockedClaimsItem> for ::std::string::String {
    fn from(value: DeadlockedClaimsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DeadlockedClaimsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DeadlockedClaimsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DeadlockedClaimsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DeadlockedClaimsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DeadlockedClaimsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The trigonometric or algebraic function governing the attenuation curve."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Decay Function\","]
#[doc = "  \"description\": \"The trigonometric or algebraic function governing the attenuation curve.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"linear\","]
#[doc = "    \"exponential\","]
#[doc = "    \"cosine_annealing\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum DecayFunction {
    #[serde(rename = "linear")]
    Linear,
    #[serde(rename = "exponential")]
    Exponential,
    #[serde(rename = "cosine_annealing")]
    CosineAnnealing,
}
impl ::std::fmt::Display for DecayFunction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Linear => f.write_str("linear"),
            Self::Exponential => f.write_str("exponential"),
            Self::CosineAnnealing => f.write_str("cosine_annealing"),
        }
    }
}
impl ::std::str::FromStr for DecayFunction {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "linear" => Ok(Self::Linear),
            "exponential" => Ok(Self::Exponential),
            "cosine_annealing" => Ok(Self::CosineAnnealing),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for DecayFunction {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DecayFunction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DecayFunction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes the binary attack relation in Dung's Abstract Argumentation Framework. As an ...Event suffix, this is an append-only, cryptographically frozen historical fact on the Merkle-DAG.\n\nCAUSAL AFFORDANCE: Projects an undercutting or rebutting defeater from a source claim against a target claim. If mathematically validated, it physically triggers a DefeasibleCascadeEvent to sever all downstream nodes relying on the target.\n\nEPISTEMIC BOUNDS: Strictly bounds the attack geometry using AttackVectorProfile enums (`Literal[\"rebuttal\", \"undercutter\", \"underminer\"]`). Source and target mappings are locked to 128-character CIDs, preventing unbounded graph traversals.\n\nMCP ROUTING TRIGGERS: Undercutting Defeater, Dialectical Edge, Truth Maintenance System, Bipartite Mapping, Non-Monotonic Retraction"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DefeasibleAttackEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes the binary attack relation in Dung's Abstract Argumentation Framework. As an ...Event suffix, this is an append-only, cryptographically frozen historical fact on the Merkle-DAG.\\n\\nCAUSAL AFFORDANCE: Projects an undercutting or rebutting defeater from a source claim against a target claim. If mathematically validated, it physically triggers a DefeasibleCascadeEvent to sever all downstream nodes relying on the target.\\n\\nEPISTEMIC BOUNDS: Strictly bounds the attack geometry using AttackVectorProfile enums (`Literal[\\\"rebuttal\\\", \\\"undercutter\\\", \\\"underminer\\\"]`). Source and target mappings are locked to 128-character CIDs, preventing unbounded graph traversals.\\n\\nMCP ROUTING TRIGGERS: Undercutting Defeater, Dialectical Edge, Truth Maintenance System, Bipartite Mapping, Non-Monotonic Retraction\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"attack_cid\","]
#[doc = "    \"attack_vector\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"source_claim_cid\","]
#[doc = "    \"target_claim_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"attack_cid\": {"]
#[doc = "      \"title\": \"Attack Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this directed attack edge.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"attack_vector\": {"]
#[doc = "      \"description\": \"Geometric matrices of undercutting defeaters.\","]
#[doc = "      \"$ref\": \"#/$defs/AttackVectorProfile\""]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"source_claim_cid\": {"]
#[doc = "      \"title\": \"Source Claim Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the claim mounting the attack.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_claim_cid\": {"]
#[doc = "      \"title\": \"Target Claim Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the claim being attacked.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"defeasible_attack\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DefeasibleAttackEvent {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this directed attack edge."]
    pub attack_cid: AttackCid,
    #[doc = "Geometric matrices of undercutting defeaters."]
    pub attack_vector: AttackVectorProfile,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the claim mounting the attack."]
    pub source_claim_cid: SourceClaimCid,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the claim being attacked."]
    pub target_claim_cid: TargetClaimCid,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl DefeasibleAttackEvent {
    pub fn builder() -> builder::DefeasibleAttackEvent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Executes Jon Doyle's Truth Maintenance System (TMS) protocol. As an ...Event suffix, this is an append-only coordinate on the Merkle-DAG representing the active propagation of belief retraction.\n\nCAUSAL AFFORDANCE: Applies a Pearlian do-operator to mathematically zero-out the probability mass of the `quarantined_event_cids` subgraph, physically halting all execution branches dependent on the `root_falsified_event_cid` to prevent epistemic contagion.\n\nEPISTEMIC BOUNDS: The Shannon Entropy reduction across edges is strictly clamped by `propagated_decay_factor` (`ge=0.0, le=1.0`). Deterministic alignment is guaranteed by a `@model_validator` that physically sorts the `quarantined_event_cids` array. A second validator mathematically rejects root events appearing in quarantine (`reject_root_in_quarantine`).\n\nMCP ROUTING TRIGGERS: Jon Doyle TMS, Epistemic Contagion, Belief Retraction, Shannon Entropy Penalty, Graph Quarantine"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DefeasibleCascadeEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Executes Jon Doyle's Truth Maintenance System (TMS) protocol. As an ...Event suffix, this is an append-only coordinate on the Merkle-DAG representing the active propagation of belief retraction.\\n\\nCAUSAL AFFORDANCE: Applies a Pearlian do-operator to mathematically zero-out the probability mass of the `quarantined_event_cids` subgraph, physically halting all execution branches dependent on the `root_falsified_event_cid` to prevent epistemic contagion.\\n\\nEPISTEMIC BOUNDS: The Shannon Entropy reduction across edges is strictly clamped by `propagated_decay_factor` (`ge=0.0, le=1.0`). Deterministic alignment is guaranteed by a `@model_validator` that physically sorts the `quarantined_event_cids` array. A second validator mathematically rejects root events appearing in quarantine (`reject_root_in_quarantine`).\\n\\nMCP ROUTING TRIGGERS: Jon Doyle TMS, Epistemic Contagion, Belief Retraction, Shannon Entropy Penalty, Graph Quarantine\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"cascade_cid\","]
#[doc = "    \"propagated_decay_factor\","]
#[doc = "    \"quarantined_event_cids\","]
#[doc = "    \"root_falsified_event_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"cascade_cid\": {"]
#[doc = "      \"title\": \"Cascade Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this automated truth maintenance operation.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"cross_boundary_quarantine_issued\": {"]
#[doc = "      \"title\": \"Cross Boundary Quarantine Issued\","]
#[doc = "      \"description\": \"Cryptographic proof that this cascade was broadcast to the Swarm to halt epistemic contagion.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"propagated_decay_factor\": {"]
#[doc = "      \"title\": \"Propagated Decay Factor\","]
#[doc = "      \"description\": \"The calculated Entropy Penalty applied to this specific subgraph.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"quarantined_event_cids\": {"]
#[doc = "      \"title\": \"Quarantined Event Cids\","]
#[doc = "      \"description\": \"The strict array of downstream event Content Identifiers (CIDs) isolated and muted by this cascade to prevent Epistemic Contagion.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1"]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"root_falsified_event_cid\": {"]
#[doc = "      \"title\": \"Root Falsified Event Cid\","]
#[doc = "      \"description\": \"The source BeliefMutationEvent or HypothesisGenerationEvent Content Identifier (CID) that collapsed and triggered this cascade.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"temporal_blast_radius\": {"]
#[doc = "      \"title\": \"Temporal Blast Radius\","]
#[doc = "      \"description\": \"Limits the cascade to sever downstream nodes whose valid_from falls within this exact window.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"array\","]
#[doc = "          \"maxItems\": 2,"]
#[doc = "          \"minItems\": 2,"]
#[doc = "          \"prefixItems\": ["]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            }"]
#[doc = "          ]"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DefeasibleCascadeEvent {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this automated truth maintenance operation."]
    pub cascade_cid: CascadeCid,
    #[doc = "Cryptographic proof that this cascade was broadcast to the Swarm to halt epistemic contagion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub cross_boundary_quarantine_issued: ::std::option::Option<bool>,
    #[doc = "The calculated Entropy Penalty applied to this specific subgraph."]
    pub propagated_decay_factor: f64,
    #[doc = "The strict array of downstream event Content Identifiers (CIDs) isolated and muted by this cascade to prevent Epistemic Contagion."]
    pub quarantined_event_cids: ::std::vec::Vec<QuarantinedEventCidsItem>,
    #[doc = "The source BeliefMutationEvent or HypothesisGenerationEvent Content Identifier (CID) that collapsed and triggered this cascade."]
    pub root_falsified_event_cid: RootFalsifiedEventCid,
    #[doc = "Limits the cascade to sever downstream nodes whose valid_from falls within this exact window."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub temporal_blast_radius: ::std::option::Option<[::serde_json::Value; 2usize]>,
}
impl DefeasibleCascadeEvent {
    pub fn builder() -> builder::DefeasibleCascadeEvent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Macaroons and Decentralized Identifiers (DIDs) to construct a verifiable delegation chain of authority from a human principal to an autonomous agent.\n\nCAUSAL AFFORDANCE: Empowers the `delegate_agent_did` to invoke the explicitly whitelisted `allowed_tool_cids`, acting as a cryptographic proxy for the `principal_did`. The `cryptographic_signature` proves the delegation chain.\n\nEPISTEMIC BOUNDS: The delegation's temporal geometry is physically bounded by `expiration_timestamp` (`ge=0.0, le=253402300799.0`). The `capability_cid` is a 128-char CID anchor. The `allowed_tool_cids` array is deterministically sorted by `@model_validator` for RFC 8785 canonical hashing.\n\nMCP ROUTING TRIGGERS: Macaroons, Delegation Chain, Public Key Infrastructure, Object Capability Model, Decentralized Identifiers"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DelegatedCapabilityManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Macaroons and Decentralized Identifiers (DIDs) to construct a verifiable delegation chain of authority from a human principal to an autonomous agent.\\n\\nCAUSAL AFFORDANCE: Empowers the `delegate_agent_did` to invoke the explicitly whitelisted `allowed_tool_cids`, acting as a cryptographic proxy for the `principal_did`. The `cryptographic_signature` proves the delegation chain.\\n\\nEPISTEMIC BOUNDS: The delegation's temporal geometry is physically bounded by `expiration_timestamp` (`ge=0.0, le=253402300799.0`). The `capability_cid` is a 128-char CID anchor. The `allowed_tool_cids` array is deterministically sorted by `@model_validator` for RFC 8785 canonical hashing.\\n\\nMCP ROUTING TRIGGERS: Macaroons, Delegation Chain, Public Key Infrastructure, Object Capability Model, Decentralized Identifiers\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"allowed_tool_cids\","]
#[doc = "    \"capability_cid\","]
#[doc = "    \"cryptographic_signature\","]
#[doc = "    \"delegate_agent_did\","]
#[doc = "    \"expiration_timestamp\","]
#[doc = "    \"principal_did\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"allowed_tool_cids\": {"]
#[doc = "      \"title\": \"Allowed Tool Cids\","]
#[doc = "      \"description\": \"The strictly bounded set of ToolIdentifiers this delegation permits.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/CapabilityPointerState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"capability_cid\": {"]
#[doc = "      \"title\": \"Capability Cid\","]
#[doc = "      \"description\": \"A string CID for the delegated capability.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"cryptographic_signature\": {"]
#[doc = "      \"title\": \"Cryptographic Signature\","]
#[doc = "      \"description\": \"A base64 string proving the cryptographic delegation.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 10000"]
#[doc = "    },"]
#[doc = "    \"delegate_agent_did\": {"]
#[doc = "      \"description\": \"The DID representing the autonomous actor receiving authority.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"expiration_timestamp\": {"]
#[doc = "      \"title\": \"Expiration Timestamp\","]
#[doc = "      \"description\": \"A float bounding the temporal lifecycle.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"principal_did\": {"]
#[doc = "      \"description\": \"The DID representing the human or parent delegating authority.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DelegatedCapabilityManifest {
    #[doc = "The strictly bounded set of ToolIdentifiers this delegation permits."]
    pub allowed_tool_cids: ::std::vec::Vec<CapabilityPointerState>,
    #[doc = "A string CID for the delegated capability."]
    pub capability_cid: CapabilityCid,
    #[doc = "A base64 string proving the cryptographic delegation."]
    pub cryptographic_signature: CryptographicSignature,
    #[doc = "The DID representing the autonomous actor receiving authority."]
    pub delegate_agent_did: NodeCidState,
    #[doc = "A float bounding the temporal lifecycle."]
    pub expiration_timestamp: f64,
    #[doc = "The DID representing the human or parent delegating authority."]
    pub principal_did: NodeCidState,
}
impl DelegatedCapabilityManifest {
    pub fn builder() -> builder::DelegatedCapabilityManifest {
        Default::default()
    }
}
#[doc = "The unconstrained Chain-of-Thought reasoning trace generated by the Frontier model with the Sovereign LLM Proxy's XGrammar AOT FSM bitmask DISABLED. This field captures the full computational runway — scratchpad blocks, intermediate calculations, and heuristic explorations — that the model requires to maximize logical accuracy without suffering the Format Restriction Penalty."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Deliberation Trace\","]
#[doc = "  \"description\": \"The unconstrained Chain-of-Thought reasoning trace generated by the Frontier model with the Sovereign LLM Proxy's XGrammar AOT FSM bitmask DISABLED. This field captures the full computational runway — scratchpad blocks, intermediate calculations, and heuristic explorations — that the model requires to maximize logical accuracy without suffering the Format Restriction Penalty.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DeliberationTrace(::std::string::String);
impl ::std::ops::Deref for DeliberationTrace {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DeliberationTrace> for ::std::string::String {
    fn from(value: DeliberationTrace) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DeliberationTrace {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DeliberationTrace {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DeliberationTrace {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DeliberationTrace {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DeliberationTrace {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A Generic two-stage generation wrapper that neutralizes the Format Restriction Penalty (Semantic Tax) during Constrained Decoding. The Sovereign LLM Proxy's XGrammar AOT FSM bitmask MUST be physically toggled between the two fields: DISABLED for `deliberation_trace`, then ENABLED for `payload`. This class models the architectural pattern documented in the Decoupled Reasoning and Formatting specification.\n\nCAUSAL AFFORDANCE: Unlocks the two-stage Thinker-Parser pipeline by providing a single serializable envelope that carries both the unconstrained Chain-of-Thought reasoning trace and the deterministic, schema-compliant structured payload. Enables the Claw Swarm to reason freely while the deterministic Forge receives only validated structural output.\n\nEPISTEMIC BOUNDS: The `deliberation_trace` has a maximum length of 100,000 characters to prevent context window exhaustion. The `payload` of type `T` is strictly validated against the target `CoreasonBaseState` subclass schema at deserialization time. The Generic parameter `T` must be a `CoreasonBaseState` descendant to guarantee RFC 8785 canonicalization.\n\nMCP ROUTING TRIGGERS: Semantic Tax Neutralization, Decoupled Reasoning Pipeline, XGrammar FSM Toggle, Constrained Decoding, Two-Stage Generation, Deliberation Envelope"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DeliberativeEnvelope\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A Generic two-stage generation wrapper that neutralizes the Format Restriction Penalty (Semantic Tax) during Constrained Decoding. The Sovereign LLM Proxy's XGrammar AOT FSM bitmask MUST be physically toggled between the two fields: DISABLED for `deliberation_trace`, then ENABLED for `payload`. This class models the architectural pattern documented in the Decoupled Reasoning and Formatting specification.\\n\\nCAUSAL AFFORDANCE: Unlocks the two-stage Thinker-Parser pipeline by providing a single serializable envelope that carries both the unconstrained Chain-of-Thought reasoning trace and the deterministic, schema-compliant structured payload. Enables the Claw Swarm to reason freely while the deterministic Forge receives only validated structural output.\\n\\nEPISTEMIC BOUNDS: The `deliberation_trace` has a maximum length of 100,000 characters to prevent context window exhaustion. The `payload` of type `T` is strictly validated against the target `CoreasonBaseState` subclass schema at deserialization time. The Generic parameter `T` must be a `CoreasonBaseState` descendant to guarantee RFC 8785 canonicalization.\\n\\nMCP ROUTING TRIGGERS: Semantic Tax Neutralization, Decoupled Reasoning Pipeline, XGrammar FSM Toggle, Constrained Decoding, Two-Stage Generation, Deliberation Envelope\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"deliberation_trace\","]
#[doc = "    \"payload\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"deliberation_trace\": {"]
#[doc = "      \"title\": \"Deliberation Trace\","]
#[doc = "      \"description\": \"The unconstrained Chain-of-Thought reasoning trace generated by the Frontier model with the Sovereign LLM Proxy's XGrammar AOT FSM bitmask DISABLED. This field captures the full computational runway — scratchpad blocks, intermediate calculations, and heuristic explorations — that the model requires to maximize logical accuracy without suffering the Format Restriction Penalty.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000"]
#[doc = "    },"]
#[doc = "    \"payload\": {"]
#[doc = "      \"title\": \"Payload\","]
#[doc = "      \"description\": \"The deterministic, schema-compliant structured output generated by the Edge model (or the same model in a second pass) with the Sovereign LLM Proxy's XGrammar AOT FSM bitmask STRICTLY ENABLED. This field contains the validated structural result that maps directly to the target CoreasonBaseState subclass.\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DeliberativeEnvelope {
    #[doc = "The unconstrained Chain-of-Thought reasoning trace generated by the Frontier model with the Sovereign LLM Proxy's XGrammar AOT FSM bitmask DISABLED. This field captures the full computational runway — scratchpad blocks, intermediate calculations, and heuristic explorations — that the model requires to maximize logical accuracy without suffering the Format Restriction Penalty."]
    pub deliberation_trace: DeliberationTrace,
    #[doc = "The deterministic, schema-compliant structured output generated by the Edge model (or the same model in a second pass) with the Sovereign LLM Proxy's XGrammar AOT FSM bitmask STRICTLY ENABLED. This field contains the validated structural result that maps directly to the target CoreasonBaseState subclass."]
    pub payload: ::serde_json::Value,
}
impl DeliberativeEnvelope {
    pub fn builder() -> builder::DeliberativeEnvelope {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Replaces monolithic probability floats with a composite tri-vector. Independently measures lexical matching, latent semantic distance, and topological graph integrity to allow the orchestrator to compute epistemic conflict and execute evidence discounting.\n\n    CAUSAL AFFORDANCE: Instructs the orchestrator to independently measure lexical matching, latent semantic distance, and topological graph integrity.\n\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\n\n    MCP ROUTING TRIGGERS: Dempster-Shafer, Epistemic Conflict, Evidence Discounting, Composite Tri-Vector"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DempsterShaferBeliefVector\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Replaces monolithic probability floats with a composite tri-vector. Independently measures lexical matching, latent semantic distance, and topological graph integrity to allow the orchestrator to compute epistemic conflict and execute evidence discounting.\\n\\n    CAUSAL AFFORDANCE: Instructs the orchestrator to independently measure lexical matching, latent semantic distance, and topological graph integrity.\\n\\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\\n\\n    MCP ROUTING TRIGGERS: Dempster-Shafer, Epistemic Conflict, Evidence Discounting, Composite Tri-Vector\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"epistemic_conflict_mass\","]
#[doc = "    \"lexical_confidence\","]
#[doc = "    \"semantic_distance\","]
#[doc = "    \"structural_graph_confidence\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"epistemic_conflict_mass\": {"]
#[doc = "      \"title\": \"Epistemic Conflict Mass\","]
#[doc = "      \"description\": \"The calculated mathematical contradiction or dissonance between the three vectors. High conflict mass triggers evidence discounting.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"lexical_confidence\": {"]
#[doc = "      \"title\": \"Lexical Confidence\","]
#[doc = "      \"description\": \"Represents exact syntactic schema or sub-string overlap.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"semantic_distance\": {"]
#[doc = "      \"title\": \"Semantic Distance\","]
#[doc = "      \"description\": \"Represents continuous optimal transport alignment (e.g., Gromov-Wasserstein or Cosine distance) within the high-dimensional latent manifold.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"structural_graph_confidence\": {"]
#[doc = "      \"title\": \"Structural Graph Confidence\","]
#[doc = "      \"description\": \"Represents the topological validity of the surrounding causal edges (e.g., evaluated via Random Walk with Restart).\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"supporting_citations\": {"]
#[doc = "      \"title\": \"Supporting Citations\","]
#[doc = "      \"description\": \"The array of external NLI-scored citations aggregating to form this belief mass.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EvidentiaryCitationState\""]
#[doc = "      },"]
#[doc = "      \"maxItems\": 100"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DempsterShaferBeliefVector {
    #[doc = "The calculated mathematical contradiction or dissonance between the three vectors. High conflict mass triggers evidence discounting."]
    pub epistemic_conflict_mass: f64,
    #[doc = "Represents exact syntactic schema or sub-string overlap."]
    pub lexical_confidence: f64,
    #[doc = "Represents continuous optimal transport alignment (e.g., Gromov-Wasserstein or Cosine distance) within the high-dimensional latent manifold."]
    pub semantic_distance: f64,
    #[doc = "Represents the topological validity of the surrounding causal edges (e.g., evaluated via Random Walk with Restart)."]
    pub structural_graph_confidence: f64,
    #[doc = "The array of external NLI-scored citations aggregating to form this belief mass."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub supporting_citations: ::std::vec::Vec<EvidentiaryCitationState>,
}
impl DempsterShaferBeliefVector {
    pub fn builder() -> builder::DempsterShaferBeliefVector {
        Default::default()
    }
}
#[doc = "AGENT INSTRUCTION: Defines the rigid mathematical derivation mode for semantic extraction.\n\nCAUSAL AFFORDANCE: Instructs the extraction engine whether to perform a strict 1:1 topological mapping or an abductive expansion.\n\nEPISTEMIC BOUNDS: Constrained entirely to strict Pydantic string literals to prevent hallucinated derivation paths.\n\nMCP ROUTING TRIGGERS: Derivation Mode, Abductive Upsampling, Direct Translation, Epistemic Extraction"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DerivationModeProfile\","]
#[doc = "  \"description\": \"AGENT INSTRUCTION: Defines the rigid mathematical derivation mode for semantic extraction.\\n\\nCAUSAL AFFORDANCE: Instructs the extraction engine whether to perform a strict 1:1 topological mapping or an abductive expansion.\\n\\nEPISTEMIC BOUNDS: Constrained entirely to strict Pydantic string literals to prevent hallucinated derivation paths.\\n\\nMCP ROUTING TRIGGERS: Derivation Mode, Abductive Upsampling, Direct Translation, Epistemic Extraction\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"direct_translation\","]
#[doc = "    \"abductive_upsampling\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum DerivationModeProfile {
    #[serde(rename = "direct_translation")]
    DirectTranslation,
    #[serde(rename = "abductive_upsampling")]
    AbductiveUpsampling,
}
impl ::std::fmt::Display for DerivationModeProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::DirectTranslation => f.write_str("direct_translation"),
            Self::AbductiveUpsampling => f.write_str("abductive_upsampling"),
        }
    }
}
impl ::std::str::FromStr for DerivationModeProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "direct_translation" => Ok(Self::DirectTranslation),
            "abductive_upsampling" => Ok(Self::AbductiveUpsampling),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for DerivationModeProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DerivationModeProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DerivationModeProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The semantic boundary defining the objective function of the execution node. [SITD-Gamma: Neurosymbolic Substrate Alignment]"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Description\","]
#[doc = "  \"description\": \"The semantic boundary defining the objective function of the execution node. [SITD-Gamma: Neurosymbolic Substrate Alignment]\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Description(::std::string::String);
impl ::std::ops::Deref for Description {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Description> for ::std::string::String {
    fn from(value: Description) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Description {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Description {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Description {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Description {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Description {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`DetectedModalitiesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"text\","]
#[doc = "    \"raster_image\","]
#[doc = "    \"vector_graphics\","]
#[doc = "    \"tabular_grid\","]
#[doc = "    \"n_dimensional_tensor\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum DetectedModalitiesItem {
    #[serde(rename = "text")]
    Text,
    #[serde(rename = "raster_image")]
    RasterImage,
    #[serde(rename = "vector_graphics")]
    VectorGraphics,
    #[serde(rename = "tabular_grid")]
    TabularGrid,
    #[serde(rename = "n_dimensional_tensor")]
    NDimensionalTensor,
}
impl ::std::fmt::Display for DetectedModalitiesItem {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Text => f.write_str("text"),
            Self::RasterImage => f.write_str("raster_image"),
            Self::VectorGraphics => f.write_str("vector_graphics"),
            Self::TabularGrid => f.write_str("tabular_grid"),
            Self::NDimensionalTensor => f.write_str("n_dimensional_tensor"),
        }
    }
}
impl ::std::str::FromStr for DetectedModalitiesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "text" => Ok(Self::Text),
            "raster_image" => Ok(Self::RasterImage),
            "vector_graphics" => Ok(Self::VectorGraphics),
            "tabular_grid" => Ok(Self::TabularGrid),
            "n_dimensional_tensor" => Ok(Self::NDimensionalTensor),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for DetectedModalitiesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DetectedModalitiesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DetectedModalitiesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The cryptographic signature of the developer/vendor."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Developer Signature\","]
#[doc = "  \"description\": \"The cryptographic signature of the developer/vendor.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DeveloperSignature(::std::string::String);
impl ::std::ops::Deref for DeveloperSignature {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DeveloperSignature> for ::std::string::String {
    fn from(value: DeveloperSignature) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DeveloperSignature {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DeveloperSignature {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DeveloperSignature {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DeveloperSignature {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DeveloperSignature {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`DiagnosticHash`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Diagnostic Hash\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DiagnosticHash(::std::string::String);
impl ::std::ops::Deref for DiagnosticHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DiagnosticHash> for ::std::string::String {
    fn from(value: DiagnosticHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DiagnosticHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DiagnosticHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DiagnosticHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DiagnosticHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DiagnosticHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The specific constraint breached."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Diagnostic Message\","]
#[doc = "  \"description\": \"The specific constraint breached.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DiagnosticMessage(::std::string::String);
impl ::std::ops::Deref for DiagnosticMessage {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DiagnosticMessage> for ::std::string::String {
    fn from(value: DiagnosticMessage) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DiagnosticMessage {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DiagnosticMessage {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DiagnosticMessage {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DiagnosticMessage {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DiagnosticMessage {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The semantic explanation for the starvation (e.g., 'Maximum search retries exhausted')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Diagnostic Reason\","]
#[doc = "  \"description\": \"The semantic explanation for the starvation (e.g., 'Maximum search retries exhausted').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DiagnosticReason(::std::string::String);
impl ::std::ops::Deref for DiagnosticReason {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DiagnosticReason> for ::std::string::String {
    fn from(value: DiagnosticReason) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DiagnosticReason {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DiagnosticReason {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DiagnosticReason {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DiagnosticReason {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DiagnosticReason {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The discrete open-source engine URN identifier."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Dialect\","]
#[doc = "  \"description\": \"The discrete open-source engine URN identifier.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Dialect(::std::string::String);
impl ::std::ops::Deref for Dialect {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Dialect> for ::std::string::String {
    fn from(value: Dialect) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Dialect {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^urn:coreason:.*$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^urn:coreason:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Dialect {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Dialect {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Dialect {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Dialect {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The URN identifying the specific formal dialect or solver (e.g., 'urn:coreason:dialect:lean4', 'urn:coreason:dialect:clingo')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Dialect Urn\","]
#[doc = "  \"description\": \"The URN identifying the specific formal dialect or solver (e.g., 'urn:coreason:dialect:lean4', 'urn:coreason:dialect:clingo').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DialectUrn(::std::string::String);
impl ::std::ops::Deref for DialectUrn {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DialectUrn> for ::std::string::String {
    fn from(value: DialectUrn) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DialectUrn {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^urn:coreason:.*$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^urn:coreason:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DialectUrn {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DialectUrn {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DialectUrn {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DialectUrn {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The Decentralized Identifier (DID) of the human operator."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Did Subject\","]
#[doc = "  \"description\": \"The Decentralized Identifier (DID) of the human operator.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 1024,"]
#[doc = "  \"pattern\": \"^did:[a-z0-9]+:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DidSubject(::std::string::String);
impl ::std::ops::Deref for DidSubject {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DidSubject> for ::std::string::String {
    fn from(value: DidSubject) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DidSubject {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 1024usize {
            return Err("longer than 1024 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^did:[a-z0-9]+:.*$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^did:[a-z0-9]+:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DidSubject {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DidSubject {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DidSubject {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DidSubject {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this state differential."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Diff Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this state differential.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DiffCid(::std::string::String);
impl ::std::ops::Deref for DiffCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DiffCid> for ::std::string::String {
    fn from(value: DiffCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DiffCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DiffCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DiffCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DiffCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DiffCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Bridges the Neurosymbolic divide by mapping discrete Satisfiability Modulo Theories (SMT) or Lean4 logic proofs into continuous, differentiable loss gradients.\n\nCAUSAL AFFORDANCE: Allows the backpropagation engine to apply a continuous, differentiable penalty (relaxation) to the LLM's probability mass when it violates the formal syntactic rules encoded in the `formal_syntax_smt` representation.\n\nEPISTEMIC BOUNDS: The geometric penalty is clamped by `relaxation_epsilon` (`ge=0.0, le=1.0`) to prevent gradient explosion. The logical schema is locked to the 128-char `constraint_cid` CID to structurally bound string evaluation scope.\n\nMCP ROUTING TRIGGERS: Satisfiability Modulo Theories, Neurosymbolic Relaxation, Differentiable Theorem Proving, Probabilistic Logic Networks, Continuous Penalty"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DifferentiableLogicPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Bridges the Neurosymbolic divide by mapping discrete Satisfiability Modulo Theories (SMT) or Lean4 logic proofs into continuous, differentiable loss gradients.\\n\\nCAUSAL AFFORDANCE: Allows the backpropagation engine to apply a continuous, differentiable penalty (relaxation) to the LLM's probability mass when it violates the formal syntactic rules encoded in the `formal_syntax_smt` representation.\\n\\nEPISTEMIC BOUNDS: The geometric penalty is clamped by `relaxation_epsilon` (`ge=0.0, le=1.0`) to prevent gradient explosion. The logical schema is locked to the 128-char `constraint_cid` CID to structurally bound string evaluation scope.\\n\\nMCP ROUTING TRIGGERS: Satisfiability Modulo Theories, Neurosymbolic Relaxation, Differentiable Theorem Proving, Probabilistic Logic Networks, Continuous Penalty\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"constraint_cid\","]
#[doc = "    \"formal_syntax_smt\","]
#[doc = "    \"relaxation_epsilon\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"constraint_cid\": {"]
#[doc = "      \"title\": \"Constraint Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"formal_syntax_smt\": {"]
#[doc = "      \"title\": \"Formal Syntax Smt\","]
#[doc = "      \"description\": \"The formal SMT-LIB or Lean4 language representation of the symbolic rule.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"relaxation_epsilon\": {"]
#[doc = "      \"title\": \"Relaxation Epsilon\","]
#[doc = "      \"description\": \"The continuous penalty applied to the LLM probability mass for constraint violation.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DifferentiableLogicPolicy {
    pub constraint_cid: ConstraintCid,
    #[doc = "The formal SMT-LIB or Lean4 language representation of the symbolic rule."]
    pub formal_syntax_smt: FormalSyntaxSmt,
    #[doc = "The continuous penalty applied to the LLM probability mass for constraint violation."]
    pub relaxation_epsilon: f64,
}
impl DifferentiableLogicPolicy {
    pub fn builder() -> builder::DifferentiableLogicPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative, frozen snapshot of a Cyber-Physical Systems (CPS) Digital Twin, establishing an epistemically isolated shadow graph that mirrors a real-world topology without risking kinetic bleed.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator to execute unbounded sandbox simulations against the mirrored `target_topology_cid` (128-char CID), mathematically severing all external write access if `enforce_no_side_effects` is True.\n\nEPISTEMIC BOUNDS: The simulation physics are structurally clamped by the `convergence_sla`, which physically bounds the maximum Monte Carlo rollouts and variance tolerance. External kinetic permutations are mechanically trapped.\n\nMCP ROUTING TRIGGERS: Digital Twin, Cyber-Physical Systems, Sandbox Simulation, Markov Blanket, Shadow Graph"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DigitalTwinTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative, frozen snapshot of a Cyber-Physical Systems (CPS) Digital Twin, establishing an epistemically isolated shadow graph that mirrors a real-world topology without risking kinetic bleed.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator to execute unbounded sandbox simulations against the mirrored `target_topology_cid` (128-char CID), mathematically severing all external write access if `enforce_no_side_effects` is True.\\n\\nEPISTEMIC BOUNDS: The simulation physics are structurally clamped by the `convergence_sla`, which physically bounds the maximum Monte Carlo rollouts and variance tolerance. External kinetic permutations are mechanically trapped.\\n\\nMCP ROUTING TRIGGERS: Digital Twin, Cyber-Physical Systems, Sandbox Simulation, Markov Blanket, Shadow Graph\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"convergence_sla\","]
#[doc = "    \"nodes\","]
#[doc = "    \"target_topology_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"convergence_sla\": {"]
#[doc = "      \"description\": \"The strict mathematical boundaries for the simulation.\","]
#[doc = "      \"$ref\": \"#/$defs/SimulationConvergenceSLA\""]
#[doc = "    },"]
#[doc = "    \"enforce_no_side_effects\": {"]
#[doc = "      \"title\": \"Enforce No Side Effects\","]
#[doc = "      \"description\": \"A declarative flag that instructs the runtime to mathematically sever all external write access.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"epistemic_enforcement\": {"]
#[doc = "      \"description\": \"Ties the topology to the Truth Maintenance layer.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TruthMaintenancePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this topology's configuration.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"lifecycle_phase\": {"]
#[doc = "      \"title\": \"Lifecycle Phase\","]
#[doc = "      \"description\": \"The execution phase of the graph. 'draft' allows incomplete structural state.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"draft\","]
#[doc = "        \"live\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"nodes\": {"]
#[doc = "      \"title\": \"Nodes\","]
#[doc = "      \"description\": \"Flat registry of all nodes in this topology.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyNodeProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"observability\": {"]
#[doc = "      \"description\": \"The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ObservabilityLODPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"semantic_flow\": {"]
#[doc = "      \"description\": \"The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticFlowPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"shared_state_contract\": {"]
#[doc = "      \"description\": \"The schema-on-write contract governing the internal state of this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StateContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_topology_cid\": {"]
#[doc = "      \"title\": \"Target Topology Cid\","]
#[doc = "      \"description\": \"The identifier (expected to be a W3C DID) pointing to the real-world topology it is cloning.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a Digital Twin topology.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"digital_twin\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DigitalTwinTopologyManifest {
    #[doc = "The AI's declarative rationale for selecting this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "The strict mathematical boundaries for the simulation."]
    pub convergence_sla: SimulationConvergenceSla,
    #[doc = "A declarative flag that instructs the runtime to mathematically sever all external write access."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub enforce_no_side_effects: ::std::option::Option<bool>,
    #[doc = "Ties the topology to the Truth Maintenance layer."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_enforcement: ::std::option::Option<TruthMaintenancePolicy>,
    #[doc = "Cryptographic/audit justification for this topology's configuration."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The execution phase of the graph. 'draft' allows incomplete structural state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub lifecycle_phase: ::std::option::Option<LifecyclePhase>,
    #[doc = "Flat registry of all nodes in this topology."]
    pub nodes: ::std::collections::HashMap<::std::string::String, AnyNodeProfile>,
    #[doc = "The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub observability: ::std::option::Option<ObservabilityLodPolicy>,
    #[doc = "The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_flow: ::std::option::Option<SemanticFlowPolicy>,
    #[doc = "The schema-on-write contract governing the internal state of this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub shared_state_contract: ::std::option::Option<StateContract>,
    #[doc = "The identifier (expected to be a W3C DID) pointing to the real-world topology it is cloning."]
    pub target_topology_cid: TargetTopologyCid,
    #[doc = "Discriminator for a Digital Twin topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl DigitalTwinTopologyManifest {
    pub fn builder() -> builder::DigitalTwinTopologyManifest {
        Default::default()
    }
}
#[doc = "The topological relationship."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Directed Edge Class\","]
#[doc = "  \"description\": \"The topological relationship.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DirectedEdgeClass(::std::string::String);
impl ::std::ops::Deref for DirectedEdgeClass {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DirectedEdgeClass> for ::std::string::String {
    fn from(value: DirectedEdgeClass) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DirectedEdgeClass {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DirectedEdgeClass {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DirectedEdgeClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DirectedEdgeClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DirectedEdgeClass {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`DiscardedBranchesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DiscardedBranchesItem(::std::string::String);
impl ::std::ops::Deref for DiscardedBranchesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DiscardedBranchesItem> for ::std::string::String {
    fn from(value: DiscardedBranchesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DiscardedBranchesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DiscardedBranchesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DiscardedBranchesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DiscardedBranchesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DiscardedBranchesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A structural vertex defining a distinct rhetorical block of text within a document, enabling hierarchical parsing and graph-based traversal of discourse.\n\n    CAUSAL AFFORDANCE: Instructs the orchestrator to allocate memory for a distinct rhetorical block of text.\n\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\n\n    MCP ROUTING TRIGGERS: Rhetorical Block, Discourse Parsing, Graph Traversal, Structural Vertex"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DiscourseNodeState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A structural vertex defining a distinct rhetorical block of text within a document, enabling hierarchical parsing and graph-based traversal of discourse.\\n\\n    CAUSAL AFFORDANCE: Instructs the orchestrator to allocate memory for a distinct rhetorical block of text.\\n\\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\\n\\n    MCP ROUTING TRIGGERS: Rhetorical Block, Discourse Parsing, Graph Traversal, Structural Vertex\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"discourse_type\","]
#[doc = "    \"node_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"contained_propositions\": {"]
#[doc = "      \"title\": \"Contained Propositions\","]
#[doc = "      \"description\": \"Explicit pointers linking this discourse block to the specific AtomicPropositionState nodes extracted from its text.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"discourse_type\": {"]
#[doc = "      \"title\": \"Discourse Type\","]
#[doc = "      \"description\": \"A strict universal automaton classifying the structural role of the text block.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"preamble\","]
#[doc = "        \"methodology\","]
#[doc = "        \"argumentation\","]
#[doc = "        \"findings\","]
#[doc = "        \"conclusion\","]
#[doc = "        \"addendum\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"node_cid\": {"]
#[doc = "      \"description\": \"The spatial coordinate of this specific discourse block.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"parent_node_cid\": {"]
#[doc = "      \"description\": \"A pointer to the subsuming structural block. None indicates this is a root node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DiscourseNodeState {
    #[doc = "Explicit pointers linking this discourse block to the specific AtomicPropositionState nodes extracted from its text."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub contained_propositions: ::std::vec::Vec<NodeCidState>,
    #[doc = "A strict universal automaton classifying the structural role of the text block."]
    pub discourse_type: DiscourseType,
    #[doc = "The spatial coordinate of this specific discourse block."]
    pub node_cid: NodeCidState,
    #[doc = "A pointer to the subsuming structural block. None indicates this is a root node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub parent_node_cid: ::std::option::Option<NodeCidState>,
}
impl DiscourseNodeState {
    pub fn builder() -> builder::DiscourseNodeState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A verifiable Directed Acyclic Graph (DAG) mapping the hierarchical geometry of human discourse. Deprecates flat-sequence extraction to solve rhetorical flattening.\n\n    CAUSAL AFFORDANCE: Instructs the orchestrator to enforce a strict Directed Acyclic Graph (DAG) for discourse representation.\n\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\n\n    MCP ROUTING TRIGGERS: Discourse Geometry, Rhetorical Flattening, Directed Acyclic Graph, Hierarchical Extraction"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DiscourseTreeManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A verifiable Directed Acyclic Graph (DAG) mapping the hierarchical geometry of human discourse. Deprecates flat-sequence extraction to solve rhetorical flattening.\\n\\n    CAUSAL AFFORDANCE: Instructs the orchestrator to enforce a strict Directed Acyclic Graph (DAG) for discourse representation.\\n\\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\\n\\n    MCP ROUTING TRIGGERS: Discourse Geometry, Rhetorical Flattening, Directed Acyclic Graph, Hierarchical Extraction\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"discourse_nodes\","]
#[doc = "    \"manifest_cid\","]
#[doc = "    \"root_node_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"discourse_nodes\": {"]
#[doc = "      \"title\": \"Discourse Nodes\","]
#[doc = "      \"description\": \"The localized registry of all hierarchical blocks comprising the document.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 10000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/DiscourseNodeState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"manifest_cid\": {"]
#[doc = "      \"title\": \"Manifest Cid\","]
#[doc = "      \"description\": \"Cryptographic identifier for this topology.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"root_node_cid\": {"]
#[doc = "      \"description\": \"The apex of the document tree.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a discourse tree topology.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"discourse_tree\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DiscourseTreeManifest {
    #[doc = "The localized registry of all hierarchical blocks comprising the document."]
    pub discourse_nodes: ::std::collections::HashMap<::std::string::String, DiscourseNodeState>,
    #[doc = "Cryptographic identifier for this topology."]
    pub manifest_cid: ManifestCid,
    #[doc = "The apex of the document tree."]
    pub root_node_cid: NodeCidState,
    #[doc = "Discriminator for a discourse tree topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl DiscourseTreeManifest {
    pub fn builder() -> builder::DiscourseTreeManifest {
        Default::default()
    }
}
#[doc = "A strict universal automaton classifying the structural role of the text block."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Discourse Type\","]
#[doc = "  \"description\": \"A strict universal automaton classifying the structural role of the text block.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"preamble\","]
#[doc = "    \"methodology\","]
#[doc = "    \"argumentation\","]
#[doc = "    \"findings\","]
#[doc = "    \"conclusion\","]
#[doc = "    \"addendum\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum DiscourseType {
    #[serde(rename = "preamble")]
    Preamble,
    #[serde(rename = "methodology")]
    Methodology,
    #[serde(rename = "argumentation")]
    Argumentation,
    #[serde(rename = "findings")]
    Findings,
    #[serde(rename = "conclusion")]
    Conclusion,
    #[serde(rename = "addendum")]
    Addendum,
}
impl ::std::fmt::Display for DiscourseType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Preamble => f.write_str("preamble"),
            Self::Methodology => f.write_str("methodology"),
            Self::Argumentation => f.write_str("argumentation"),
            Self::Findings => f.write_str("findings"),
            Self::Conclusion => f.write_str("conclusion"),
            Self::Addendum => f.write_str("addendum"),
        }
    }
}
impl ::std::str::FromStr for DiscourseType {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "preamble" => Ok(Self::Preamble),
            "methodology" => Ok(Self::Methodology),
            "argumentation" => Ok(Self::Argumentation),
            "findings" => Ok(Self::Findings),
            "conclusion" => Ok(Self::Conclusion),
            "addendum" => Ok(Self::Addendum),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for DiscourseType {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DiscourseType {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DiscourseType {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Bayesian Inference and Parametric Probability Density\nFunctions (PDFs) to mathematically define the stochastic shape of latent variables.\nAs a ...Profile suffix, this is a declarative, frozen snapshot of an evaluation geometry.\n\nCAUSAL AFFORDANCE: Projects a continuous statistical geometry (Gaussian, Uniform,\nor Beta) onto a stochastic process, dictating the generative bounds of entropy or\nreward distributions during reinforcement learning.\n\nEPISTEMIC BOUNDS: The Euclidean limits are physically clamped by mean and variance\n(le=18446744073709551615.0). The @model_validator validate_confidence_interval mathematically\nenforces the invariant that the 95% confidence lower bound must be strictly less than\nthe upper bound.\n\nMCP ROUTING TRIGGERS: Probability Density Function, Bayesian Inference, Stochastic Geometry, Parametric Distribution, Variance Bounding"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DistributionProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Bayesian Inference and Parametric Probability Density\\nFunctions (PDFs) to mathematically define the stochastic shape of latent variables.\\nAs a ...Profile suffix, this is a declarative, frozen snapshot of an evaluation geometry.\\n\\nCAUSAL AFFORDANCE: Projects a continuous statistical geometry (Gaussian, Uniform,\\nor Beta) onto a stochastic process, dictating the generative bounds of entropy or\\nreward distributions during reinforcement learning.\\n\\nEPISTEMIC BOUNDS: The Euclidean limits are physically clamped by mean and variance\\n(le=18446744073709551615.0). The @model_validator validate_confidence_interval mathematically\\nenforces the invariant that the 95% confidence lower bound must be strictly less than\\nthe upper bound.\\n\\nMCP ROUTING TRIGGERS: Probability Density Function, Bayesian Inference, Stochastic Geometry, Parametric Distribution, Variance Bounding\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"distribution_type\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"confidence_interval_95\": {"]
#[doc = "      \"title\": \"Confidence Interval 95\","]
#[doc = "      \"description\": \"The 95% probability bounds.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"array\","]
#[doc = "          \"maxItems\": 1000,"]
#[doc = "          \"minItems\": 2,"]
#[doc = "          \"prefixItems\": ["]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            }"]
#[doc = "          ]"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"distribution_type\": {"]
#[doc = "      \"description\": \"The mathematical shape of the probability density function.\","]
#[doc = "      \"$ref\": \"#/$defs/DistributionShapeProfile\""]
#[doc = "    },"]
#[doc = "    \"mean\": {"]
#[doc = "      \"title\": \"Mean\","]
#[doc = "      \"description\": \"The expected value (mu) of the distribution.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"variance\": {"]
#[doc = "      \"title\": \"Variance\","]
#[doc = "      \"description\": \"The mathematical variance (sigma squared).\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DistributionProfile {
    #[doc = "The 95% probability bounds."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub confidence_interval_95: ::std::option::Option<::std::vec::Vec<::serde_json::Value>>,
    #[doc = "The mathematical shape of the probability density function."]
    pub distribution_type: DistributionShapeProfile,
    #[doc = "The expected value (mu) of the distribution."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub mean: ::std::option::Option<f64>,
    #[doc = "The mathematical variance (sigma squared)."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub variance: ::std::option::Option<f64>,
}
impl DistributionProfile {
    pub fn builder() -> builder::DistributionProfile {
        Default::default()
    }
}
#[doc = "`DistributionShapeProfile`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"gaussian\","]
#[doc = "    \"uniform\","]
#[doc = "    \"beta\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum DistributionShapeProfile {
    #[serde(rename = "gaussian")]
    Gaussian,
    #[serde(rename = "uniform")]
    Uniform,
    #[serde(rename = "beta")]
    Beta,
}
impl ::std::fmt::Display for DistributionShapeProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Gaussian => f.write_str("gaussian"),
            Self::Uniform => f.write_str("uniform"),
            Self::Beta => f.write_str("beta"),
        }
    }
}
impl ::std::str::FromStr for DistributionShapeProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "gaussian" => Ok(Self::Gaussian),
            "uniform" => Ok(Self::Uniform),
            "beta" => Ok(Self::Beta),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for DistributionShapeProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DistributionShapeProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DistributionShapeProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Cognitive Heterogeneity and Ensemble Variance mandates to\nphysically prevent mode collapse, epistemic echo-chambers, and algorithmic Groupthink\nwithin the swarm. As a ...Policy suffix, this object defines rigid mathematical\nboundaries.\n\nCAUSAL AFFORDANCE: Forces the orchestrator to construct a topologically diverse\nmulti-model matrix (if model_variance_required is True) and assigns explicit adversarial\n(\"Devil's Advocate\") roles to intentionally perturb the consensus gradient.\n\nEPISTEMIC BOUNDS: Physically bounds the lower limits of adversarial insertion via\nmin_adversaries (le=18446744073709551615, no ge bound). Enforces continuous entropic variance via\nthe optional temperature_variance float (le=18446744073709551615.0, default=None).\n\nMCP ROUTING TRIGGERS: Cognitive Heterogeneity, Ensemble Variance, Groupthink\nMitigation, Red Teaming, Adversarial Perturbation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DiversityPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Cognitive Heterogeneity and Ensemble Variance mandates to\\nphysically prevent mode collapse, epistemic echo-chambers, and algorithmic Groupthink\\nwithin the swarm. As a ...Policy suffix, this object defines rigid mathematical\\nboundaries.\\n\\nCAUSAL AFFORDANCE: Forces the orchestrator to construct a topologically diverse\\nmulti-model matrix (if model_variance_required is True) and assigns explicit adversarial\\n(\\\"Devil's Advocate\\\") roles to intentionally perturb the consensus gradient.\\n\\nEPISTEMIC BOUNDS: Physically bounds the lower limits of adversarial insertion via\\nmin_adversaries (le=18446744073709551615, no ge bound). Enforces continuous entropic variance via\\nthe optional temperature_variance float (le=18446744073709551615.0, default=None).\\n\\nMCP ROUTING TRIGGERS: Cognitive Heterogeneity, Ensemble Variance, Groupthink\\nMitigation, Red Teaming, Adversarial Perturbation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"min_adversaries\","]
#[doc = "    \"model_variance_required\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"min_adversaries\": {"]
#[doc = "      \"title\": \"Min Adversaries\","]
#[doc = "      \"description\": \"The minimum number of adversarial or 'Devil's Advocate' roles required to prevent groupthink.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"model_variance_required\": {"]
#[doc = "      \"title\": \"Model Variance Required\","]
#[doc = "      \"description\": \"If True, forces the orchestrator to route sub-agents to different foundational models.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"temperature_variance\": {"]
#[doc = "      \"title\": \"Temperature Variance\","]
#[doc = "      \"description\": \"Required statistical variance in temperature settings across the council.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DiversityPolicy {
    #[doc = "The minimum number of adversarial or 'Devil's Advocate' roles required to prevent groupthink."]
    pub min_adversaries: u64,
    #[doc = "If True, forces the orchestrator to route sub-agents to different foundational models."]
    pub model_variance_required: bool,
    #[doc = "Required statistical variance in temperature settings across the council."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub temperature_variance: ::std::option::Option<f64>,
}
impl DiversityPolicy {
    pub fn builder() -> builder::DiversityPolicy {
        Default::default()
    }
}
#[doc = "The exact value or condition forced upon the intervention_variable, isolating it from its historical causes."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Do Operator State\","]
#[doc = "  \"description\": \"The exact value or condition forced upon the intervention_variable, isolating it from its historical causes.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DoOperatorState(::std::string::String);
impl ::std::ops::Deref for DoOperatorState {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DoOperatorState> for ::std::string::String {
    fn from(value: DoOperatorState) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DoOperatorState {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DoOperatorState {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DoOperatorState {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DoOperatorState {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DoOperatorState {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DocumentKnowledgeGraphManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"causal_edges\","]
#[doc = "    \"graph_cid\","]
#[doc = "    \"isomorphism_hash\","]
#[doc = "    \"nodes\","]
#[doc = "    \"source_artifact_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"causal_edges\": {"]
#[doc = "      \"title\": \"Causal Edges\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/CausalDirectedEdgeState\""]
#[doc = "      },"]
#[doc = "      \"maxItems\": 100000"]
#[doc = "    },"]
#[doc = "    \"graph_cid\": {"]
#[doc = "      \"title\": \"Graph Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"isomorphism_hash\": {"]
#[doc = "      \"title\": \"Isomorphism Hash\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"nodes\": {"]
#[doc = "      \"title\": \"Nodes\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/SemanticNodeState\""]
#[doc = "      },"]
#[doc = "      \"maxItems\": 100000"]
#[doc = "    },"]
#[doc = "    \"source_artifact_cid\": {"]
#[doc = "      \"title\": \"Source Artifact Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"document_knowledge_graph\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DocumentKnowledgeGraphManifest {
    pub causal_edges: ::std::vec::Vec<CausalDirectedEdgeState>,
    pub graph_cid: GraphCid,
    pub isomorphism_hash: IsomorphismHash,
    pub nodes: ::std::vec::Vec<SemanticNodeState>,
    pub source_artifact_cid: SourceArtifactCid,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl DocumentKnowledgeGraphManifest {
    pub fn builder() -> builder::DocumentKnowledgeGraphManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Instantiates a Directed Acyclic Graph (DAG) to represent\nthe strictly chronological reading flow of a complex 2D multimodal manifold.\nAs a ...Manifest suffix, this is a frozen N-dimensional coordinate state.\n\nCAUSAL AFFORDANCE: Synthesizes spatially disparate DocumentLayoutRegionState\nnodes into a mathematically ordered execution trajectory, dictating the exact\nsequential vector for downstream tokenization.\n\nEPISTEMIC BOUNDS: The @model_validator verify_dag_and_integrity executes a\nDepth First Search to mathematically prove chronological_flow_edges form a\nparadox-free DAG. It simultaneously verifies referential integrity against the\nblocks dictionary (bounded to 1,000,000,000 max properties).\n\nMCP ROUTING TRIGGERS: Directed Acyclic Graph, Kahn's Algorithm, Topological\nSort, Referential Integrity, Spatial Reading Order"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DocumentLayoutManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Instantiates a Directed Acyclic Graph (DAG) to represent\\nthe strictly chronological reading flow of a complex 2D multimodal manifold.\\nAs a ...Manifest suffix, this is a frozen N-dimensional coordinate state.\\n\\nCAUSAL AFFORDANCE: Synthesizes spatially disparate DocumentLayoutRegionState\\nnodes into a mathematically ordered execution trajectory, dictating the exact\\nsequential vector for downstream tokenization.\\n\\nEPISTEMIC BOUNDS: The @model_validator verify_dag_and_integrity executes a\\nDepth First Search to mathematically prove chronological_flow_edges form a\\nparadox-free DAG. It simultaneously verifies referential integrity against the\\nblocks dictionary (bounded to 1,000,000,000 max properties).\\n\\nMCP ROUTING TRIGGERS: Directed Acyclic Graph, Kahn's Algorithm, Topological\\nSort, Referential Integrity, Spatial Reading Order\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"blocks\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"blocks\": {"]
#[doc = "      \"title\": \"Blocks\","]
#[doc = "      \"description\": \"Dictionary mapping block_cids to their strict spatial definitions.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/DocumentLayoutRegionState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"chronological_flow_edges\": {"]
#[doc = "      \"title\": \"Chronological Flow Edges\","]
#[doc = "      \"description\": \"Directed edges defining the topological sort (chronological flow) of the document.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"array\","]
#[doc = "        \"maxItems\": 2,"]
#[doc = "        \"minItems\": 2,"]
#[doc = "        \"prefixItems\": ["]
#[doc = "          {"]
#[doc = "            \"type\": \"string\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"string\""]
#[doc = "          }"]
#[doc = "        ]"]
#[doc = "      },"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DocumentLayoutManifest {
    #[doc = "Dictionary mapping block_cids to their strict spatial definitions."]
    pub blocks: ::std::collections::HashMap<::std::string::String, DocumentLayoutRegionState>,
    #[doc = "Directed edges defining the topological sort (chronological flow) of the document."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub chronological_flow_edges: ::std::vec::Vec<[::serde_json::Value; 2usize]>,
}
impl DocumentLayoutManifest {
    pub fn builder() -> builder::DocumentLayoutManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A discrete topological bounding box within a formalized\nDocument Object Model (DOM) taxonomy, acting as a spatial vertex in a\nmultimodal graph. As a ...State suffix, this is a frozen N-dimensional\ncoordinate.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator's spatial extraction engine to\nclassify, extract, and isolate explicit sub-regions for localized processing\nusing the anchor (MultimodalTokenAnchorState).\n\nEPISTEMIC BOUNDS: The block_cid is cryptographically anchored by a 128-char\nCID regex (^[a-zA-Z0-9_.:-]+$). The block_class structurally limits extraction\ngeometry to a finite Literal automaton [\"header\", \"paragraph\", \"figure\",\n\"table\", \"footnote\", \"caption\", \"equation\"].\n\nMCP ROUTING TRIGGERS: DOM Taxonomy, Topological Vertex, Spatial\nClassification, Bounding Box Geometry, Semantic Region Isolation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DocumentLayoutRegionState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A discrete topological bounding box within a formalized\\nDocument Object Model (DOM) taxonomy, acting as a spatial vertex in a\\nmultimodal graph. As a ...State suffix, this is a frozen N-dimensional\\ncoordinate.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator's spatial extraction engine to\\nclassify, extract, and isolate explicit sub-regions for localized processing\\nusing the anchor (MultimodalTokenAnchorState).\\n\\nEPISTEMIC BOUNDS: The block_cid is cryptographically anchored by a 128-char\\nCID regex (^[a-zA-Z0-9_.:-]+$). The block_class structurally limits extraction\\ngeometry to a finite Literal automaton [\\\"header\\\", \\\"paragraph\\\", \\\"figure\\\",\\n\\\"table\\\", \\\"footnote\\\", \\\"caption\\\", \\\"equation\\\"].\\n\\nMCP ROUTING TRIGGERS: DOM Taxonomy, Topological Vertex, Spatial\\nClassification, Bounding Box Geometry, Semantic Region Isolation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"anchor\","]
#[doc = "    \"block_cid\","]
#[doc = "    \"block_class\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"anchor\": {"]
#[doc = "      \"description\": \"The strict visual and token coordinate bindings for this block.\","]
#[doc = "      \"$ref\": \"#/$defs/MultimodalTokenAnchorState\""]
#[doc = "    },"]
#[doc = "    \"block_cid\": {"]
#[doc = "      \"title\": \"Block Cid\","]
#[doc = "      \"description\": \"Unique structural identifier for this geometric region.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"block_class\": {"]
#[doc = "      \"title\": \"Block Class\","]
#[doc = "      \"description\": \"The taxonomic classification of the layout region.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"header\","]
#[doc = "        \"paragraph\","]
#[doc = "        \"figure\","]
#[doc = "        \"table\","]
#[doc = "        \"footnote\","]
#[doc = "        \"caption\","]
#[doc = "        \"equation\","]
#[doc = "        \"list_item\","]
#[doc = "        \"code_block\","]
#[doc = "        \"form_field\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"tabular_matrix\": {"]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TabularMatrixProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DocumentLayoutRegionState {
    #[doc = "The strict visual and token coordinate bindings for this block."]
    pub anchor: MultimodalTokenAnchorState,
    #[doc = "Unique structural identifier for this geometric region."]
    pub block_cid: BlockCid,
    #[doc = "The taxonomic classification of the layout region."]
    pub block_class: BlockClass,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub tabular_matrix: ::std::option::Option<TabularMatrixProfile>,
}
impl DocumentLayoutRegionState {
    pub fn builder() -> builder::DocumentLayoutRegionState {
        Default::default()
    }
}
#[doc = "`DomCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Dom Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DomCid(::std::string::String);
impl ::std::ops::Deref for DomCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DomCid> for ::std::string::String {
    fn from(value: DomCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DomCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DomCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DomCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DomCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DomCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SHA-256 hash acting as the structural manifestation vector."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Dom Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash acting as the structural manifestation vector.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DomHash(::std::string::String);
impl ::std::ops::Deref for DomHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DomHash> for ::std::string::String {
    fn from(value: DomHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DomHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DomHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DomHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DomHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DomHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Fristonian Active Inference to minimize Expected Free Energy. Triggered when the swarm detects a catastrophic Epistemic Gap and lacks the structural parameters necessary to reduce Shannon Entropy autonomously.\n\nCAUSAL AFFORDANCE: Emits a structural query to an external human oracle to explicitly solicit data. It suspends autonomous trajectory generation until the missing semantic dimensions are actively projected back into the working memory partition.\n\nEPISTEMIC BOUNDS: The human's unstructured cognitive entropy is aggressively forced through a mathematical funnel via the `resolution_schema`. This schema is volumetrically clamped by the `enforce_payload_topology` hook to prevent AST explosion during input parsing.\n\nMCP ROUTING TRIGGERS: Active Inference, Expected Free Energy, Shannon Entropy Reduction, Zero-Shot Elicitation, Epistemic Gap"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DraftingIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Fristonian Active Inference to minimize Expected Free Energy. Triggered when the swarm detects a catastrophic Epistemic Gap and lacks the structural parameters necessary to reduce Shannon Entropy autonomously.\\n\\nCAUSAL AFFORDANCE: Emits a structural query to an external human oracle to explicitly solicit data. It suspends autonomous trajectory generation until the missing semantic dimensions are actively projected back into the working memory partition.\\n\\nEPISTEMIC BOUNDS: The human's unstructured cognitive entropy is aggressively forced through a mathematical funnel via the `resolution_schema`. This schema is volumetrically clamped by the `enforce_payload_topology` hook to prevent AST explosion during input parsing.\\n\\nMCP ROUTING TRIGGERS: Active Inference, Expected Free Energy, Shannon Entropy Reduction, Zero-Shot Elicitation, Epistemic Gap\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"context_prompt\","]
#[doc = "    \"resolution_schema\","]
#[doc = "    \"timeout_action\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"context_prompt\": {"]
#[doc = "      \"title\": \"Context Prompt\","]
#[doc = "      \"description\": \"The prompt explaining what information the swarm is missing.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"resolution_schema\": {"]
#[doc = "      \"title\": \"Resolution Schema\","]
#[doc = "      \"description\": \"The strict JSON Schema the human's input must satisfy before the graph can resume. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"timeout_action\": {"]
#[doc = "      \"title\": \"Timeout Action\","]
#[doc = "      \"description\": \"The action to take if the human fails to provide the draft.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"rollback\","]
#[doc = "        \"proceed_default\","]
#[doc = "        \"terminate\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for requesting specific missing context from a human.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"drafting\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DraftingIntent {
    #[doc = "The prompt explaining what information the swarm is missing."]
    pub context_prompt: ContextPrompt,
    #[doc = "The strict JSON Schema the human's input must satisfy before the graph can resume. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    pub resolution_schema: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "The action to take if the human fails to provide the draft."]
    pub timeout_action: TimeoutAction,
    #[doc = "Discriminator for requesting specific missing context from a human."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl DraftingIntent {
    pub fn builder() -> builder::DraftingIntent {
        Default::default()
    }
}
#[doc = "The globally unique decentralized identifier (DID) anchoring the GuardrailViolationEvent that justified triggering this proposal."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Drift Event Cid\","]
#[doc = "  \"description\": \"The globally unique decentralized identifier (DID) anchoring the GuardrailViolationEvent that justified triggering this proposal.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct DriftEventCid(::std::string::String);
impl ::std::ops::Deref for DriftEventCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<DriftEventCid> for ::std::string::String {
    fn from(value: DriftEventCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for DriftEventCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for DriftEventCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for DriftEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for DriftEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for DriftEventCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the mathematical Optimal Stopping Theory boundaries for Monte\nCarlo Tree Search (MCTS) and test-time compute scaling. As an ...SLA suffix, this object\nenforces rigid mathematical boundaries that the orchestrator must respect globally.\n\nCAUSAL AFFORDANCE: Triggers an early termination circuit breaker on reasoning trajectories\nwhen the gradient of the Process Reward Model (PRM) score falls below the epsilon delta,\nhalting unnecessary probability wave expansion and preserving VRAM.\n\nEPISTEMIC BOUNDS: Mathematically constrained by convergence_delta_epsilon (ge=0.0, le=1.0)\nover a strictly positive lookback_window_steps (gt=0, le=18446744073709551615). Physically mandates\na minimum_reasoning_steps burn-in period (gt=0, le=18446744073709551615) to prevent premature\ncollapse before the latent space is adequately explored.\n\nMCP ROUTING TRIGGERS: Optimal Stopping Theory, MCTS, PRM Convergence, Circuit Breaker,\nBellman Equation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DynamicConvergenceSLA\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the mathematical Optimal Stopping Theory boundaries for Monte\\nCarlo Tree Search (MCTS) and test-time compute scaling. As an ...SLA suffix, this object\\nenforces rigid mathematical boundaries that the orchestrator must respect globally.\\n\\nCAUSAL AFFORDANCE: Triggers an early termination circuit breaker on reasoning trajectories\\nwhen the gradient of the Process Reward Model (PRM) score falls below the epsilon delta,\\nhalting unnecessary probability wave expansion and preserving VRAM.\\n\\nEPISTEMIC BOUNDS: Mathematically constrained by convergence_delta_epsilon (ge=0.0, le=1.0)\\nover a strictly positive lookback_window_steps (gt=0, le=18446744073709551615). Physically mandates\\na minimum_reasoning_steps burn-in period (gt=0, le=18446744073709551615) to prevent premature\\ncollapse before the latent space is adequately explored.\\n\\nMCP ROUTING TRIGGERS: Optimal Stopping Theory, MCTS, PRM Convergence, Circuit Breaker,\\nBellman Equation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"convergence_delta_epsilon\","]
#[doc = "    \"lookback_window_steps\","]
#[doc = "    \"minimum_reasoning_steps\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"convergence_delta_epsilon\": {"]
#[doc = "      \"title\": \"Convergence Delta Epsilon\","]
#[doc = "      \"description\": \"The minimal required PRM score improvement across the lookback window to justify continued compute.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"lookback_window_steps\": {"]
#[doc = "      \"title\": \"Lookback Window Steps\","]
#[doc = "      \"description\": \"The N-step temporal window over which the PRM gradient is calculated.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"minimum_reasoning_steps\": {"]
#[doc = "      \"title\": \"Minimum Reasoning Steps\","]
#[doc = "      \"description\": \"The burn-in period before convergence logic is activated.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DynamicConvergenceSla {
    #[doc = "The minimal required PRM score improvement across the lookback window to justify continued compute."]
    pub convergence_delta_epsilon: f64,
    #[doc = "The N-step temporal window over which the PRM gradient is calculated."]
    pub lookback_window_steps: ::std::num::NonZeroU64,
    #[doc = "The burn-in period before convergence logic is activated."]
    pub minimum_reasoning_steps: ::std::num::NonZeroU64,
}
impl DynamicConvergenceSla {
    pub fn builder() -> builder::DynamicConvergenceSla {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Encapsulates a Python 3.14 t-string template as an Abstract Syntax Tree (AST) artifact for declarative, zero-trust UI evaluation.\n\nCAUSAL AFFORDANCE: Projects dynamic visual grids onto the UI plane while physically suffocating any capability for Arbitrary Code Execution (ACE) during runtime string interpolation.\n\nEPISTEMIC BOUNDS: The `layout_tstring` is physically clamped at `max_length=2000`. The `@field_validator` `validate_tstring` mathematically proves execution safety by traversing the AST and explicitly quarantining forbidden kinetic nodes (e.g., Call, Import), restricting to declarative operations.\n\nMCP ROUTING TRIGGERS: Abstract Syntax Tree Validation, Zero-Trust UI Projection, Arbitrary Code Execution Prevention, Declarative Templating"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DynamicLayoutManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Encapsulates a Python 3.14 t-string template as an Abstract Syntax Tree (AST) artifact for declarative, zero-trust UI evaluation.\\n\\nCAUSAL AFFORDANCE: Projects dynamic visual grids onto the UI plane while physically suffocating any capability for Arbitrary Code Execution (ACE) during runtime string interpolation.\\n\\nEPISTEMIC BOUNDS: The `layout_tstring` is physically clamped at `max_length=2000`. The `@field_validator` `validate_tstring` mathematically proves execution safety by traversing the AST and explicitly quarantining forbidden kinetic nodes (e.g., Call, Import), restricting to declarative operations.\\n\\nMCP ROUTING TRIGGERS: Abstract Syntax Tree Validation, Zero-Trust UI Projection, Arbitrary Code Execution Prevention, Declarative Templating\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"layout_tstring\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"layout_tstring\": {"]
#[doc = "      \"title\": \"Layout Tstring\","]
#[doc = "      \"description\": \"A Python 3.14 t-string template definition for dynamic UI grid evaluation.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"max_ast_node_budget\": {"]
#[doc = "      \"title\": \"Max Ast Node Budget\","]
#[doc = "      \"description\": \"The absolute physical limit on the number of Abstract Syntax Tree nodes allowed in the layout template, preventing UI Layout Bombing.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 500.0,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DynamicLayoutManifest {
    #[doc = "A Python 3.14 t-string template definition for dynamic UI grid evaluation."]
    pub layout_tstring: LayoutTstring,
    #[doc = "The absolute physical limit on the number of Abstract Syntax Tree nodes allowed in the layout template, preventing UI Layout Bombing."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_ast_node_budget: ::std::option::Option<::std::num::NonZeroU64>,
}
impl DynamicLayoutManifest {
    pub fn builder() -> builder::DynamicLayoutManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Provides the rendering matrix that translates the swarm's physics into human retinal variables using the Grammar of Graphics and Semantic Zooming.\n\nCAUSAL AFFORDANCE: Maps N-dimensional capabilities onto the UI plane without breaking semantic causal edges.\n\nEPISTEMIC BOUNDS: Binds an AST gradient and thermodynamic burn metric, governed by a physical zoom profile limit. Discriminator locked to `Literal[\"dynamic_manifold\"]`.\n\nMCP ROUTING TRIGGERS: Grammar of Graphics, Retinal Variables, UI Rendering, Semantic Zooming, Dynamic Manifold"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DynamicManifoldProjectionManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Provides the rendering matrix that translates the swarm's physics into human retinal variables using the Grammar of Graphics and Semantic Zooming.\\n\\nCAUSAL AFFORDANCE: Maps N-dimensional capabilities onto the UI plane without breaking semantic causal edges.\\n\\nEPISTEMIC BOUNDS: Binds an AST gradient and thermodynamic burn metric, governed by a physical zoom profile limit. Discriminator locked to `Literal[\\\"dynamic_manifold\\\"]`.\\n\\nMCP ROUTING TRIGGERS: Grammar of Graphics, Retinal Variables, UI Rendering, Semantic Zooming, Dynamic Manifold\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"active_forge_cid\","]
#[doc = "    \"ast_gradient_visual_mapping\","]
#[doc = "    \"manifest_cid\","]
#[doc = "    \"thermodynamic_burn_mapping\","]
#[doc = "    \"viewport_zoom_profile\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"active_forge_cid\": {"]
#[doc = "      \"title\": \"Active Forge Cid\","]
#[doc = "      \"description\": \"A pointer to the CapabilityForgeTopologyManifest currently executing.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"ast_gradient_visual_mapping\": {"]
#[doc = "      \"description\": \"Algebraically maps the ASTGradientReceipt loss vectors into a 2D plot.\","]
#[doc = "      \"$ref\": \"#/$defs/GrammarPanelProfile\""]
#[doc = "    },"]
#[doc = "    \"manifest_cid\": {"]
#[doc = "      \"title\": \"Manifest Cid\","]
#[doc = "      \"description\": \"Unique identifier for this projection.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"thermodynamic_burn_mapping\": {"]
#[doc = "      \"description\": \"Tracks the KinematicDeltaManifest against the human's allocated_budget_magnitude.\","]
#[doc = "      \"$ref\": \"#/$defs/AnyPanelProfile\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for the dynamic manifold projection.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"dynamic_manifold\""]
#[doc = "    },"]
#[doc = "    \"viewport_zoom_profile\": {"]
#[doc = "      \"description\": \"Governs Spectral Graph Coarsening as the human alters their Euclidean distance from the graph.\","]
#[doc = "      \"$ref\": \"#/$defs/SemanticZoomProfile\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DynamicManifoldProjectionManifest {
    #[doc = "A pointer to the CapabilityForgeTopologyManifest currently executing."]
    pub active_forge_cid: ActiveForgeCid,
    #[doc = "Algebraically maps the ASTGradientReceipt loss vectors into a 2D plot."]
    pub ast_gradient_visual_mapping: GrammarPanelProfile,
    #[doc = "Unique identifier for this projection."]
    pub manifest_cid: ManifestCid,
    #[doc = "Tracks the KinematicDeltaManifest against the human's allocated_budget_magnitude."]
    pub thermodynamic_burn_mapping: AnyPanelProfile,
    #[doc = "Discriminator for the dynamic manifold projection."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "Governs Spectral Graph Coarsening as the human alters their Euclidean distance from the graph."]
    pub viewport_zoom_profile: SemanticZoomProfile,
}
impl DynamicManifoldProjectionManifest {
    pub fn builder() -> builder::DynamicManifoldProjectionManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements a deterministic Softmax Router Gate to dictate the exact active execution topology, mapping multi-agent subgraphs to specific data modalities.\n\nCAUSAL AFFORDANCE: Physically directs the thermodynamic compute flow, unlocking specific worker nodes (active_subgraphs) and explicitly bypassing others (bypassed_steps), while locking economic allocations via branch_budgets_magnitude.\n\nEPISTEMIC BOUNDS: The @model_validator hooks mathematically verify topological soundness: validate_modality_alignment proves no routes to hallucinated modalities exist, and validate_conservation_of_custody ensures bypassed_steps perfectly align with the artifact_event_cid.\n\nMCP ROUTING TRIGGERS: Softmax Router Gate, Sparse Mixture of Experts, Conservation of Custody, Topos Theory, Spot Compute Allocation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"DynamicRoutingManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements a deterministic Softmax Router Gate to dictate the exact active execution topology, mapping multi-agent subgraphs to specific data modalities.\\n\\nCAUSAL AFFORDANCE: Physically directs the thermodynamic compute flow, unlocking specific worker nodes (active_subgraphs) and explicitly bypassing others (bypassed_steps), while locking economic allocations via branch_budgets_magnitude.\\n\\nEPISTEMIC BOUNDS: The @model_validator hooks mathematically verify topological soundness: validate_modality_alignment proves no routes to hallucinated modalities exist, and validate_conservation_of_custody ensures bypassed_steps perfectly align with the artifact_event_cid.\\n\\nMCP ROUTING TRIGGERS: Softmax Router Gate, Sparse Mixture of Experts, Conservation of Custody, Topos Theory, Spot Compute Allocation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"active_subgraphs\","]
#[doc = "    \"artifact_profile\","]
#[doc = "    \"branch_budgets_magnitude\","]
#[doc = "    \"manifest_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"active_subgraphs\": {"]
#[doc = "      \"title\": \"Active Subgraphs\","]
#[doc = "      \"description\": \"Mapping of specific modalities (e.g., 'tabular_grid') to the explicit lists of worker NodeIdentifierStates authorized to execute.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"array\","]
#[doc = "        \"items\": {"]
#[doc = "          \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "        }"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"artifact_profile\": {"]
#[doc = "      \"description\": \"The semantic profile governing this route.\","]
#[doc = "      \"$ref\": \"#/$defs/GlobalSemanticProfile\""]
#[doc = "    },"]
#[doc = "    \"branch_budgets_magnitude\": {"]
#[doc = "      \"title\": \"Branch Budgets Magnitude\","]
#[doc = "      \"description\": \"The strict allocation of compute budget bound to specific nodes.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"integer\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"bypassed_steps\": {"]
#[doc = "      \"title\": \"Bypassed Steps\","]
#[doc = "      \"description\": \"The declarative array of steps the orchestrator is mandated to skip.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/BypassReceipt\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"manifest_cid\": {"]
#[doc = "      \"title\": \"Manifest Cid\","]
#[doc = "      \"description\": \"The unique Content Identifier (CID) for this routing plan.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct DynamicRoutingManifest {
    #[doc = "Mapping of specific modalities (e.g., 'tabular_grid') to the explicit lists of worker NodeIdentifierStates authorized to execute."]
    pub active_subgraphs:
        ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<NodeCidState>>,
    #[doc = "The semantic profile governing this route."]
    pub artifact_profile: GlobalSemanticProfile,
    #[doc = "The strict allocation of compute budget bound to specific nodes."]
    pub branch_budgets_magnitude: ::std::collections::HashMap<::std::string::String, i64>,
    #[doc = "The declarative array of steps the orchestrator is mandated to skip."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub bypassed_steps: ::std::vec::Vec<BypassReceipt>,
    #[doc = "The unique Content Identifier (CID) for this routing plan."]
    pub manifest_cid: ManifestCid,
}
impl DynamicRoutingManifest {
    pub fn builder() -> builder::DynamicRoutingManifest {
        Default::default()
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this semantic edge to the Merkle-DAG."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Edge Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this semantic edge to the Merkle-DAG.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct EdgeCid(::std::string::String);
impl ::std::ops::Deref for EdgeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<EdgeCid> for ::std::string::String {
    fn from(value: EdgeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for EdgeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for EdgeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EdgeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EdgeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for EdgeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The specific Pearlian topological relationship between the two variables."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Edge Class\","]
#[doc = "  \"description\": \"The specific Pearlian topological relationship between the two variables.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"direct_cause\","]
#[doc = "    \"confounder\","]
#[doc = "    \"collider\","]
#[doc = "    \"mediator\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum EdgeClass {
    #[serde(rename = "direct_cause")]
    DirectCause,
    #[serde(rename = "confounder")]
    Confounder,
    #[serde(rename = "collider")]
    Collider,
    #[serde(rename = "mediator")]
    Mediator,
}
impl ::std::fmt::Display for EdgeClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::DirectCause => f.write_str("direct_cause"),
            Self::Confounder => f.write_str("confounder"),
            Self::Collider => f.write_str("collider"),
            Self::Mediator => f.write_str("mediator"),
        }
    }
}
impl ::std::str::FromStr for EdgeClass {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "direct_cause" => Ok(Self::DirectCause),
            "confounder" => Ok(Self::Confounder),
            "collider" => Ok(Self::Collider),
            "mediator" => Ok(Self::Mediator),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for EdgeClass {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EdgeClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EdgeClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes a Profunctor Optics (Lenses) mapping between\ndisjoint capabilities without computational glue logic. As a ...Contract suffix,\nthis creates a rigid algebraic boundary.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator's state projection engine to\nsafely project the Covariant output of a source node into the Contravariant\ninput of a target node using pure mathematical mappings.\n\nEPISTEMIC BOUNDS: The mapping uses RFC 6902 JSON Pointers (source_pointer and\ntarget_pointer) to extract and inject data, bounded by 2000-character limits.\n\nMCP ROUTING TRIGGERS: Category Theory, Profunctor Optics, Bijective Mapping,\nAlgebraic Translation, Lens, Prism"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EdgeMappingContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes a Profunctor Optics (Lenses) mapping between\\ndisjoint capabilities without computational glue logic. As a ...Contract suffix,\\nthis creates a rigid algebraic boundary.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator's state projection engine to\\nsafely project the Covariant output of a source node into the Contravariant\\ninput of a target node using pure mathematical mappings.\\n\\nEPISTEMIC BOUNDS: The mapping uses RFC 6902 JSON Pointers (source_pointer and\\ntarget_pointer) to extract and inject data, bounded by 2000-character limits.\\n\\nMCP ROUTING TRIGGERS: Category Theory, Profunctor Optics, Bijective Mapping,\\nAlgebraic Translation, Lens, Prism\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"source_pointer\","]
#[doc = "    \"target_pointer\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"source_pointer\": {"]
#[doc = "      \"title\": \"Source Pointer\","]
#[doc = "      \"description\": \"The RFC 6902 JSON Pointer extracting the Covariant output.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"target_pointer\": {"]
#[doc = "      \"title\": \"Target Pointer\","]
#[doc = "      \"description\": \"The RFC 6902 JSON Pointer injecting into the Contravariant input.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EdgeMappingContract {
    #[doc = "The RFC 6902 JSON Pointer extracting the Covariant output."]
    pub source_pointer: SourcePointer,
    #[doc = "The RFC 6902 JSON Pointer injecting into the Contravariant input."]
    pub target_pointer: TargetPointer,
}
impl EdgeMappingContract {
    pub fn builder() -> builder::EdgeMappingContract {
        Default::default()
    }
}
#[doc = "How to flatten SemanticEdgeState."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Edge Projection Mode\","]
#[doc = "  \"description\": \"How to flatten SemanticEdgeState.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"adjacency_matrix\","]
#[doc = "    \"map_array\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum EdgeProjectionMode {
    #[serde(rename = "adjacency_matrix")]
    AdjacencyMatrix,
    #[serde(rename = "map_array")]
    MapArray,
}
impl ::std::fmt::Display for EdgeProjectionMode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::AdjacencyMatrix => f.write_str("adjacency_matrix"),
            Self::MapArray => f.write_str("map_array"),
        }
    }
}
impl ::std::str::FromStr for EdgeProjectionMode {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "adjacency_matrix" => Ok(Self::AdjacencyMatrix),
            "map_array" => Ok(Self::MapArray),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for EdgeProjectionMode {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EdgeProjectionMode {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EdgeProjectionMode {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "Target serialization format."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Egress Format\","]
#[doc = "  \"description\": \"Target serialization format.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"turtle\","]
#[doc = "    \"xml\","]
#[doc = "    \"json-ld\","]
#[doc = "    \"ntriples\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum EgressFormat {
    #[serde(rename = "turtle")]
    Turtle,
    #[serde(rename = "xml")]
    Xml,
    #[serde(rename = "json-ld")]
    JsonLd,
    #[serde(rename = "ntriples")]
    Ntriples,
}
impl ::std::fmt::Display for EgressFormat {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Turtle => f.write_str("turtle"),
            Self::Xml => f.write_str("xml"),
            Self::JsonLd => f.write_str("json-ld"),
            Self::Ntriples => f.write_str("ntriples"),
        }
    }
}
impl ::std::str::FromStr for EgressFormat {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "turtle" => Ok(Self::Turtle),
            "xml" => Ok(Self::Xml),
            "json-ld" => Ok(Self::JsonLd),
            "ntriples" => Ok(Self::Ntriples),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for EgressFormat {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EgressFormat {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EgressFormat {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Multimodal Sensor Fusion by quantifying Bayesian Surprise (KL Divergence) against the agent's prior belief manifold.\n\nCAUSAL AFFORDANCE: Emits a quantified sensory vector to the orchestrator, determining whether an exogenous signal contains enough information-theoretic value to cross the continuous-to-discrete gap and trigger a topological observation.\n\nEPISTEMIC BOUNDS: The bayesian_surprise_score is strictly clamped to a continuous float space (le=1.0), and physical presence is bounded by temporal_duration_ms (le=18446744073709551615).\n\nMCP ROUTING TRIGGERS: Bayesian Surprise, Multimodal Sensor Fusion, Kullback-Leibler Divergence, Exteroceptive Vector, Proprioception"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EmbodiedSensoryVectorProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Multimodal Sensor Fusion by quantifying Bayesian Surprise (KL Divergence) against the agent's prior belief manifold.\\n\\nCAUSAL AFFORDANCE: Emits a quantified sensory vector to the orchestrator, determining whether an exogenous signal contains enough information-theoretic value to cross the continuous-to-discrete gap and trigger a topological observation.\\n\\nEPISTEMIC BOUNDS: The bayesian_surprise_score is strictly clamped to a continuous float space (le=1.0), and physical presence is bounded by temporal_duration_ms (le=18446744073709551615).\\n\\nMCP ROUTING TRIGGERS: Bayesian Surprise, Multimodal Sensor Fusion, Kullback-Leibler Divergence, Exteroceptive Vector, Proprioception\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"bayesian_surprise_score\","]
#[doc = "    \"sensory_modality\","]
#[doc = "    \"temporal_duration_ms\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"bayesian_surprise_score\": {"]
#[doc = "      \"title\": \"Bayesian Surprise Score\","]
#[doc = "      \"description\": \"The calculated KL divergence between the prior belief and the incoming structural evidence.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"salience_threshold_breached\": {"]
#[doc = "      \"title\": \"Salience Threshold Breached\","]
#[doc = "      \"description\": \"Continuous-to-Discrete Crystallization threshold being crossed.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"sensory_modality\": {"]
#[doc = "      \"title\": \"Sensory Modality\","]
#[doc = "      \"description\": \"Multimodal Sensor Fusion and Spatial-Temporal Bindings representing Proprioceptive State and Exteroceptive Vectors.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"video\","]
#[doc = "        \"audio\","]
#[doc = "        \"spatial_telemetry\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"temporal_duration_ms\": {"]
#[doc = "      \"title\": \"Temporal Duration Ms\","]
#[doc = "      \"description\": \"The exact length of the timeline encapsulated by this observation.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EmbodiedSensoryVectorProfile {
    #[doc = "The calculated KL divergence between the prior belief and the incoming structural evidence."]
    pub bayesian_surprise_score: f64,
    #[doc = "Continuous-to-Discrete Crystallization threshold being crossed."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub salience_threshold_breached: ::std::option::Option<bool>,
    #[doc = "Multimodal Sensor Fusion and Spatial-Temporal Bindings representing Proprioceptive State and Exteroceptive Vectors."]
    pub sensory_modality: SensoryModality,
    #[doc = "The exact length of the timeline encapsulated by this observation."]
    pub temporal_duration_ms: ::std::num::NonZeroU64,
}
impl EmbodiedSensoryVectorProfile {
    pub fn builder() -> builder::EmbodiedSensoryVectorProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Enforces strict Popperian Falsificationism by defining the exact empirical boundary conditions that would logically invalidate a non-monotonic causal hypothesis.\n\nCAUSAL AFFORDANCE: Provides the deterministic pattern-matching criteria (`falsifying_observation_signature`) that triggers a DefeasibleCascadeEvent, instantly quarantining the collapsed subgraph if met.\n\nEPISTEMIC BOUNDS: Limits the falsification logic to a strictly typed `condition_cid` (`max_length=128`) and physically binds the empirical test to an explicit `required_tool_name` (`max_length=2000`) to prevent unbounded or hallucinated search spaces.\n\nMCP ROUTING TRIGGERS: Popperian Falsification, Null Hypothesis, Defeasible Logic, Empirical Falsifiability, Structural Boundary"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EmpiricalFalsificationContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Enforces strict Popperian Falsificationism by defining the exact empirical boundary conditions that would logically invalidate a non-monotonic causal hypothesis.\\n\\nCAUSAL AFFORDANCE: Provides the deterministic pattern-matching criteria (`falsifying_observation_signature`) that triggers a DefeasibleCascadeEvent, instantly quarantining the collapsed subgraph if met.\\n\\nEPISTEMIC BOUNDS: Limits the falsification logic to a strictly typed `condition_cid` (`max_length=128`) and physically binds the empirical test to an explicit `required_tool_name` (`max_length=2000`) to prevent unbounded or hallucinated search spaces.\\n\\nMCP ROUTING TRIGGERS: Popperian Falsification, Null Hypothesis, Defeasible Logic, Empirical Falsifiability, Structural Boundary\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"condition_cid\","]
#[doc = "    \"description\","]
#[doc = "    \"falsifying_observation_signature\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"condition_cid\": {"]
#[doc = "      \"title\": \"Condition Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this falsification test to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"description\": {"]
#[doc = "      \"title\": \"Description\","]
#[doc = "      \"description\": \"Semantic description of what observation would prove the parent hypothesis is false.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"falsifying_observation_signature\": {"]
#[doc = "      \"title\": \"Falsifying Observation Signature\","]
#[doc = "      \"description\": \"The expected data schema or regex pattern that, if returned by the tool, kills the hypothesis.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"required_tool_name\": {"]
#[doc = "      \"title\": \"Required Tool Name\","]
#[doc = "      \"description\": \"The specific CognitiveActionSpaceManifest tool required to test this condition (e.g., 'sql_query_db').\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for empirical falsification contract.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"empirical_falsification_contract\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EmpiricalFalsificationContract {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this falsification test to the Merkle-DAG."]
    pub condition_cid: ConditionCid,
    #[doc = "Semantic description of what observation would prove the parent hypothesis is false."]
    pub description: Description,
    #[doc = "The expected data schema or regex pattern that, if returned by the tool, kills the hypothesis."]
    pub falsifying_observation_signature: FalsifyingObservationSignature,
    #[doc = "The specific CognitiveActionSpaceManifest tool required to test this condition (e.g., 'sql_query_db')."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub required_tool_name: ::std::option::Option<::std::string::String>,
    #[doc = "Discriminator type for empirical falsification contract."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl EmpiricalFalsificationContract {
    pub fn builder() -> builder::EmpiricalFalsificationContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: An explicit mathematical boundary extracted from text that limits the certainty or scope of a proposition. Physically prevents agents from performing epistemic smoothing.\n\n    CAUSAL AFFORDANCE: Physically authorizes the orchestrator to impose explicit mathematical boundaries on propositions.\n\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\n\n    MCP ROUTING TRIGGERS: Empirical Statistics, Mathematical Boundary, Epistemic Smoothing, Proposition Certainty"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EmpiricalStatisticalProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: An explicit mathematical boundary extracted from text that limits the certainty or scope of a proposition. Physically prevents agents from performing epistemic smoothing.\\n\\n    CAUSAL AFFORDANCE: Physically authorizes the orchestrator to impose explicit mathematical boundaries on propositions.\\n\\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\\n\\n    MCP ROUTING TRIGGERS: Empirical Statistics, Mathematical Boundary, Epistemic Smoothing, Proposition Certainty\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"algebraic_operator\","]
#[doc = "    \"qualifier_type\","]
#[doc = "    \"value\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"algebraic_operator\": {"]
#[doc = "      \"title\": \"Algebraic Operator\","]
#[doc = "      \"description\": \"The mathematical operator applying to the value.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"eq\","]
#[doc = "        \"lt\","]
#[doc = "        \"le\","]
#[doc = "        \"gt\","]
#[doc = "        \"ge\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"lower_bound\": {"]
#[doc = "      \"title\": \"Lower Bound\","]
#[doc = "      \"description\": \"Used exclusively for geometric/statistical intervals.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"qualifier_type\": {"]
#[doc = "      \"title\": \"Qualifier Type\","]
#[doc = "      \"description\": \"A universal automaton classifying the type of statistical boundary.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"probability_value\","]
#[doc = "        \"sample_size\","]
#[doc = "        \"variance_metric\","]
#[doc = "        \"effect_size\","]
#[doc = "        \"confidence_interval\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"upper_bound\": {"]
#[doc = "      \"title\": \"Upper Bound\","]
#[doc = "      \"description\": \"Used exclusively for geometric/statistical intervals.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"value\": {"]
#[doc = "      \"title\": \"Value\","]
#[doc = "      \"description\": \"The primary scalar boundary for the qualifier.\","]
#[doc = "      \"type\": \"number\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EmpiricalStatisticalProfile {
    #[doc = "The mathematical operator applying to the value."]
    pub algebraic_operator: AlgebraicOperator,
    #[doc = "Used exclusively for geometric/statistical intervals."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub lower_bound: ::std::option::Option<f64>,
    #[doc = "A universal automaton classifying the type of statistical boundary."]
    pub qualifier_type: QualifierType,
    #[doc = "Used exclusively for geometric/statistical intervals."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub upper_bound: ::std::option::Option<f64>,
    #[doc = "The primary scalar boundary for the qualifier."]
    pub value: f64,
}
impl EmpiricalStatisticalProfile {
    pub fn builder() -> builder::EmpiricalStatisticalProfile {
        Default::default()
    }
}
#[doc = "The URN representing the physical silicon architecture generating the root-of-trust quote (e.g., 'urn:coreason:enclave:intel_tdx')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Enclave Class\","]
#[doc = "  \"description\": \"The URN representing the physical silicon architecture generating the root-of-trust quote (e.g., 'urn:coreason:enclave:intel_tdx').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct EnclaveClass(::std::string::String);
impl ::std::ops::Deref for EnclaveClass {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<EnclaveClass> for ::std::string::String {
    fn from(value: EnclaveClass) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for EnclaveClass {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^urn:coreason:.*$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^urn:coreason:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for EnclaveClass {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EnclaveClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EnclaveClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for EnclaveClass {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The deterministic action the orchestrator must take if a bipartite cycle is detected."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Enforcement Action\","]
#[doc = "  \"description\": \"The deterministic action the orchestrator must take if a bipartite cycle is detected.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"halt_and_quarantine\","]
#[doc = "    \"sever_causal_chain\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum EnforcementAction {
    #[serde(rename = "halt_and_quarantine")]
    HaltAndQuarantine,
    #[serde(rename = "sever_causal_chain")]
    SeverCausalChain,
}
impl ::std::fmt::Display for EnforcementAction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::HaltAndQuarantine => f.write_str("halt_and_quarantine"),
            Self::SeverCausalChain => f.write_str("sever_causal_chain"),
        }
    }
}
impl ::std::str::FromStr for EnforcementAction {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "halt_and_quarantine" => Ok(Self::HaltAndQuarantine),
            "sever_causal_chain" => Ok(Self::SeverCausalChain),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for EnforcementAction {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EnforcementAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EnforcementAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The mechanistic strategy for intercepting the LLM forward pass."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Enforcement Strategy\","]
#[doc = "  \"description\": \"The mechanistic strategy for intercepting the LLM forward pass.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"fsm_logit_mask\","]
#[doc = "    \"lmql_query\","]
#[doc = "    \"guidance_program\","]
#[doc = "    \"ebnf_grammar\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum EnforcementStrategy {
    #[serde(rename = "fsm_logit_mask")]
    FsmLogitMask,
    #[serde(rename = "lmql_query")]
    LmqlQuery,
    #[serde(rename = "guidance_program")]
    GuidanceProgram,
    #[serde(rename = "ebnf_grammar")]
    EbnfGrammar,
}
impl ::std::fmt::Display for EnforcementStrategy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::FsmLogitMask => f.write_str("fsm_logit_mask"),
            Self::LmqlQuery => f.write_str("lmql_query"),
            Self::GuidanceProgram => f.write_str("guidance_program"),
            Self::EbnfGrammar => f.write_str("ebnf_grammar"),
        }
    }
}
impl ::std::str::FromStr for EnforcementStrategy {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "fsm_logit_mask" => Ok(Self::FsmLogitMask),
            "lmql_query" => Ok(Self::LmqlQuery),
            "guidance_program" => Ok(Self::GuidanceProgram),
            "ebnf_grammar" => Ok(Self::EbnfGrammar),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for EnforcementStrategy {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EnforcementStrategy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EnforcementStrategy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Ensemble Learning and Quantum-like Superposition to evaluate multiple divergent reasoning topologies simultaneously before collapsing them into a singular truth.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator to execute the specified concurrent branches in parallel, holding the state in superposition until the fusion function mathematically collapses the wave.\n\nEPISTEMIC BOUNDS: Requires a minimum of 2 concurrent branches (minItems=2). The wave-collapse opcode is strictly limited to the Literal FSM [\"weighted_consensus\", \"highest_confidence\", \"brier_score_collapse\"]. The @model_validator guarantees invariant RFC 8785 canonical hashing by sorting the DIDs.\n\nMCP ROUTING TRIGGERS: Ensemble Learning, Superposition Wave Collapse, Brier Score, Parallel Execution, Condorcet's Jury Theorem"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EnsembleTopologyProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Ensemble Learning and Quantum-like Superposition to evaluate multiple divergent reasoning topologies simultaneously before collapsing them into a singular truth.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator to execute the specified concurrent branches in parallel, holding the state in superposition until the fusion function mathematically collapses the wave.\\n\\nEPISTEMIC BOUNDS: Requires a minimum of 2 concurrent branches (minItems=2). The wave-collapse opcode is strictly limited to the Literal FSM [\\\"weighted_consensus\\\", \\\"highest_confidence\\\", \\\"brier_score_collapse\\\"]. The @model_validator guarantees invariant RFC 8785 canonical hashing by sorting the DIDs.\\n\\nMCP ROUTING TRIGGERS: Ensemble Learning, Superposition Wave Collapse, Brier Score, Parallel Execution, Condorcet's Jury Theorem\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"concurrent_branch_cids\","]
#[doc = "    \"fusion_function\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"concurrent_branch_cids\": {"]
#[doc = "      \"title\": \"Concurrent Branch Cids\","]
#[doc = "      \"description\": \"The strict array of strict W3C DIDs (NodeIdentifierStates) representing concurrent topology branches.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 2"]
#[doc = "    },"]
#[doc = "    \"fusion_function\": {"]
#[doc = "      \"title\": \"Fusion Function\","]
#[doc = "      \"description\": \"The explicit wave-collapse opcode dictating the resolution of concurrent branches.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"weighted_consensus\","]
#[doc = "        \"highest_confidence\","]
#[doc = "        \"brier_score_collapse\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EnsembleTopologyProfile {
    #[doc = "The strict array of strict W3C DIDs (NodeIdentifierStates) representing concurrent topology branches."]
    pub concurrent_branch_cids: ::std::vec::Vec<NodeCidState>,
    #[doc = "The explicit wave-collapse opcode dictating the resolution of concurrent branches."]
    pub fusion_function: FusionFunction,
}
impl EnsembleTopologyProfile {
    pub fn builder() -> builder::EnsembleTopologyProfile {
        Default::default()
    }
}
#[doc = "Defines the initial state (S_0) of the MDP."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Entry Point Cid\","]
#[doc = "  \"description\": \"Defines the initial state (S_0) of the MDP.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct EntryPointCid(::std::string::String);
impl ::std::ops::Deref for EntryPointCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<EntryPointCid> for ::std::string::String {
    fn from(value: EntryPointCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for EntryPointCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for EntryPointCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EntryPointCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EntryPointCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for EntryPointCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SHA-256 hash of the state-space context matrix."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Env Variables Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the state-space context matrix.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct EnvVariablesHash(::std::string::String);
impl ::std::ops::Deref for EnvVariablesHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<EnvVariablesHash> for ::std::string::String {
    fn from(value: EnvVariablesHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for EnvVariablesHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for EnvVariablesHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EnvVariablesHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EnvVariablesHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for EnvVariablesHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements a hardware-level Sandboxing and Trusted Execution Environment (TEE) paradigm, utilizing WASI, eBPF, or zkVMs to safely execute exogenous bytecode.\n\nCAUSAL AFFORDANCE: Physically isolates kinetic execution from the host OS via `execution_runtime` Literal `[\"wasm32-wasi\", \"riscv32-zkvm\", \"bpf\"]`, authorizing the orchestrator to instantiate a temporary virtual machine strictly conforming to bounded network egress and subprocess rules.\n\nEPISTEMIC BOUNDS: The Halting Problem is managed via `max_ttl_seconds` (`le=18446744073709551615, gt=0`), and memory exhaustion is prevented via `max_vram_mb` (`le=18446744073709551615, gt=0`). The `@model_validator` enforces SHA-256 regex on `authorized_bytecode_hashes` and sorts them deterministically.\n\nMCP ROUTING TRIGGERS: WebAssembly System Interface, Zero-Knowledge Virtual Machine, eBPF, Execution Sandbox, Arbitrary Code Execution Mitigation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EphemeralNamespacePartitionState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements a hardware-level Sandboxing and Trusted Execution Environment (TEE) paradigm, utilizing WASI, eBPF, or zkVMs to safely execute exogenous bytecode.\\n\\nCAUSAL AFFORDANCE: Physically isolates kinetic execution from the host OS via `execution_runtime` Literal `[\\\"wasm32-wasi\\\", \\\"riscv32-zkvm\\\", \\\"bpf\\\"]`, authorizing the orchestrator to instantiate a temporary virtual machine strictly conforming to bounded network egress and subprocess rules.\\n\\nEPISTEMIC BOUNDS: The Halting Problem is managed via `max_ttl_seconds` (`le=18446744073709551615, gt=0`), and memory exhaustion is prevented via `max_vram_mb` (`le=18446744073709551615, gt=0`). The `@model_validator` enforces SHA-256 regex on `authorized_bytecode_hashes` and sorts them deterministically.\\n\\nMCP ROUTING TRIGGERS: WebAssembly System Interface, Zero-Knowledge Virtual Machine, eBPF, Execution Sandbox, Arbitrary Code Execution Mitigation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"authorized_bytecode_hashes\","]
#[doc = "    \"execution_runtime\","]
#[doc = "    \"max_ttl_seconds\","]
#[doc = "    \"max_vram_mb\","]
#[doc = "    \"partition_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"allow_network_egress\": {"]
#[doc = "      \"title\": \"Allow Network Egress\","]
#[doc = "      \"description\": \"Capability-based flag to allow or mathematically deny network sockets.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"allow_subprocess_spawning\": {"]
#[doc = "      \"title\": \"Allow Subprocess Spawning\","]
#[doc = "      \"description\": \"Capability-based flag to allow or deny OS-level process spawning.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"authorized_bytecode_hashes\": {"]
#[doc = "      \"title\": \"Authorized Bytecode Hashes\","]
#[doc = "      \"description\": \"The explicit whitelist of SHA-256 hashes allowed to execute within this partition.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1"]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"execution_runtime\": {"]
#[doc = "      \"title\": \"Execution Runtime\","]
#[doc = "      \"description\": \"The strict virtual machine target mandated for dynamic execution.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"wasm32-wasi\","]
#[doc = "        \"riscv32-zkvm\","]
#[doc = "        \"bpf\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_ttl_seconds\": {"]
#[doc = "      \"title\": \"Max Ttl Seconds\","]
#[doc = "      \"description\": \"The absolute temporal guillotine before the orchestrator drops the context.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"max_vram_mb\": {"]
#[doc = "      \"title\": \"Max Vram Mb\","]
#[doc = "      \"description\": \"The strict physical VRAM ceiling allocated to this partition.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"partition_cid\": {"]
#[doc = "      \"title\": \"Partition Cid\","]
#[doc = "      \"description\": \"Unique identifier for this ephemeral partition.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for an ephemeral namespace partition.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"ephemeral_partition\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EphemeralNamespacePartitionState {
    #[doc = "Capability-based flag to allow or mathematically deny network sockets."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub allow_network_egress: ::std::option::Option<bool>,
    #[doc = "Capability-based flag to allow or deny OS-level process spawning."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub allow_subprocess_spawning: ::std::option::Option<bool>,
    #[doc = "The explicit whitelist of SHA-256 hashes allowed to execute within this partition."]
    pub authorized_bytecode_hashes: ::std::vec::Vec<AuthorizedBytecodeHashesItem>,
    #[doc = "The strict virtual machine target mandated for dynamic execution."]
    pub execution_runtime: ExecutionRuntime,
    #[doc = "The absolute temporal guillotine before the orchestrator drops the context."]
    pub max_ttl_seconds: ::std::num::NonZeroU64,
    #[doc = "The strict physical VRAM ceiling allocated to this partition."]
    pub max_vram_mb: ::std::num::NonZeroU64,
    #[doc = "Unique identifier for this ephemeral partition."]
    pub partition_cid: PartitionCid,
    #[doc = "Discriminator type for an ephemeral namespace partition."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl EphemeralNamespacePartitionState {
    pub fn builder() -> builder::EphemeralNamespacePartitionState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements a discrete node $A \\in AR$ within Dung's Abstract Argumentation Framework. As a ...State suffix, this is a declarative, frozen snapshot of a falsifiable proposition at a specific point in time.\n\nCAUSAL AFFORDANCE: Acts as the primary target for DefeasibleAttackEvent undercutting. Successfully defending this claim stabilizes the probability mass, allowing it to serve as a premise in the Grounded Extension.\n\nEPISTEMIC BOUNDS: The proposition payload (`text_chunk`) is mathematically capped at `max_length=50000`. The internal `warrants` array is deterministically sorted by the `justification` field via a `@model_validator` to preserve RFC 8785 canonical hashing. The `proponent_cid` is bounded to a 128-char CID.\n\nMCP ROUTING TRIGGERS: Dung's AAF, Defeasible Logic, Abstract Argumentation, Non-Monotonic Node, Grounded Extension Premise"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicArgumentClaimState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements a discrete node $A \\\\in AR$ within Dung's Abstract Argumentation Framework. As a ...State suffix, this is a declarative, frozen snapshot of a falsifiable proposition at a specific point in time.\\n\\nCAUSAL AFFORDANCE: Acts as the primary target for DefeasibleAttackEvent undercutting. Successfully defending this claim stabilizes the probability mass, allowing it to serve as a premise in the Grounded Extension.\\n\\nEPISTEMIC BOUNDS: The proposition payload (`text_chunk`) is mathematically capped at `max_length=50000`. The internal `warrants` array is deterministically sorted by the `justification` field via a `@model_validator` to preserve RFC 8785 canonical hashing. The `proponent_cid` is bounded to a 128-char CID.\\n\\nMCP ROUTING TRIGGERS: Dung's AAF, Defeasible Logic, Abstract Argumentation, Non-Monotonic Node, Grounded Extension Premise\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"claim_cid\","]
#[doc = "    \"proponent_cid\","]
#[doc = "    \"text_chunk\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"claim_cid\": {"]
#[doc = "      \"title\": \"Claim Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this specific logical proposition.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"proponent_cid\": {"]
#[doc = "      \"title\": \"Proponent Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the agent or system that advanced this claim.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"text_chunk\": {"]
#[doc = "      \"title\": \"Text Chunk\","]
#[doc = "      \"description\": \"The natural language representation of the proposition.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 50000"]
#[doc = "    },"]
#[doc = "    \"warrants\": {"]
#[doc = "      \"title\": \"Warrants\","]
#[doc = "      \"description\": \"The foundational premises supporting this claim.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EvidentiaryWarrantState\""]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicArgumentClaimState {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this specific logical proposition."]
    pub claim_cid: ClaimCid,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the agent or system that advanced this claim."]
    pub proponent_cid: ProponentCid,
    #[doc = "The natural language representation of the proposition."]
    pub text_chunk: TextChunk,
    #[doc = "The foundational premises supporting this claim."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub warrants: ::std::vec::Vec<EvidentiaryWarrantState>,
}
impl EpistemicArgumentClaimState {
    pub fn builder() -> builder::EpistemicArgumentClaimState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Constructs the macroscopic adjacency matrix for the complete $AF = \\langle AR, \\rightarrow \\rangle$ topology. As a ...State suffix, this is a declarative, frozen snapshot of the dialectical geometry.\n\nCAUSAL AFFORDANCE: Exposes the holistic bipartite mapping of claims and their defeasible attacks to the orchestrator, allowing graph traversal algorithms to deterministically compute the conflict-free Grounded Extension of surviving truths.\n\nEPISTEMIC BOUNDS: Physically limits state-space explosion by capping the `claims` and `attacks` dictionaries at `max_length=10000` keys each. Key geometries are strictly bounded to 255 characters to prevent Dictionary Bombing during canonicalization.\n\nMCP ROUTING TRIGGERS: Dung's AAF, Adjacency Matrix, Grounded Extension, State-Space Bounding, Dialectical Justification"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicArgumentGraphState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Constructs the macroscopic adjacency matrix for the complete $AF = \\\\langle AR, \\\\rightarrow \\\\rangle$ topology. As a ...State suffix, this is a declarative, frozen snapshot of the dialectical geometry.\\n\\nCAUSAL AFFORDANCE: Exposes the holistic bipartite mapping of claims and their defeasible attacks to the orchestrator, allowing graph traversal algorithms to deterministically compute the conflict-free Grounded Extension of surviving truths.\\n\\nEPISTEMIC BOUNDS: Physically limits state-space explosion by capping the `claims` and `attacks` dictionaries at `max_length=10000` keys each. Key geometries are strictly bounded to 255 characters to prevent Dictionary Bombing during canonicalization.\\n\\nMCP ROUTING TRIGGERS: Dung's AAF, Adjacency Matrix, Grounded Extension, State-Space Bounding, Dialectical Justification\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"claims\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"attacks\": {"]
#[doc = "      \"title\": \"Attacks\","]
#[doc = "      \"description\": \"Geometric matrices of undercutting defeaters.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 10000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/DefeasibleAttackEvent\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"claims\": {"]
#[doc = "      \"title\": \"Claims\","]
#[doc = "      \"description\": \"Components of an Abstract Argumentation Framework.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 10000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/EpistemicArgumentClaimState\""]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicArgumentGraphState {
    #[doc = "Geometric matrices of undercutting defeaters."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub attacks: ::std::collections::HashMap<::std::string::String, DefeasibleAttackEvent>,
    #[doc = "Components of an Abstract Argumentation Framework."]
    pub claims: ::std::collections::HashMap<::std::string::String, EpistemicArgumentClaimState>,
}
impl EpistemicArgumentGraphState {
    pub fn builder() -> builder::EpistemicArgumentGraphState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Joint Attention and Gaze Raycasting across the distributed topology. Projects a continuous vector from an observer's optical center to indicate cognitive focus prior to physical mutation.\n\nCAUSAL AFFORDANCE: Broadcasts a non-kinetic 'cursor presence' to the swarm. The orchestrator calculates the dot product between this vector and surrounding nodes, identifying the exact topological vertices the observer is currently evaluating.\n\nEPISTEMIC BOUNDS: The `direction_unit_vector` is mathematically normalized to exactly 1.0 via `@model_validator` to prevent raycast scalar explosions. To mitigate $O(N^2)$ intersection complexity, the `intersected_node_cids` array is strictly capped at `max_length=100` and deterministically sorted.\n\nMCP ROUTING TRIGGERS: Spatial Raycasting, Joint Attention, Cognitive Frustum Intersection, Vector Math, Gaze Tracking"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicAttentionState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Joint Attention and Gaze Raycasting across the distributed topology. Projects a continuous vector from an observer's optical center to indicate cognitive focus prior to physical mutation.\\n\\nCAUSAL AFFORDANCE: Broadcasts a non-kinetic 'cursor presence' to the swarm. The orchestrator calculates the dot product between this vector and surrounding nodes, identifying the exact topological vertices the observer is currently evaluating.\\n\\nEPISTEMIC BOUNDS: The `direction_unit_vector` is mathematically normalized to exactly 1.0 via `@model_validator` to prevent raycast scalar explosions. To mitigate $O(N^2)$ intersection complexity, the `intersected_node_cids` array is strictly capped at `max_length=100` and deterministically sorted.\\n\\nMCP ROUTING TRIGGERS: Spatial Raycasting, Joint Attention, Cognitive Frustum Intersection, Vector Math, Gaze Tracking\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"direction_unit_vector\","]
#[doc = "    \"origin\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"direction_unit_vector\": {"]
#[doc = "      \"title\": \"Direction Unit Vector\","]
#[doc = "      \"description\": \"The strictly normalized 3D directional vector representing the angle of gaze.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"maxItems\": 3,"]
#[doc = "      \"minItems\": 3,"]
#[doc = "      \"prefixItems\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"hardware_gaze_signature\": {"]
#[doc = "      \"title\": \"Hardware Gaze Signature\","]
#[doc = "      \"description\": \"Hardware-backed cryptographic proof of human eye-tracking from a Trusted Execution Environment (TEE), preventing bot-driven attention spoofing.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"intersected_node_cids\": {"]
#[doc = "      \"title\": \"Intersected Node Cids\","]
#[doc = "      \"description\": \"The array of topological vertices mathematically pierced by this attention ray.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "      },"]
#[doc = "      \"maxItems\": 100"]
#[doc = "    },"]
#[doc = "    \"origin\": {"]
#[doc = "      \"description\": \"The absolute SE(3) spatial coordinate representing the observer's optical center.\","]
#[doc = "      \"$ref\": \"#/$defs/SE3TransformProfile\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicAttentionState {
    #[doc = "The strictly normalized 3D directional vector representing the angle of gaze."]
    pub direction_unit_vector: [::serde_json::Value; 3usize],
    #[doc = "Hardware-backed cryptographic proof of human eye-tracking from a Trusted Execution Environment (TEE), preventing bot-driven attention spoofing."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub hardware_gaze_signature: ::std::option::Option<::std::string::String>,
    #[doc = "The array of topological vertices mathematically pierced by this attention ray."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub intersected_node_cids: ::std::vec::Vec<NodeCidState>,
    #[doc = "The absolute SE(3) spatial coordinate representing the observer's optical center."]
    pub origin: Se3TransformProfile,
}
impl EpistemicAttentionState {
    pub fn builder() -> builder::EpistemicAttentionState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements First-Order Logic and Resource Description Framework (RDF) triples to mathematically formalize knowledge. As a ...State suffix, this is a declarative, frozen snapshot of a specific causal connection.\n\nCAUSAL AFFORDANCE: Distills high-entropy natural language token streams into rigid, hashable causal edges (Subject, Predicate, Object), unlocking deterministic querying and Truth Maintenance System (TMS) traversals.\n\nEPISTEMIC BOUNDS: Source and target concept physical boundaries are strictly locked to 128-char CIDs matching the regex `^[a-zA-Z0-9_.:-]+$`. The `directed_edge_class` is clamped to a `max_length=2000` to prevent dictionary bombing during semantic evaluation.\n\nMCP ROUTING TRIGGERS: First-Order Logic, RDF Triple, Semantic Distillation, Causal Edge, Directed Graph"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicAxiomState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements First-Order Logic and Resource Description Framework (RDF) triples to mathematically formalize knowledge. As a ...State suffix, this is a declarative, frozen snapshot of a specific causal connection.\\n\\nCAUSAL AFFORDANCE: Distills high-entropy natural language token streams into rigid, hashable causal edges (Subject, Predicate, Object), unlocking deterministic querying and Truth Maintenance System (TMS) traversals.\\n\\nEPISTEMIC BOUNDS: Source and target concept physical boundaries are strictly locked to 128-char CIDs matching the regex `^[a-zA-Z0-9_.:-]+$`. The `directed_edge_class` is clamped to a `max_length=2000` to prevent dictionary bombing during semantic evaluation.\\n\\nMCP ROUTING TRIGGERS: First-Order Logic, RDF Triple, Semantic Distillation, Causal Edge, Directed Graph\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"directed_edge_class\","]
#[doc = "    \"source_concept_cid\","]
#[doc = "    \"target_concept_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"directed_edge_class\": {"]
#[doc = "      \"title\": \"Directed Edge Class\","]
#[doc = "      \"description\": \"The topological relationship.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"source_concept_cid\": {"]
#[doc = "      \"title\": \"Source Concept Cid\","]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring the origin node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_concept_cid\": {"]
#[doc = "      \"title\": \"Target Concept Cid\","]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring destination node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicAxiomState {
    #[doc = "The topological relationship."]
    pub directed_edge_class: DirectedEdgeClass,
    #[doc = "The globally unique decentralized identifier (DID) anchoring the origin node."]
    pub source_concept_cid: SourceConceptCid,
    #[doc = "The globally unique decentralized identifier (DID) anchoring destination node."]
    pub target_concept_cid: TargetConceptCid,
}
impl EpistemicAxiomState {
    pub fn builder() -> builder::EpistemicAxiomState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements automated Natural Language Inference (NLI) and Entailment Verification to mechanically quarantine hallucinated tokens. As a ...Receipt suffix, it represents an immutable cryptographic verdict.\n\nCAUSAL AFFORDANCE: Acts as the definitive logic gate for the Truth Maintenance System. If verification succeeds, it physically unlocks the promotion of the source prediction into the global semantic knowledge graph.\n\nEPISTEMIC BOUNDS: Factual alignment is geometrically bounded by sequence_similarity_score (ge=0.0, le=1.0). The @model_validator enforce_epistemic_quarantine deliberately crashes instantiation if fact_score_passed is False, physically severing the DAG to prevent epistemic contagion. Structural integrity mathematically demands that the `zero_trust_receipt_cid` be present to prove the generative extraction bypassed prompt injection boundaries.\n\nMCP ROUTING TRIGGERS: Entailment Verification, Natural Language Inference, Truth Maintenance System, Epistemic Quarantine, Hallucination Filtering"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicAxiomVerificationReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements automated Natural Language Inference (NLI) and Entailment Verification to mechanically quarantine hallucinated tokens. As a ...Receipt suffix, it represents an immutable cryptographic verdict.\\n\\nCAUSAL AFFORDANCE: Acts as the definitive logic gate for the Truth Maintenance System. If verification succeeds, it physically unlocks the promotion of the source prediction into the global semantic knowledge graph.\\n\\nEPISTEMIC BOUNDS: Factual alignment is geometrically bounded by sequence_similarity_score (ge=0.0, le=1.0). The @model_validator enforce_epistemic_quarantine deliberately crashes instantiation if fact_score_passed is False, physically severing the DAG to prevent epistemic contagion. Structural integrity mathematically demands that the `zero_trust_receipt_cid` be present to prove the generative extraction bypassed prompt injection boundaries.\\n\\nMCP ROUTING TRIGGERS: Entailment Verification, Natural Language Inference, Truth Maintenance System, Epistemic Quarantine, Hallucination Filtering\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"fact_score_passed\","]
#[doc = "    \"sequence_similarity_score\","]
#[doc = "    \"source_prediction_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"fact_score_passed\": {"]
#[doc = "      \"title\": \"Fact Score Passed\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"formal_backing_receipt_cid\": {"]
#[doc = "      \"description\": \"Cryptographic pointer to the deterministic Triad execution receipt (Proof-Carrying Data).\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"sequence_similarity_score\": {"]
#[doc = "      \"title\": \"Sequence Similarity Score\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"source_prediction_cid\": {"]
#[doc = "      \"title\": \"Source Prediction Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"epistemic_axiom_verification\""]
#[doc = "    },"]
#[doc = "    \"zero_trust_receipt_cid\": {"]
#[doc = "      \"title\": \"Zero Trust Receipt Cid\","]
#[doc = "      \"description\": \"The undeniable pointer proving the source prediction traversed the Zero-Trust contract before being verified as an axiom.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicAxiomVerificationReceipt {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    pub fact_score_passed: bool,
    #[doc = "Cryptographic pointer to the deterministic Triad execution receipt (Proof-Carrying Data)."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub formal_backing_receipt_cid: ::std::option::Option<NodeCidState>,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    pub sequence_similarity_score: f64,
    pub source_prediction_cid: SourcePredictionCid,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The undeniable pointer proving the source prediction traversed the Zero-Trust contract before being verified as an axiom."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub zero_trust_receipt_cid: ::std::option::Option<::std::string::String>,
}
impl EpistemicAxiomVerificationReceipt {
    pub fn builder() -> builder::EpistemicAxiomVerificationReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines a Markov Blanket formulation within an Abstract Argumentation Framework. Represents a frozen, declarative geometry of interconnected axioms binding semantic leaves to syntactic roots.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator to compute deterministic reachability matrices, tracing high-level syntactic claims back to their foundational semantic triples without invoking non-monotonic reasoning loops.\n\nEPISTEMIC BOUNDS: Bounded by a 128-char `chain_cid` CID. The `@model_validator` physically enforces cryptographic determinism by sorting the `semantic_leaves` array by the composite key (`source_concept_cid`, `directed_edge_class`, `target_concept_cid`), guaranteeing invariant RFC 8785 canonical hashing.\n\nMCP ROUTING TRIGGERS: Markov Blanket, Reachability Matrix, Abstract Argumentation, RFC 8785 Canonicalization, Graph Traversal"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicChainGraphState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines a Markov Blanket formulation within an Abstract Argumentation Framework. Represents a frozen, declarative geometry of interconnected axioms binding semantic leaves to syntactic roots.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator to compute deterministic reachability matrices, tracing high-level syntactic claims back to their foundational semantic triples without invoking non-monotonic reasoning loops.\\n\\nEPISTEMIC BOUNDS: Bounded by a 128-char `chain_cid` CID. The `@model_validator` physically enforces cryptographic determinism by sorting the `semantic_leaves` array by the composite key (`source_concept_cid`, `directed_edge_class`, `target_concept_cid`), guaranteeing invariant RFC 8785 canonical hashing.\\n\\nMCP ROUTING TRIGGERS: Markov Blanket, Reachability Matrix, Abstract Argumentation, RFC 8785 Canonicalization, Graph Traversal\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"chain_cid\","]
#[doc = "    \"semantic_leaves\","]
#[doc = "    \"syntactic_roots\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"chain_cid\": {"]
#[doc = "      \"title\": \"Chain Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"semantic_leaves\": {"]
#[doc = "      \"title\": \"Semantic Leaves\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EpistemicAxiomState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"syntactic_roots\": {"]
#[doc = "      \"title\": \"Syntactic Roots\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicChainGraphState {
    pub chain_cid: ChainCid,
    pub semantic_leaves: ::std::vec::Vec<EpistemicAxiomState>,
    pub syntactic_roots: ::std::vec::Vec<SyntacticRootsItem>,
}
impl EpistemicChainGraphState {
    pub fn builder() -> builder::EpistemicChainGraphState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements the Information Bottleneck Method to govern the\nlossy compression of episodic or multimodal payloads into structured semantic\ngeometry. As an ...SLA suffix, this enforces rigid mathematical boundaries.\n\nCAUSAL AFFORDANCE: Instructs the extraction and transmutation engines to discard\naleatoric noise while mathematically preserving the mutual information of the\nsource artifact. The strict_probability_retention (bool, default=True) forces\nthe resulting SemanticNodeState to populate its uncertainty_profile.\n\nEPISTEMIC BOUNDS: The informational loss is strictly bounded by\nmax_allowed_entropy_loss (ge=0.0, le=1.0), mathematically preventing the\nover-compression of truth. The required_grounding_density is locked to the\nLiteral automaton [\"sparse\", \"dense\", \"exhaustive\"].\n\nMCP ROUTING TRIGGERS: Information Bottleneck Method, Shannon Entropy Loss,\nSemantic Compression, Multimodal Grounding, Autoencoder Distillation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicCompressionSLA\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements the Information Bottleneck Method to govern the\\nlossy compression of episodic or multimodal payloads into structured semantic\\ngeometry. As an ...SLA suffix, this enforces rigid mathematical boundaries.\\n\\nCAUSAL AFFORDANCE: Instructs the extraction and transmutation engines to discard\\naleatoric noise while mathematically preserving the mutual information of the\\nsource artifact. The strict_probability_retention (bool, default=True) forces\\nthe resulting SemanticNodeState to populate its uncertainty_profile.\\n\\nEPISTEMIC BOUNDS: The informational loss is strictly bounded by\\nmax_allowed_entropy_loss (ge=0.0, le=1.0), mathematically preventing the\\nover-compression of truth. The required_grounding_density is locked to the\\nLiteral automaton [\\\"sparse\\\", \\\"dense\\\", \\\"exhaustive\\\"].\\n\\nMCP ROUTING TRIGGERS: Information Bottleneck Method, Shannon Entropy Loss,\\nSemantic Compression, Multimodal Grounding, Autoencoder Distillation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_allowed_entropy_loss\","]
#[doc = "    \"minimum_fidelity_threshold\","]
#[doc = "    \"required_grounding_density\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_allowed_entropy_loss\": {"]
#[doc = "      \"title\": \"Max Allowed Entropy Loss\","]
#[doc = "      \"description\": \"The maximum allowed statistical flattening of the source data. Bounded between [0.0, 1.0].\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"minimum_fidelity_threshold\": {"]
#[doc = "      \"title\": \"Minimum Fidelity Threshold\","]
#[doc = "      \"description\": \"Mathematical boundary condition (epsilon_max).\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"required_grounding_density\": {"]
#[doc = "      \"title\": \"Required Grounding Density\","]
#[doc = "      \"description\": \"Dictates the required granularity of the MultimodalTokenAnchorState (e.g., must the model map every single entity, or just the global claim?).\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"sparse\","]
#[doc = "        \"dense\","]
#[doc = "        \"exhaustive\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"strict_probability_retention\": {"]
#[doc = "      \"title\": \"Strict Probability Retention\","]
#[doc = "      \"description\": \"If True, forces the resulting SemanticNodeState to populate its uncertainty_profile.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicCompressionSla {
    #[doc = "The maximum allowed statistical flattening of the source data. Bounded between [0.0, 1.0]."]
    pub max_allowed_entropy_loss: f64,
    #[doc = "Mathematical boundary condition (epsilon_max)."]
    pub minimum_fidelity_threshold: f64,
    #[doc = "Dictates the required granularity of the MultimodalTokenAnchorState (e.g., must the model map every single entity, or just the global claim?)."]
    pub required_grounding_density: RequiredGroundingDensity,
    #[doc = "If True, forces the resulting SemanticNodeState to populate its uncertainty_profile."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub strict_probability_retention: ::std::option::Option<bool>,
}
impl EpistemicCompressionSla {
    pub fn builder() -> builder::EpistemicCompressionSla {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A mathematical invariant evaluated against an LLM's proxy-based structural plan.\n\nCAUSAL AFFORDANCE: Enables SymbolicAI's Design-by-Contract (DbC) autonomous correction loop during test-time compute.\n\nEPISTEMIC BOUNDS: `assertion_ast` must be a strictly parsable Python AST string. It structurally prohibits imports, assignments, or kinetic network calls to guarantee safe downstream evaluation.\n\nMCP ROUTING TRIGGERS: Design-by-Contract, AST Evaluation, Invariant Checking, SymbolicAI DbC, Zero-Trust Execution"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicConstraintPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A mathematical invariant evaluated against an LLM's proxy-based structural plan.\\n\\nCAUSAL AFFORDANCE: Enables SymbolicAI's Design-by-Contract (DbC) autonomous correction loop during test-time compute.\\n\\nEPISTEMIC BOUNDS: `assertion_ast` must be a strictly parsable Python AST string. It structurally prohibits imports, assignments, or kinetic network calls to guarantee safe downstream evaluation.\\n\\nMCP ROUTING TRIGGERS: Design-by-Contract, AST Evaluation, Invariant Checking, SymbolicAI DbC, Zero-Trust Execution\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"assertion_ast\","]
#[doc = "    \"remediation_prompt\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"assertion_ast\": {"]
#[doc = "      \"title\": \"Assertion Ast\","]
#[doc = "      \"description\": \"Strict AST-parsable string constraint (e.g., 'len(plan.outputs) == len(plan.inputs)').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 1024"]
#[doc = "    },"]
#[doc = "    \"remediation_prompt\": {"]
#[doc = "      \"title\": \"Remediation Prompt\","]
#[doc = "      \"description\": \"The exact semantic prompt injected into the LLM if the AST assertion collapses natively.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2048"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicConstraintPolicy {
    #[doc = "Strict AST-parsable string constraint (e.g., 'len(plan.outputs) == len(plan.inputs)')."]
    pub assertion_ast: AssertionAst,
    #[doc = "The exact semantic prompt injected into the LLM if the AST assertion collapses natively."]
    pub remediation_prompt: RemediationPrompt,
}
impl EpistemicConstraintPolicy {
    pub fn builder() -> builder::EpistemicConstraintPolicy {
        Default::default()
    }
}
#[doc = "A string ID representing the session or specific spatial trace binding."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Epistemic Coordinate\","]
#[doc = "  \"description\": \"A string ID representing the session or specific spatial trace binding.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct EpistemicCoordinate(::std::string::String);
impl ::std::ops::Deref for EpistemicCoordinate {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<EpistemicCoordinate> for ::std::string::String {
    fn from(value: EpistemicCoordinate) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for EpistemicCoordinate {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for EpistemicCoordinate {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EpistemicCoordinate {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EpistemicCoordinate {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for EpistemicCoordinate {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Curriculum Learning and Experience Replay manifolds,\nserving as the definitive batch transport layer for continuous swarm optimization. As a\n...Manifest suffix, this defines a frozen, N-dimensional coordinate state.\n\nCAUSAL AFFORDANCE: Injects a validated cluster of EpistemicGroundedTaskManifest\nprimitives into the decentralized training pipeline, forcing deterministic policy\ngradient updates across all subscribing nodes.\n\nEPISTEMIC BOUNDS: The tasks array requires min_length=1 to prevent empty compute\ncycles. To guarantee zero-trust distribution and prevent Byzantine hash fractures, the\n@model_validator sort_tasks mechanically sorts the array by task_cid, ensuring perfect\nRFC 8785 canonical hashing. Anchored by a 128-char curriculum_cid CID.\n\nMCP ROUTING TRIGGERS: Curriculum Learning, Experience Replay, Policy Gradient,\nCanonical Hashing, Knowledge Distillation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicCurriculumManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Curriculum Learning and Experience Replay manifolds,\\nserving as the definitive batch transport layer for continuous swarm optimization. As a\\n...Manifest suffix, this defines a frozen, N-dimensional coordinate state.\\n\\nCAUSAL AFFORDANCE: Injects a validated cluster of EpistemicGroundedTaskManifest\\nprimitives into the decentralized training pipeline, forcing deterministic policy\\ngradient updates across all subscribing nodes.\\n\\nEPISTEMIC BOUNDS: The tasks array requires min_length=1 to prevent empty compute\\ncycles. To guarantee zero-trust distribution and prevent Byzantine hash fractures, the\\n@model_validator sort_tasks mechanically sorts the array by task_cid, ensuring perfect\\nRFC 8785 canonical hashing. Anchored by a 128-char curriculum_cid CID.\\n\\nMCP ROUTING TRIGGERS: Curriculum Learning, Experience Replay, Policy Gradient,\\nCanonical Hashing, Knowledge Distillation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"curriculum_cid\","]
#[doc = "    \"tasks\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"curriculum_cid\": {"]
#[doc = "      \"title\": \"Curriculum Cid\","]
#[doc = "      \"description\": \"Unique CID for this training epoch release.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"tasks\": {"]
#[doc = "      \"title\": \"Tasks\","]
#[doc = "      \"description\": \"The array of fully verified task primitives.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EpistemicGroundedTaskManifest\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicCurriculumManifest {
    #[doc = "Unique CID for this training epoch release."]
    pub curriculum_cid: CurriculumCid,
    #[doc = "The array of fully verified task primitives."]
    pub tasks: ::std::vec::Vec<EpistemicGroundedTaskManifest>,
}
impl EpistemicCurriculumManifest {
    pub fn builder() -> builder::EpistemicCurriculumManifest {
        Default::default()
    }
}
#[doc = "A structured natural-language description of the deterministic logic that failed, including the specific AST node, formal solver, or constraint that could not be satisfied."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Epistemic Deficit Description\","]
#[doc = "  \"description\": \"A structured natural-language description of the deterministic logic that failed, including the specific AST node, formal solver, or constraint that could not be satisfied.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 10000,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct EpistemicDeficitDescription(::std::string::String);
impl ::std::ops::Deref for EpistemicDeficitDescription {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<EpistemicDeficitDescription> for ::std::string::String {
    fn from(value: EpistemicDeficitDescription) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for EpistemicDeficitDescription {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 10000usize {
            return Err("longer than 10000 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for EpistemicDeficitDescription {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EpistemicDeficitDescription {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EpistemicDeficitDescription {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for EpistemicDeficitDescription {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Explicit instruction to the orchestrator on how to patch the shared state blackboard with the partial payload."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Epistemic Disposition\","]
#[doc = "  \"description\": \"Explicit instruction to the orchestrator on how to patch the shared state blackboard with the partial payload.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"discard\","]
#[doc = "    \"retain_as_context\","]
#[doc = "    \"mark_as_falsified\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum EpistemicDisposition {
    #[serde(rename = "discard")]
    Discard,
    #[serde(rename = "retain_as_context")]
    RetainAsContext,
    #[serde(rename = "mark_as_falsified")]
    MarkAsFalsified,
}
impl ::std::fmt::Display for EpistemicDisposition {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Discard => f.write_str("discard"),
            Self::RetainAsContext => f.write_str("retain_as_context"),
            Self::MarkAsFalsified => f.write_str("mark_as_falsified"),
        }
    }
}
impl ::std::str::FromStr for EpistemicDisposition {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "discard" => Ok(Self::Discard),
            "retain_as_context" => Ok(Self::RetainAsContext),
            "mark_as_falsified" => Ok(Self::MarkAsFalsified),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for EpistemicDisposition {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EpistemicDisposition {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EpistemicDisposition {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Encapsulates Formal Epistemology and Bounded Semilattices to represent a verifiable, collision-free cluster of knowledge. As a ...Manifest suffix, this defines a frozen, N-dimensional coordinate state.\n\nCAUSAL AFFORDANCE: Projects a fully verified, non-contradictory subdomain of the global Knowledge Graph into the orchestrator's active context window, allowing specialized agents to operate on a localized, noise-free epistemic baseline.\n\nEPISTEMIC BOUNDS: The graph is physically constrained to a 128-char `graph_cid` CID. The `verified_axioms` array requires `min_length=1` and is deterministically sorted by its triplet components to prevent Byzantine hash fractures.\n\nMCP ROUTING TRIGGERS: Formal Epistemology, Bounded Semilattice, Knowledge Graph Partition, Deterministic Alignment, Subdomain Projection"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicDomainGraphManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Encapsulates Formal Epistemology and Bounded Semilattices to represent a verifiable, collision-free cluster of knowledge. As a ...Manifest suffix, this defines a frozen, N-dimensional coordinate state.\\n\\nCAUSAL AFFORDANCE: Projects a fully verified, non-contradictory subdomain of the global Knowledge Graph into the orchestrator's active context window, allowing specialized agents to operate on a localized, noise-free epistemic baseline.\\n\\nEPISTEMIC BOUNDS: The graph is physically constrained to a 128-char `graph_cid` CID. The `verified_axioms` array requires `min_length=1` and is deterministically sorted by its triplet components to prevent Byzantine hash fractures.\\n\\nMCP ROUTING TRIGGERS: Formal Epistemology, Bounded Semilattice, Knowledge Graph Partition, Deterministic Alignment, Subdomain Projection\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"graph_cid\","]
#[doc = "    \"verified_axioms\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"graph_cid\": {"]
#[doc = "      \"title\": \"Graph Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"verified_axioms\": {"]
#[doc = "      \"title\": \"Verified Axioms\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EpistemicAxiomState\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicDomainGraphManifest {
    pub graph_cid: GraphCid,
    pub verified_axioms: ::std::vec::Vec<EpistemicAxiomState>,
}
impl EpistemicDomainGraphManifest {
    pub fn builder() -> builder::EpistemicDomainGraphManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes a Kahneman System 2 Test-Time Compute Allocation heuristic, leveraging Information Theory to dynamically unlock compute budgets based on measured Shannon Entropy.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator to recursively scale the active `max_latent_tokens_budget` via the `test_time_multiplier` when the agent's internal predictive distribution breaches the `baseline_entropy_threshold`.\n\nEPISTEMIC BOUNDS: State-Space Explosion prevention is delegated to runtime Admission Controllers. `max_escalation_tiers` is clamped to `le=18446744073709551615`.\n\nMCP ROUTING TRIGGERS: System 2 Processing, Test-Time Compute, Shannon Entropy, Epistemic Escalation, Non-Monotonic Scaling"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicEscalationContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes a Kahneman System 2 Test-Time Compute Allocation heuristic, leveraging Information Theory to dynamically unlock compute budgets based on measured Shannon Entropy.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator to recursively scale the active `max_latent_tokens_budget` via the `test_time_multiplier` when the agent's internal predictive distribution breaches the `baseline_entropy_threshold`.\\n\\nEPISTEMIC BOUNDS: State-Space Explosion prevention is delegated to runtime Admission Controllers. `max_escalation_tiers` is clamped to `le=18446744073709551615`.\\n\\nMCP ROUTING TRIGGERS: System 2 Processing, Test-Time Compute, Shannon Entropy, Epistemic Escalation, Non-Monotonic Scaling\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"baseline_entropy_threshold\","]
#[doc = "    \"max_escalation_tiers\","]
#[doc = "    \"test_time_multiplier\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"baseline_entropy_threshold\": {"]
#[doc = "      \"title\": \"Baseline Entropy Threshold\","]
#[doc = "      \"description\": \"The mathematical measure of uncertainty (e.g., variance in generated hypotheses) required to trigger escalation.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"max_escalation_tiers\": {"]
#[doc = "      \"title\": \"Max Escalation Tiers\","]
#[doc = "      \"description\": \"The absolute integer limit on how many times the orchestrator can recursively multiply the compute budget before forcing a SystemFaultEvent.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"test_time_multiplier\": {"]
#[doc = "      \"title\": \"Test Time Multiplier\","]
#[doc = "      \"description\": \"The continuous scalar applied to the agent's baseline max_latent_tokens_budget when the entropy threshold is breached.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 1.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicEscalationContract {
    #[doc = "The mathematical measure of uncertainty (e.g., variance in generated hypotheses) required to trigger escalation."]
    pub baseline_entropy_threshold: f64,
    #[doc = "The absolute integer limit on how many times the orchestrator can recursively multiply the compute budget before forcing a SystemFaultEvent."]
    pub max_escalation_tiers: ::std::num::NonZeroU64,
    #[doc = "The continuous scalar applied to the agent's baseline max_latent_tokens_budget when the entropy threshold is breached."]
    pub test_time_multiplier: f64,
}
impl EpistemicEscalationContract {
    pub fn builder() -> builder::EpistemicEscalationContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: An immutable cryptographic coordinate recording the successful\nfactorization of a terminal reward into a fractional flow value across a continuous\nCognitiveReasoningTraceState trajectory. As a ...Receipt suffix, this is an append-only\ncoordinate on the Merkle-DAG.\n\nCAUSAL AFFORDANCE: Physically anchors the scalar backpropagation of a factored reward\nto a specific source_trajectory_cid, unlocking global flow consistency calculations\nacross the distributed swarm. The terminal_reward_factorized boolean confirms\nsuccessful reward decomposition.\n\nEPISTEMIC BOUNDS: Flow magnitude is geometrically bounded by estimated_flow_value\n(ge=0.0, le=18446744073709551615.0) to prevent exploding gradients during policy updates.\nCryptographically mapped to a rigid 128-char source_trajectory_cid CID.\n\nMCP ROUTING TRIGGERS: Trajectory Balance, Reward Factorization, Flow Network Receipt,\nScalar Backpropagation, Acyclic Path"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicFlowStateReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: An immutable cryptographic coordinate recording the successful\\nfactorization of a terminal reward into a fractional flow value across a continuous\\nCognitiveReasoningTraceState trajectory. As a ...Receipt suffix, this is an append-only\\ncoordinate on the Merkle-DAG.\\n\\nCAUSAL AFFORDANCE: Physically anchors the scalar backpropagation of a factored reward\\nto a specific source_trajectory_cid, unlocking global flow consistency calculations\\nacross the distributed swarm. The terminal_reward_factorized boolean confirms\\nsuccessful reward decomposition.\\n\\nEPISTEMIC BOUNDS: Flow magnitude is geometrically bounded by estimated_flow_value\\n(ge=0.0, le=18446744073709551615.0) to prevent exploding gradients during policy updates.\\nCryptographically mapped to a rigid 128-char source_trajectory_cid CID.\\n\\nMCP ROUTING TRIGGERS: Trajectory Balance, Reward Factorization, Flow Network Receipt,\\nScalar Backpropagation, Acyclic Path\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"estimated_flow_value\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"source_trajectory_cid\","]
#[doc = "    \"terminal_reward_factorized\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"estimated_flow_value\": {"]
#[doc = "      \"title\": \"Estimated Flow Value\","]
#[doc = "      \"description\": \"The non-negative flow value scalar representing the factorized outcome reward.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"source_trajectory_cid\": {"]
#[doc = "      \"title\": \"Source Trajectory Cid\","]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring the partial CognitiveReasoningTraceState.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"terminal_reward_factorized\": {"]
#[doc = "      \"title\": \"Terminal Reward Factorized\","]
#[doc = "      \"description\": \"True if this flow successfully factorized a terminal outcome reward.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"epistemic_flow_state\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicFlowStateReceipt {
    #[doc = "The non-negative flow value scalar representing the factorized outcome reward."]
    pub estimated_flow_value: f64,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The globally unique decentralized identifier (DID) anchoring the partial CognitiveReasoningTraceState."]
    pub source_trajectory_cid: SourceTrajectoryCid,
    #[doc = "True if this flow successfully factorized a terminal outcome reward."]
    pub terminal_reward_factorized: bool,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl EpistemicFlowStateReceipt {
    pub fn builder() -> builder::EpistemicFlowStateReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Trajectory Distillation and Direct Preference Optimization\n(DPO) by encapsulating a mathematically verified ground-truth training datum. As a\n...Manifest suffix, this defines a frozen, N-dimensional coordinate state.\n\nCAUSAL AFFORDANCE: Unlocks verifiable Reinforcement Learning across the swarm by\nsecurely binding an unstructured vignette_payload to a formal topological_proof\n(EpistemicTopologicalProofManifest) and its resulting non-monotonic thinking_trace\n(CognitiveReasoningTraceState).\n\nEPISTEMIC BOUNDS: The task_cid is cryptographically constrained to a 128-char CID\n(^[a-zA-Z0-9_.:-]+$). The vignette_payload is bounded to 100000 characters to prevent\ncontext exhaustion. A verification_lock (CognitiveDualVerificationReceipt) is\nstructurally mandated to physically prevent reward hacking via isolated consensus.\n\nMCP ROUTING TRIGGERS: Trajectory Distillation, Direct Preference Optimization,\nReinforcement Learning, Dual Verification, Curry-Howard Correspondence"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicGroundedTaskManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Trajectory Distillation and Direct Preference Optimization\\n(DPO) by encapsulating a mathematically verified ground-truth training datum. As a\\n...Manifest suffix, this defines a frozen, N-dimensional coordinate state.\\n\\nCAUSAL AFFORDANCE: Unlocks verifiable Reinforcement Learning across the swarm by\\nsecurely binding an unstructured vignette_payload to a formal topological_proof\\n(EpistemicTopologicalProofManifest) and its resulting non-monotonic thinking_trace\\n(CognitiveReasoningTraceState).\\n\\nEPISTEMIC BOUNDS: The task_cid is cryptographically constrained to a 128-char CID\\n(^[a-zA-Z0-9_.:-]+$). The vignette_payload is bounded to 100000 characters to prevent\\ncontext exhaustion. A verification_lock (CognitiveDualVerificationReceipt) is\\nstructurally mandated to physically prevent reward hacking via isolated consensus.\\n\\nMCP ROUTING TRIGGERS: Trajectory Distillation, Direct Preference Optimization,\\nReinforcement Learning, Dual Verification, Curry-Howard Correspondence\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"task_cid\","]
#[doc = "    \"thinking_trace\","]
#[doc = "    \"topological_proof\","]
#[doc = "    \"verification_lock\","]
#[doc = "    \"vignette_payload\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"task_cid\": {"]
#[doc = "      \"title\": \"Task Cid\","]
#[doc = "      \"description\": \"The cryptographic globally unique decentralized identifier (DID) anchoring the task.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"thinking_trace\": {"]
#[doc = "      \"description\": \"The verified reasoning path.\","]
#[doc = "      \"$ref\": \"#/$defs/CognitiveReasoningTraceState\""]
#[doc = "    },"]
#[doc = "    \"topological_proof\": {"]
#[doc = "      \"description\": \"The underlying latent path.\","]
#[doc = "      \"$ref\": \"#/$defs/EpistemicTopologicalProofManifest\""]
#[doc = "    },"]
#[doc = "    \"verification_lock\": {"]
#[doc = "      \"description\": \"The cryptographic proof of dual-agent approval.\","]
#[doc = "      \"$ref\": \"#/$defs/CognitiveDualVerificationReceipt\""]
#[doc = "    },"]
#[doc = "    \"vignette_payload\": {"]
#[doc = "      \"title\": \"Vignette Payload\","]
#[doc = "      \"description\": \"The generated natural language scenario.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicGroundedTaskManifest {
    #[doc = "The cryptographic globally unique decentralized identifier (DID) anchoring the task."]
    pub task_cid: TaskCid,
    #[doc = "The verified reasoning path."]
    pub thinking_trace: CognitiveReasoningTraceState,
    #[doc = "The underlying latent path."]
    pub topological_proof: EpistemicTopologicalProofManifest,
    #[doc = "The cryptographic proof of dual-agent approval."]
    pub verification_lock: CognitiveDualVerificationReceipt,
    #[doc = "The generated natural language scenario."]
    pub vignette_payload: VignettePayload,
}
impl EpistemicGroundedTaskManifest {
    pub fn builder() -> builder::EpistemicGroundedTaskManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative proxy that outputs standard NeMo Colang format (.co files)\nto configure the NeMo Guardrails reverse-proxy in the Envoy mesh.\n\nCAUSAL AFFORDANCE: Defines the exact Colang state machine configuration for intercepting\nand overriding LLM outputs before they hit the network.\n\nEPISTEMIC BOUNDS: Bounded by a strict max_length=100000 on the raw Colang payload\nto prevent memory exhaustion. The @model_validator deterministically sorts the required\nimports.\n\nMCP ROUTING TRIGGERS: NeMo Guardrails, Colang, Reverse Proxy, Constitutional Alignment, Envoy Mesh"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicGuardrailsManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative proxy that outputs standard NeMo Colang format (.co files)\\nto configure the NeMo Guardrails reverse-proxy in the Envoy mesh.\\n\\nCAUSAL AFFORDANCE: Defines the exact Colang state machine configuration for intercepting\\nand overriding LLM outputs before they hit the network.\\n\\nEPISTEMIC BOUNDS: Bounded by a strict max_length=100000 on the raw Colang payload\\nto prevent memory exhaustion. The @model_validator deterministically sorts the required\\nimports.\\n\\nMCP ROUTING TRIGGERS: NeMo Guardrails, Colang, Reverse Proxy, Constitutional Alignment, Envoy Mesh\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"colang_payload\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"colang_payload\": {"]
#[doc = "      \"title\": \"Colang Payload\","]
#[doc = "      \"description\": \"The raw Colang (.co) state machine configuration.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000"]
#[doc = "    },"]
#[doc = "    \"colang_version\": {"]
#[doc = "      \"title\": \"Colang Version\","]
#[doc = "      \"description\": \"The Colang specification version.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"1.0\","]
#[doc = "        \"2.0\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"severity\": {"]
#[doc = "      \"title\": \"Severity\","]
#[doc = "      \"description\": \"The categorical magnitude of the systemic breach enacted upon rule violation.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"low\","]
#[doc = "        \"medium\","]
#[doc = "        \"high\","]
#[doc = "        \"critical\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicGuardrailsManifest {
    #[doc = "The raw Colang (.co) state machine configuration."]
    pub colang_payload: ColangPayload,
    #[doc = "The Colang specification version."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub colang_version: ::std::option::Option<ColangVersion>,
    #[doc = "The categorical magnitude of the systemic breach enacted upon rule violation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub severity: ::std::option::Option<Severity>,
}
impl EpistemicGuardrailsManifest {
    pub fn builder() -> builder::EpistemicGuardrailsManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the limits of infinite graph unfolding to protect UI VRAM when pulling from the EpistemicLedgerState.\nCAUSAL AFFORDANCE: Instructs the orchestrator's deserialization engine to halt graph traversal at a specific recursion depth, replacing raw objects with cryptographic pointers.\nEPISTEMIC BOUNDS: The `max_unfold_depth` strictly bounds the DAG traversal depth (`ge=1, le=18446744073709551615`). `lazy_fetch_timeout_ms` prevents infinite halting (`ge=1, le=60000`). `truncation_strategy` is constrained to a Literal.\nMCP ROUTING TRIGGERS: Coalgebraic Unfolding, Lazy Evaluation, State-Space Bounding, VRAM Exhaustion Prevention"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicHydrationPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the limits of infinite graph unfolding to protect UI VRAM when pulling from the EpistemicLedgerState.\\nCAUSAL AFFORDANCE: Instructs the orchestrator's deserialization engine to halt graph traversal at a specific recursion depth, replacing raw objects with cryptographic pointers.\\nEPISTEMIC BOUNDS: The `max_unfold_depth` strictly bounds the DAG traversal depth (`ge=1, le=18446744073709551615`). `lazy_fetch_timeout_ms` prevents infinite halting (`ge=1, le=60000`). `truncation_strategy` is constrained to a Literal.\\nMCP ROUTING TRIGGERS: Coalgebraic Unfolding, Lazy Evaluation, State-Space Bounding, VRAM Exhaustion Prevention\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"lazy_fetch_timeout_ms\","]
#[doc = "    \"max_unfold_depth\","]
#[doc = "    \"truncation_strategy\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"lazy_fetch_timeout_ms\": {"]
#[doc = "      \"title\": \"Lazy Fetch Timeout Ms\","]
#[doc = "      \"description\": \"Temporal guillotine for resolving cryptographic pointers.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 60000.0,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"max_unfold_depth\": {"]
#[doc = "      \"title\": \"Max Unfold Depth\","]
#[doc = "      \"description\": \"Absolute recursive depth limit for DAG deserialization.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"truncation_strategy\": {"]
#[doc = "      \"title\": \"Truncation Strategy\","]
#[doc = "      \"description\": \"Dictates how the orchestrator caps the state when max_unfold_depth is reached.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"hash_pointer\","]
#[doc = "        \"nullify\","]
#[doc = "        \"scalar_summary\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicHydrationPolicy {
    #[doc = "Temporal guillotine for resolving cryptographic pointers."]
    pub lazy_fetch_timeout_ms: ::std::num::NonZeroU64,
    #[doc = "Absolute recursive depth limit for DAG deserialization."]
    pub max_unfold_depth: ::std::num::NonZeroU64,
    #[doc = "Dictates how the orchestrator caps the state when max_unfold_depth is reached."]
    pub truncation_strategy: TruncationStrategy,
}
impl EpistemicHydrationPolicy {
    pub fn builder() -> builder::EpistemicHydrationPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Event Sourcing and the Merkle-DAG structure as the absolute, immutable source of truth for the swarm, fully partitioned from volatile memory.\n\nCAUSAL AFFORDANCE: Permanently crystallizes validated events into the `history` log. Applies Truth Maintenance, context eviction, and tracks active `DefeasibleCascadeEvents` and `RollbackIntents`.\n\nEPISTEMIC BOUNDS: The `@model_validator` `_enforce_canonical_sort` deterministically sorts history by timestamp, checkpoints by ID, and active cascades—guaranteeing invariant RFC 8785 canonical hashing. Validation prevents epistemic paradoxes (child before parent).\n\nMCP ROUTING TRIGGERS: Event Sourcing, Merkle-DAG, Immutable Ledger, Truth Crystallization, Chronological Sort"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicLedgerState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Event Sourcing and the Merkle-DAG structure as the absolute, immutable source of truth for the swarm, fully partitioned from volatile memory.\\n\\nCAUSAL AFFORDANCE: Permanently crystallizes validated events into the `history` log. Applies Truth Maintenance, context eviction, and tracks active `DefeasibleCascadeEvents` and `RollbackIntents`.\\n\\nEPISTEMIC BOUNDS: The `@model_validator` `_enforce_canonical_sort` deterministically sorts history by timestamp, checkpoints by ID, and active cascades—guaranteeing invariant RFC 8785 canonical hashing. Validation prevents epistemic paradoxes (child before parent).\\n\\nMCP ROUTING TRIGGERS: Event Sourcing, Merkle-DAG, Immutable Ledger, Truth Crystallization, Chronological Sort\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"history\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"active_cascades\": {"]
#[doc = "      \"title\": \"Active Cascades\","]
#[doc = "      \"description\": \"The active state-differential payload muting specific causal subgraphs due to falsification.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/DefeasibleCascadeEvent\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"active_rollbacks\": {"]
#[doc = "      \"title\": \"Active Rollbacks\","]
#[doc = "      \"description\": \"Causal invalidations actively enforced on the execution tree.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/RollbackIntent\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"checkpoints\": {"]
#[doc = "      \"title\": \"Checkpoints\","]
#[doc = "      \"description\": \"Hard temporal anchors allowing state restoration.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/TemporalCheckpointState\""]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000"]
#[doc = "    },"]
#[doc = "    \"crystallization_policy\": {"]
#[doc = "      \"description\": \"The mathematical threshold required to compress episodic observations into semantic rules.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/CrystallizationPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"defeasible_claims\": {"]
#[doc = "      \"title\": \"Defeasible Claims\","]
#[doc = "      \"description\": \"The set of non-monotonic claims residing in the epistemic ledger that are structurally liable to falsification.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"patternProperties\": {"]
#[doc = "        \"^[a-zA-Z0-9_.:-]+$\": {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticNodeState\""]
#[doc = "        }"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"eviction_policy\": {"]
#[doc = "      \"description\": \"The strict mathematical boundary governing context window compression.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EvictionPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"history\": {"]
#[doc = "      \"title\": \"History\","]
#[doc = "      \"description\": \"An append-only, cryptographic ledger of state events. [SITD-Alpha: Non-Monotonic Epistemic Quarantine Isometry]\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyStateEvent\""]
#[doc = "      },"]
#[doc = "      \"maxItems\": 10000"]
#[doc = "    },"]
#[doc = "    \"retracted_nodes\": {"]
#[doc = "      \"title\": \"Retracted Nodes\","]
#[doc = "      \"description\": \"A strict sequence of CIDs representing historical nodes that have been severed from the causal graph via defeasible logic.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1,"]
#[doc = "        \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"truth_maintenance_policy\": {"]
#[doc = "      \"description\": \"The mathematical contract governing automated causal graph ablations and probabilistic decay.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TruthMaintenancePolicy\","]
#[doc = "          \"le\": 18446744073709551615"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicLedgerState {
    #[doc = "The active state-differential payload muting specific causal subgraphs due to falsification."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub active_cascades: ::std::vec::Vec<DefeasibleCascadeEvent>,
    #[doc = "Causal invalidations actively enforced on the execution tree."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub active_rollbacks: ::std::vec::Vec<RollbackIntent>,
    #[doc = "Hard temporal anchors allowing state restoration."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub checkpoints: ::std::vec::Vec<TemporalCheckpointState>,
    #[doc = "The mathematical threshold required to compress episodic observations into semantic rules."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub crystallization_policy: ::std::option::Option<CrystallizationPolicy>,
    #[doc = "The set of non-monotonic claims residing in the epistemic ledger that are structurally liable to falsification."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub defeasible_claims:
        ::std::collections::HashMap<EpistemicLedgerStateDefeasibleClaimsKey, SemanticNodeState>,
    #[doc = "The strict mathematical boundary governing context window compression."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub eviction_policy: ::std::option::Option<EvictionPolicy>,
    #[doc = "An append-only, cryptographic ledger of state events. [SITD-Alpha: Non-Monotonic Epistemic Quarantine Isometry]"]
    pub history: ::std::vec::Vec<AnyStateEvent>,
    #[doc = "A strict sequence of CIDs representing historical nodes that have been severed from the causal graph via defeasible logic."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub retracted_nodes: ::std::vec::Vec<RetractedNodesItem>,
    #[doc = "The mathematical contract governing automated causal graph ablations and probabilistic decay."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub truth_maintenance_policy: ::std::option::Option<TruthMaintenancePolicy>,
}
impl EpistemicLedgerState {
    pub fn builder() -> builder::EpistemicLedgerState {
        Default::default()
    }
}
#[doc = "`EpistemicLedgerStateDefeasibleClaimsKey`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct EpistemicLedgerStateDefeasibleClaimsKey(::std::string::String);
impl ::std::ops::Deref for EpistemicLedgerStateDefeasibleClaimsKey {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<EpistemicLedgerStateDefeasibleClaimsKey> for ::std::string::String {
    fn from(value: EpistemicLedgerStateDefeasibleClaimsKey) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for EpistemicLedgerStateDefeasibleClaimsKey {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for EpistemicLedgerStateDefeasibleClaimsKey {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EpistemicLedgerStateDefeasibleClaimsKey {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EpistemicLedgerStateDefeasibleClaimsKey {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for EpistemicLedgerStateDefeasibleClaimsKey {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines a purely out-of-band semantic logging vector, structurally isolated from the rigorous causal constraints of the Dapper trace tree.\n\nCAUSAL AFFORDANCE: Emits asynchronous telemetry for human-in-the-loop debugging or peripheral auditing without mutating the active Epistemic Ledger's topological state.\n\nEPISTEMIC BOUNDS: Temporal reality clamped by `timestamp`. Severity strictly masked by a Literal automaton `[\"DEBUG\", \"INFO\", \"WARNING\", \"ERROR\", \"CRITICAL\"]`. Message bounded to `max_length=2000`.\n\nMCP ROUTING TRIGGERS: Out-of-Band Telemetry, Asynchronous Logging, Severity Masking, Peripheral Audit, Ephemeral Context"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicLogEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines a purely out-of-band semantic logging vector, structurally isolated from the rigorous causal constraints of the Dapper trace tree.\\n\\nCAUSAL AFFORDANCE: Emits asynchronous telemetry for human-in-the-loop debugging or peripheral auditing without mutating the active Epistemic Ledger's topological state.\\n\\nEPISTEMIC BOUNDS: Temporal reality clamped by `timestamp`. Severity strictly masked by a Literal automaton `[\\\"DEBUG\\\", \\\"INFO\\\", \\\"WARNING\\\", \\\"ERROR\\\", \\\"CRITICAL\\\"]`. Message bounded to `max_length=2000`.\\n\\nMCP ROUTING TRIGGERS: Out-of-Band Telemetry, Asynchronous Logging, Severity Masking, Peripheral Audit, Ephemeral Context\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"level\","]
#[doc = "    \"message\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"context_profile\": {"]
#[doc = "      \"description\": \"Contextual key-value metadata associated with the event.\","]
#[doc = "      \"$ref\": \"#/$defs/TelemetryContextProfile\""]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"level\": {"]
#[doc = "      \"title\": \"Level\","]
#[doc = "      \"description\": \"The severity level of the log event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"DEBUG\","]
#[doc = "        \"INFO\","]
#[doc = "        \"WARNING\","]
#[doc = "        \"ERROR\","]
#[doc = "        \"CRITICAL\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"message\": {"]
#[doc = "      \"title\": \"Message\","]
#[doc = "      \"description\": \"The primary log message.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"The UNIX timestamp of the log event.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for a log event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"epistemic_log\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicLogEvent {
    #[doc = "Contextual key-value metadata associated with the event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub context_profile: ::std::option::Option<TelemetryContextProfile>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The severity level of the log event."]
    pub level: Level,
    #[doc = "The primary log message."]
    pub message: Message,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The UNIX timestamp of the log event."]
    pub timestamp: f64,
    #[doc = "Discriminator type for a log event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl EpistemicLogEvent {
    pub fn builder() -> builder::EpistemicLogEvent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents Hippocampal-Neocortical Consolidation, proving the successful extraction and transfer of generalized knowledge from short-term episodic traces into the permanent semantic graph.\n\nCAUSAL AFFORDANCE: Emits a permanent Merkle-DAG coordinate (`crystallized_semantic_node_cid`) that downstream agents can zero-shot reference, severing the need to reload raw source logs into active context.\n\nEPISTEMIC BOUNDS: Mathematical chain of custody bound to the strictly sorted array of `source_episodic_event_cids`. Token efficiency proven by `compression_ratio` float (`le=1.0`) guaranteeing Shannon Entropy reduction.\n\nMCP ROUTING TRIGGERS: Hippocampal Consolidation, Knowledge Distillation, Semantic Memory, Shannon Entropy Compression, Epistemic Promotion"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicPromotionEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents Hippocampal-Neocortical Consolidation, proving the successful extraction and transfer of generalized knowledge from short-term episodic traces into the permanent semantic graph.\\n\\nCAUSAL AFFORDANCE: Emits a permanent Merkle-DAG coordinate (`crystallized_semantic_node_cid`) that downstream agents can zero-shot reference, severing the need to reload raw source logs into active context.\\n\\nEPISTEMIC BOUNDS: Mathematical chain of custody bound to the strictly sorted array of `source_episodic_event_cids`. Token efficiency proven by `compression_ratio` float (`le=1.0`) guaranteeing Shannon Entropy reduction.\\n\\nMCP ROUTING TRIGGERS: Hippocampal Consolidation, Knowledge Distillation, Semantic Memory, Shannon Entropy Compression, Epistemic Promotion\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"compression_ratio\","]
#[doc = "    \"crystallized_semantic_node_cid\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"source_episodic_event_cids\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"compression_ratio\": {"]
#[doc = "      \"title\": \"Compression Ratio\","]
#[doc = "      \"description\": \"A mathematical proof of the token savings achieved (e.g., old_token_count / new_token_count).\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"crystallized_semantic_node_cid\": {"]
#[doc = "      \"title\": \"Crystallized Semantic Node Cid\","]
#[doc = "      \"description\": \"The resulting permanent W3C DID / The globally unique decentralized identifier (DID) anchoring the newly minted knowledge node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"source_episodic_event_cids\": {"]
#[doc = "      \"title\": \"Source Episodic Event Cids\","]
#[doc = "      \"description\": \"The strict array of CIDs (Content Identifiers) representing the raw logs being compressed and archived.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for an epistemic promotion event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"epistemic_promotion\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicPromotionEvent {
    #[doc = "A mathematical proof of the token savings achieved (e.g., old_token_count / new_token_count)."]
    pub compression_ratio: f64,
    #[doc = "The resulting permanent W3C DID / The globally unique decentralized identifier (DID) anchoring the newly minted knowledge node."]
    pub crystallized_semantic_node_cid: CrystallizedSemanticNodeCid,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The strict array of CIDs (Content Identifiers) representing the raw logs being compressed and archived."]
    pub source_episodic_event_cids: ::std::vec::Vec<SourceEpisodicEventCidsItem>,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "Discriminator type for an epistemic promotion event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl EpistemicPromotionEvent {
    pub fn builder() -> builder::EpistemicPromotionEvent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes a formal Data Provenance anchor, cryptographically locking a semantic state to its exact physical, temporal, or neural genesis block on the Merkle-DAG.\n\nCAUSAL AFFORDANCE: Unlocks deterministic causal tracing and auditability, granting the orchestrator the physical capability to walk the Knowledge Graph backward across multiple swarm hops to the raw multimodal source.\n\nEPISTEMIC BOUNDS: Geometric topology rigidly anchored by the `source_event_cid` (128-char CID regex `^[a-zA-Z0-9_.:-]+$`). Spatial and temporal origin physically clamped by the optional multimodal anchor (`MultimodalTokenAnchorState`).\n\nMCP ROUTING TRIGGERS: Data Provenance, Causal Tracing, Epistemic Anchoring, Bijective Mapping, Genesis Block"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicProvenanceReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes a formal Data Provenance anchor, cryptographically locking a semantic state to its exact physical, temporal, or neural genesis block on the Merkle-DAG.\\n\\nCAUSAL AFFORDANCE: Unlocks deterministic causal tracing and auditability, granting the orchestrator the physical capability to walk the Knowledge Graph backward across multiple swarm hops to the raw multimodal source.\\n\\nEPISTEMIC BOUNDS: Geometric topology rigidly anchored by the `source_event_cid` (128-char CID regex `^[a-zA-Z0-9_.:-]+$`). Spatial and temporal origin physically clamped by the optional multimodal anchor (`MultimodalTokenAnchorState`).\\n\\nMCP ROUTING TRIGGERS: Data Provenance, Causal Tracing, Epistemic Anchoring, Bijective Mapping, Genesis Block\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"derivation_mode\","]
#[doc = "    \"extracted_by\","]
#[doc = "    \"source_event_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"derivation_mode\": {"]
#[doc = "      \"$ref\": \"#/$defs/DerivationModeProfile\""]
#[doc = "    },"]
#[doc = "    \"extracted_by\": {"]
#[doc = "      \"description\": \"The Content Identifier (CID) of the agent node that extracted this payload.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"fidelity_receipt_hash\": {"]
#[doc = "      \"title\": \"Fidelity Receipt Hash\","]
#[doc = "      \"description\": \"Cryptographic pointer back to the TopologicalFidelityReceipt generated at the Input Gate.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"justification_hash\": {"]
#[doc = "      \"title\": \"Justification Hash\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"lineage_watermark\": {"]
#[doc = "      \"description\": \"The cryptographic, tamper-evident chain of custody tracing this memory across multiple swarm hops.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/LineageWatermarkReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"multimodal_anchor\": {"]
#[doc = "      \"description\": \"The unified VLM spatial and temporal token matrix where this data was extracted.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/MultimodalTokenAnchorState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"revision_loops_executed\": {"]
#[doc = "      \"title\": \"Revision Loops Executed\","]
#[doc = "      \"description\": \"Records the exact cycle count the neural model required to pass the verifier.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 100.0,"]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"source_artifact_cid\": {"]
#[doc = "      \"title\": \"Source Artifact Cid\","]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring the Genesis MultimodalArtifactReceipt this semantic state was transmutated from.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"source_event_cid\": {"]
#[doc = "      \"title\": \"Source Event Cid\","]
#[doc = "      \"description\": \"The exact event Content Identifier (CID) in the EpistemicLedgerState that generated this fact.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicProvenanceReceipt {
    pub derivation_mode: DerivationModeProfile,
    #[doc = "The Content Identifier (CID) of the agent node that extracted this payload."]
    pub extracted_by: NodeCidState,
    #[doc = "Cryptographic pointer back to the TopologicalFidelityReceipt generated at the Input Gate."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub fidelity_receipt_hash: ::std::option::Option<::std::string::String>,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The cryptographic, tamper-evident chain of custody tracing this memory across multiple swarm hops."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub lineage_watermark: ::std::option::Option<LineageWatermarkReceipt>,
    #[doc = "The unified VLM spatial and temporal token matrix where this data was extracted."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub multimodal_anchor: ::std::option::Option<MultimodalTokenAnchorState>,
    #[doc = "Records the exact cycle count the neural model required to pass the verifier."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub revision_loops_executed: ::std::option::Option<i64>,
    #[doc = "The globally unique decentralized identifier (DID) anchoring the Genesis MultimodalArtifactReceipt this semantic state was transmutated from."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub source_artifact_cid: ::std::option::Option<::std::string::String>,
    #[doc = "The exact event Content Identifier (CID) in the EpistemicLedgerState that generated this fact."]
    pub source_event_cid: SourceEventCid,
}
impl EpistemicProvenanceReceipt {
    pub fn builder() -> builder::EpistemicProvenanceReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Declares a rigid topological boundary where high-entropy data is physically quarantined from the LLM context window. The LLM receives only this structural proxy.\n\nCAUSAL AFFORDANCE: Unlocks OpenSymbolicAI's Symbolic Firewall, allowing the orchestrator to perform zero-trust semantic planning without payload exposure.\n\nEPISTEMIC BOUNDS: The `proxy_cid` is strictly bounded to a deterministic UUID string. The raw payload `T` is mathematically severed from serialization during prompt injection.\n\nMCP ROUTING TRIGGERS: Zero-Trust Isolation, Symbolic Firewall, Epistemic Quarantine, OpenSymbolicAI Projection"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicProxyState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Declares a rigid topological boundary where high-entropy data is physically quarantined from the LLM context window. The LLM receives only this structural proxy.\\n\\nCAUSAL AFFORDANCE: Unlocks OpenSymbolicAI's Symbolic Firewall, allowing the orchestrator to perform zero-trust semantic planning without payload exposure.\\n\\nEPISTEMIC BOUNDS: The `proxy_cid` is strictly bounded to a deterministic UUID string. The raw payload `T` is mathematically severed from serialization during prompt injection.\\n\\nMCP ROUTING TRIGGERS: Zero-Trust Isolation, Symbolic Firewall, Epistemic Quarantine, OpenSymbolicAI Projection\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"proxy_cid\","]
#[doc = "    \"structural_type\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"proxy_cid\": {"]
#[doc = "      \"title\": \"Proxy Cid\","]
#[doc = "      \"description\": \"The deterministic UUID generated by the runtime to represent this field.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"structural_type\": {"]
#[doc = "      \"title\": \"Structural Type\","]
#[doc = "      \"description\": \"The abstract Python type representation (e.g., 'List[str]').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicProxyState {
    #[doc = "The deterministic UUID generated by the runtime to represent this field."]
    pub proxy_cid: ProxyCid,
    #[doc = "The abstract Python type representation (e.g., 'List[str]')."]
    pub structural_type: StructuralType,
}
impl EpistemicProxyState {
    pub fn builder() -> builder::EpistemicProxyState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicProxyState[Any]\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"proxy_cid\","]
#[doc = "    \"structural_type\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"proxy_cid\": {"]
#[doc = "      \"title\": \"Proxy Cid\","]
#[doc = "      \"description\": \"The deterministic UUID generated by the runtime to represent this field.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"structural_type\": {"]
#[doc = "      \"title\": \"Structural Type\","]
#[doc = "      \"description\": \"The abstract Python type representation (e.g., 'List[str]').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicProxyStateAny {
    #[doc = "The deterministic UUID generated by the runtime to represent this field."]
    pub proxy_cid: ProxyCid,
    #[doc = "The abstract Python type representation (e.g., 'List[str]')."]
    pub structural_type: StructuralType,
}
impl EpistemicProxyStateAny {
    pub fn builder() -> builder::EpistemicProxyStateAny {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements a discrete Epistemic Quarantine and Working\nMemory partition, isolating volatile, non-monotonic probability waves from\nthe immutable ledger. As a ...Snapshot suffix, this is a frozen N-dimensional\ncoordinate of ephemeral context.\n\nCAUSAL AFFORDANCE: Provides a sandbox for the agent to simulate Theory of\nMind (theory_of_mind_matrices, list[TheoryOfMindSnapshot]) and compute\ndefeasible argumentation (argumentation, EpistemicArgumentGraphState | None).\nThe system_prompt (max_length=2000) defines the basal instruction set.\naffordance_projection and capability_attestations extend the discovery surface.\n\nEPISTEMIC BOUNDS: Physical memory is clamped by active_context (key\nmax_length=255, value max_length=100000, le=18446744073709551615). The @model_validator\nsort_arrays deterministically sorts theory_of_mind_matrices by target_agent_cid\nand capability_attestations by attestation_cid for RFC 8785 hashing.\n\nMCP ROUTING TRIGGERS: Working Memory Partition, Epistemic Quarantine, Theory\nof Mind, Volatile State Isolation, Semantic Sandbox"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicQuarantineSnapshot\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements a discrete Epistemic Quarantine and Working\\nMemory partition, isolating volatile, non-monotonic probability waves from\\nthe immutable ledger. As a ...Snapshot suffix, this is a frozen N-dimensional\\ncoordinate of ephemeral context.\\n\\nCAUSAL AFFORDANCE: Provides a sandbox for the agent to simulate Theory of\\nMind (theory_of_mind_matrices, list[TheoryOfMindSnapshot]) and compute\\ndefeasible argumentation (argumentation, EpistemicArgumentGraphState | None).\\nThe system_prompt (max_length=2000) defines the basal instruction set.\\naffordance_projection and capability_attestations extend the discovery surface.\\n\\nEPISTEMIC BOUNDS: Physical memory is clamped by active_context (key\\nmax_length=255, value max_length=100000, le=18446744073709551615). The @model_validator\\nsort_arrays deterministically sorts theory_of_mind_matrices by target_agent_cid\\nand capability_attestations by attestation_cid for RFC 8785 hashing.\\n\\nMCP ROUTING TRIGGERS: Working Memory Partition, Epistemic Quarantine, Theory\\nof Mind, Volatile State Isolation, Semantic Sandbox\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"active_context\","]
#[doc = "    \"system_prompt\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"active_context\": {"]
#[doc = "      \"title\": \"Active Context\","]
#[doc = "      \"description\": \"The ephemeral latent variables and environmental bindings currently active in Epistemic Quarantine.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 100000"]
#[doc = "      },"]
#[doc = "      \"le\": 18446744073709551615"]
#[doc = "    },"]
#[doc = "    \"affordance_projection\": {"]
#[doc = "      \"description\": \"The mathematically bounded subgraph of capabilities currently available to the agent.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/OntologicalSurfaceProjectionManifest\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"argumentation\": {"]
#[doc = "      \"description\": \"The formal graph of non-monotonic claims and defeasible attacks currently active in the swarm's working state.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EpistemicArgumentGraphState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"system_prompt\": {"]
#[doc = "      \"title\": \"System Prompt\","]
#[doc = "      \"description\": \"The basal non-monotonic instruction set currently held in Epistemic Quarantine.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"theory_of_mind_matrices\": {"]
#[doc = "      \"title\": \"Theory Of Mind Matrices\","]
#[doc = "      \"description\": \"Empathetic models of other agents to compress and target outgoing communications.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/TheoryOfMindSnapshot\""]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicQuarantineSnapshot {
    #[doc = "The ephemeral latent variables and environmental bindings currently active in Epistemic Quarantine."]
    pub active_context: ::std::collections::HashMap<
        ::std::string::String,
        EpistemicQuarantineSnapshotActiveContextValue,
    >,
    #[doc = "The mathematically bounded subgraph of capabilities currently available to the agent."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub affordance_projection: ::std::option::Option<OntologicalSurfaceProjectionManifest>,
    #[doc = "The formal graph of non-monotonic claims and defeasible attacks currently active in the swarm's working state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub argumentation: ::std::option::Option<EpistemicArgumentGraphState>,
    #[doc = "The basal non-monotonic instruction set currently held in Epistemic Quarantine."]
    pub system_prompt: SystemPrompt,
    #[doc = "Empathetic models of other agents to compress and target outgoing communications."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub theory_of_mind_matrices: ::std::vec::Vec<TheoryOfMindSnapshot>,
}
impl EpistemicQuarantineSnapshot {
    pub fn builder() -> builder::EpistemicQuarantineSnapshot {
        Default::default()
    }
}
#[doc = "`EpistemicQuarantineSnapshotActiveContextValue`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct EpistemicQuarantineSnapshotActiveContextValue(::std::string::String);
impl ::std::ops::Deref for EpistemicQuarantineSnapshotActiveContextValue {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<EpistemicQuarantineSnapshotActiveContextValue> for ::std::string::String {
    fn from(value: EpistemicQuarantineSnapshotActiveContextValue) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for EpistemicQuarantineSnapshotActiveContextValue {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for EpistemicQuarantineSnapshotActiveContextValue {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String>
    for EpistemicQuarantineSnapshotActiveContextValue
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String>
    for EpistemicQuarantineSnapshotActiveContextValue
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for EpistemicQuarantineSnapshotActiveContextValue {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: The mathematical backpropagation signal triggered when the Deterministic Compiler rejects a stochastic manifold. Quantifies the rejection and provides a mutation gradient.\n\nCAUSAL AFFORDANCE: Instructs the LLM ensemble on how to perturb the Upper Confidence Bound (UCB) during the next MCTS generation attempt by mathematically quantifying the error.\n\nEPISTEMIC BOUNDS: Kullback-Leibler divergence is strictly non-negative. A negative mathematical distance is a paradox and raises a ValueError.\n\nMCP ROUTING TRIGGERS: Rejection Receipt, Free Energy Feedback, MCTS Backpropagation, Variational Free Energy, Mutation Gradient"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicRejectionReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: The mathematical backpropagation signal triggered when the Deterministic Compiler rejects a stochastic manifold. Quantifies the rejection and provides a mutation gradient.\\n\\nCAUSAL AFFORDANCE: Instructs the LLM ensemble on how to perturb the Upper Confidence Bound (UCB) during the next MCTS generation attempt by mathematically quantifying the error.\\n\\nEPISTEMIC BOUNDS: Kullback-Leibler divergence is strictly non-negative. A negative mathematical distance is a paradox and raises a ValueError.\\n\\nMCP ROUTING TRIGGERS: Rejection Receipt, Free Energy Feedback, MCTS Backpropagation, Variational Free Energy, Mutation Gradient\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"failed_projection_cid\","]
#[doc = "    \"kl_divergence_to_validity\","]
#[doc = "    \"receipt_cid\","]
#[doc = "    \"stochastic_mutation_gradient\","]
#[doc = "    \"timestamp\","]
#[doc = "    \"violated_algebraic_constraint\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"failed_projection_cid\": {"]
#[doc = "      \"title\": \"Failed Projection Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"kl_divergence_to_validity\": {"]
#[doc = "      \"title\": \"Kl Divergence To Validity\","]
#[doc = "      \"type\": \"number\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"receipt_cid\": {"]
#[doc = "      \"title\": \"Receipt Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"stochastic_mutation_gradient\": {"]
#[doc = "      \"title\": \"Stochastic Mutation Gradient\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"epistemic_rejection\""]
#[doc = "    },"]
#[doc = "    \"violated_algebraic_constraint\": {"]
#[doc = "      \"title\": \"Violated Algebraic Constraint\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicRejectionReceipt {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    pub failed_projection_cid: FailedProjectionCid,
    pub kl_divergence_to_validity: f64,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    pub receipt_cid: ReceiptCid,
    pub stochastic_mutation_gradient: StochasticMutationGradient,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    pub violated_algebraic_constraint: ViolatedAlgebraicConstraint,
}
impl EpistemicRejectionReceipt {
    pub fn builder() -> builder::EpistemicRejectionReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the acceptable bounds of probabilistic drift for an execution task, establishing the exact hardware and physics requirements for LLM inference.\n\nCAUSAL AFFORDANCE: Instructs the Tier-1 Tensor Router to either enforce local SGLang execution, execute a two-stage decoupled pipeline, or permit Cloud Oracle escalation via structured outputs.\n\nEPISTEMIC BOUNDS: The `minimum_rigidity_tier` is strictly constrained to a scalar mathematical bound `ge=0, le=255`. The semantic-to-scalar mapping (e.g., 'H100_CLUSTER' -> 255) is resolved via a Sovereign MCP Projection. `max_retries_on_semantic_tax` is bounded `ge=0, le=100` to prevent infinite validation loops.\n\nMCP ROUTING TRIGGERS: Epistemic Rigidity Matrix, Execution Routing Policy, Logit Suffocation, Probabilistic Escalation, Semantic Tax Bounding"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicRigidityPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the acceptable bounds of probabilistic drift for an execution task, establishing the exact hardware and physics requirements for LLM inference.\\n\\nCAUSAL AFFORDANCE: Instructs the Tier-1 Tensor Router to either enforce local SGLang execution, execute a two-stage decoupled pipeline, or permit Cloud Oracle escalation via structured outputs.\\n\\nEPISTEMIC BOUNDS: The `minimum_rigidity_tier` is strictly constrained to a scalar mathematical bound `ge=0, le=255`. The semantic-to-scalar mapping (e.g., 'H100_CLUSTER' -> 255) is resolved via a Sovereign MCP Projection. `max_retries_on_semantic_tax` is bounded `ge=0, le=100` to prevent infinite validation loops.\\n\\nMCP ROUTING TRIGGERS: Epistemic Rigidity Matrix, Execution Routing Policy, Logit Suffocation, Probabilistic Escalation, Semantic Tax Bounding\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_retries_on_semantic_tax\": {"]
#[doc = "      \"title\": \"Max Retries On Semantic Tax\","]
#[doc = "      \"description\": \"The maximum number of times the CPU orchestrator is authorized to bounce structurally invalid generation back to the Cloud Oracle.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 100.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"maximum_latency_ms\": {"]
#[doc = "      \"title\": \"Maximum Latency Ms\","]
#[doc = "      \"description\": \"Maximum acceptable round-trip network latency to the Substrate to guarantee SLA.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"minimum_rigidity_tier\": {"]
#[doc = "      \"title\": \"Minimum Rigidity Tier\","]
#[doc = "      \"description\": \"The mathematical scalar representing minimum hardware execution rigor (0=CPU, 255=Max GPU). Allows enterprises to inject custom gradient mappings.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 255.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"minimum_vram_gb\": {"]
#[doc = "      \"title\": \"Minimum Vram Gb\","]
#[doc = "      \"description\": \"Minimum VRAM required on the target substrate to load the tensor topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"permitted_remote_decoding_protocols\": {"]
#[doc = "      \"title\": \"Permitted Remote Decoding Protocols\","]
#[doc = "      \"description\": \"A list of structured output protocols that the orchestrator is permitted to push to a remote Oracle. This explicitly allows the orchestrator to pick and choose how to offload constrained decoding (e.g., via STRICT_JSON_SCHEMA) rather than executing it purely on local bare-metal.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"pattern\": \"^(STRICT_JSON_SCHEMA|NATIVE_PDA_GRAMMAR|LOOSE_JSON_MODE|NONE)$\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"required_epistemic_security\": {"]
#[doc = "      \"description\": \"The minimum SPIFFE/SPIRE workload identity perimeter required for the hardware.\","]
#[doc = "      \"$ref\": \"#/$defs/EpistemicSecurityPolicy\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicRigidityPolicy {
    #[doc = "The maximum number of times the CPU orchestrator is authorized to bounce structurally invalid generation back to the Cloud Oracle."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_retries_on_semantic_tax: ::std::option::Option<i64>,
    #[doc = "Maximum acceptable round-trip network latency to the Substrate to guarantee SLA."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub maximum_latency_ms: ::std::option::Option<u64>,
    #[doc = "The mathematical scalar representing minimum hardware execution rigor (0=CPU, 255=Max GPU). Allows enterprises to inject custom gradient mappings."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub minimum_rigidity_tier: ::std::option::Option<u8>,
    #[doc = "Minimum VRAM required on the target substrate to load the tensor topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub minimum_vram_gb: ::std::option::Option<u64>,
    #[doc = "A list of structured output protocols that the orchestrator is permitted to push to a remote Oracle. This explicitly allows the orchestrator to pick and choose how to offload constrained decoding (e.g., via STRICT_JSON_SCHEMA) rather than executing it purely on local bare-metal."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub permitted_remote_decoding_protocols: ::std::vec::Vec<PermittedRemoteDecodingProtocolsItem>,
    #[doc = "The minimum SPIFFE/SPIRE workload identity perimeter required for the hardware."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub required_epistemic_security: ::std::option::Option<EpistemicSecurityPolicy>,
}
impl ::std::default::Default for EpistemicRigidityPolicy {
    fn default() -> Self {
        Self {
            max_retries_on_semantic_tax: Default::default(),
            maximum_latency_ms: Default::default(),
            minimum_rigidity_tier: Default::default(),
            minimum_vram_gb: Default::default(),
            permitted_remote_decoding_protocols: Default::default(),
            required_epistemic_security: Default::default(),
        }
    }
}
impl EpistemicRigidityPolicy {
    pub fn builder() -> builder::EpistemicRigidityPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Metacognitive Monitoring and Fristonian Active Inference to continuously scan the agent's internal belief distribution and residual stream for epistemic gaps. As a ...Policy suffix, this object defines rigid mathematical boundaries that the orchestrator must enforce globally.\n\nCAUSAL AFFORDANCE: Triggers a structural interlock when the agent detects a spike in Shannon Entropy or cognitive dissonance, forcing the orchestrator to halt forward-pass generation and actively probe or clarify the uncertainty. Gated by the active boolean toggle.\n\nEPISTEMIC BOUNDS: The sensitivity of the metacognitive scanner is physically clamped by the dissonance_threshold (ge=0.0, le=1.0). Recovery mechanisms are deterministically restricted by the action_on_gap FSM literal automaton [\"fail\", \"probe\", \"clarify\"].\n\nMCP ROUTING TRIGGERS: Metacognitive Monitoring, Active Inference, Cognitive Dissonance, Epistemic Foraging, Shannon Entropy"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicScanningPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Metacognitive Monitoring and Fristonian Active Inference to continuously scan the agent's internal belief distribution and residual stream for epistemic gaps. As a ...Policy suffix, this object defines rigid mathematical boundaries that the orchestrator must enforce globally.\\n\\nCAUSAL AFFORDANCE: Triggers a structural interlock when the agent detects a spike in Shannon Entropy or cognitive dissonance, forcing the orchestrator to halt forward-pass generation and actively probe or clarify the uncertainty. Gated by the active boolean toggle.\\n\\nEPISTEMIC BOUNDS: The sensitivity of the metacognitive scanner is physically clamped by the dissonance_threshold (ge=0.0, le=1.0). Recovery mechanisms are deterministically restricted by the action_on_gap FSM literal automaton [\\\"fail\\\", \\\"probe\\\", \\\"clarify\\\"].\\n\\nMCP ROUTING TRIGGERS: Metacognitive Monitoring, Active Inference, Cognitive Dissonance, Epistemic Foraging, Shannon Entropy\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"action_on_gap\","]
#[doc = "    \"active\","]
#[doc = "    \"dissonance_threshold\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"action_on_gap\": {"]
#[doc = "      \"title\": \"Action On Gap\","]
#[doc = "      \"description\": \"The action to take when an epistemic gap is detected.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"fail\","]
#[doc = "        \"probe\","]
#[doc = "        \"clarify\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"active\": {"]
#[doc = "      \"title\": \"Active\","]
#[doc = "      \"description\": \"Whether the epistemic scanner is active.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"dissonance_threshold\": {"]
#[doc = "      \"title\": \"Dissonance Threshold\","]
#[doc = "      \"description\": \"The threshold for cognitive dissonance before triggering an action.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicScanningPolicy {
    #[doc = "The action to take when an epistemic gap is detected."]
    pub action_on_gap: ActionOnGap,
    #[doc = "Whether the epistemic scanner is active."]
    pub active: bool,
    #[doc = "The threshold for cognitive dissonance before triggering an action."]
    pub dissonance_threshold: f64,
}
impl EpistemicScanningPolicy {
    pub fn builder() -> builder::EpistemicScanningPolicy {
        Default::default()
    }
}
#[doc = "AGENT INSTRUCTION: Defines the minimum cryptographic isolation perimeter required for this node's thermodynamic execution.\n\nCAUSAL AFFORDANCE: Binds the execution graph to hardware Trusted Execution Environments (TEEs) if CONFIDENTIAL is set, physically guillotining unauthorized exfiltration.\n\nEPISTEMIC BOUNDS: Constrained strictly to the predefined enumeration values.\n\nMCP ROUTING TRIGGERS: TEE Enforcement, Hardware Isolation, Secure Enclave, Zero-Trust Execution"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicSecurityPolicy\","]
#[doc = "  \"description\": \"AGENT INSTRUCTION: Defines the minimum cryptographic isolation perimeter required for this node's thermodynamic execution.\\n\\nCAUSAL AFFORDANCE: Binds the execution graph to hardware Trusted Execution Environments (TEEs) if CONFIDENTIAL is set, physically guillotining unauthorized exfiltration.\\n\\nEPISTEMIC BOUNDS: Constrained strictly to the predefined enumeration values.\\n\\nMCP ROUTING TRIGGERS: TEE Enforcement, Hardware Isolation, Secure Enclave, Zero-Trust Execution\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"PUBLIC\","]
#[doc = "    \"STANDARD\","]
#[doc = "    \"CONFIDENTIAL\","]
#[doc = "    \"RESTRICTED\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum EpistemicSecurityPolicy {
    #[serde(rename = "PUBLIC")]
    Public,
    #[serde(rename = "STANDARD")]
    Standard,
    #[serde(rename = "CONFIDENTIAL")]
    Confidential,
    #[serde(rename = "RESTRICTED")]
    Restricted,
}
impl ::std::fmt::Display for EpistemicSecurityPolicy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Public => f.write_str("PUBLIC"),
            Self::Standard => f.write_str("STANDARD"),
            Self::Confidential => f.write_str("CONFIDENTIAL"),
            Self::Restricted => f.write_str("RESTRICTED"),
        }
    }
}
impl ::std::str::FromStr for EpistemicSecurityPolicy {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "PUBLIC" => Ok(Self::Public),
            "STANDARD" => Ok(Self::Standard),
            "CONFIDENTIAL" => Ok(Self::Confidential),
            "RESTRICTED" => Ok(Self::Restricted),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for EpistemicSecurityPolicy {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EpistemicSecurityPolicy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EpistemicSecurityPolicy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative, frozen snapshot of the cryptographic isolation boundaries surrounding this node. As a ...Profile suffix, this defines a rigid mathematical boundary.\n\nCAUSAL AFFORDANCE: Instructs the zero-trust orchestrator to enforce hardware-level Trusted Execution Environments (TEEs) and Mixnet egress routing before authorizing the node to handle sensitive payloads.\n\nEPISTEMIC BOUNDS: The boolean gates (network_isolation, egress_obfuscation) rigidly confine the node's kinetic network reach. The epistemic_security enum mathematically dictates if the host hypervisor is trusted.\n\nMCP ROUTING TRIGGERS: Sovereign Execution, Trusted Execution Environment, Egress Obfuscation, Mixnet Routing, Network Isolation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicSecurityProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative, frozen snapshot of the cryptographic isolation boundaries surrounding this node. As a ...Profile suffix, this defines a rigid mathematical boundary.\\n\\nCAUSAL AFFORDANCE: Instructs the zero-trust orchestrator to enforce hardware-level Trusted Execution Environments (TEEs) and Mixnet egress routing before authorizing the node to handle sensitive payloads.\\n\\nEPISTEMIC BOUNDS: The boolean gates (network_isolation, egress_obfuscation) rigidly confine the node's kinetic network reach. The epistemic_security enum mathematically dictates if the host hypervisor is trusted.\\n\\nMCP ROUTING TRIGGERS: Sovereign Execution, Trusted Execution Environment, Egress Obfuscation, Mixnet Routing, Network Isolation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"properties\": {"]
#[doc = "    \"clearance_tiers\": {"]
#[doc = "      \"title\": \"Clearance Tiers\","]
#[doc = "      \"description\": \"A list of mathematical scalars representing the exact data sensitivity levels this node is authorized to process. Allows discrete horizontal compartmentalization (e.g., [50, 100] but not 0).\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"integer\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"egress_obfuscation\": {"]
#[doc = "      \"title\": \"Egress Obfuscation\","]
#[doc = "      \"description\": \"The strict Boolean constraint mandating that all outgoing packets be routed through a Sphinx-packet Mixnet.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"epistemic_security\": {"]
#[doc = "      \"description\": \"The level of hardware-enforced cryptographic isolation required.\","]
#[doc = "      \"$ref\": \"#/$defs/EpistemicSecurityPolicy\""]
#[doc = "    },"]
#[doc = "    \"network_boundary\": {"]
#[doc = "      \"title\": \"Network Boundary\","]
#[doc = "      \"description\": \"The maximum allowed physical network egress boundary for the data.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"INTERNET\","]
#[doc = "        \"VPC_INTERNAL\","]
#[doc = "        \"LOCAL_ENCLAVE\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"network_isolation\": {"]
#[doc = "      \"title\": \"Network Isolation\","]
#[doc = "      \"description\": \"The strict Boolean constraint mandating a fully isolated subnet or eBPF mesh.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"pii_quarantine_required\": {"]
#[doc = "      \"title\": \"Pii Quarantine Required\","]
#[doc = "      \"description\": \"If True, mathematically forces the Tier 1 orchestrator to execute an EpistemicFirewall mask over the payload before it can be passed to any LLM or external API.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicSecurityProfile {
    #[doc = "A list of mathematical scalars representing the exact data sensitivity levels this node is authorized to process. Allows discrete horizontal compartmentalization (e.g., [50, 100] but not 0)."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub clearance_tiers: ::std::vec::Vec<i64>,
    #[doc = "The strict Boolean constraint mandating that all outgoing packets be routed through a Sphinx-packet Mixnet."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub egress_obfuscation: ::std::option::Option<bool>,
    #[doc = "The level of hardware-enforced cryptographic isolation required."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_security: ::std::option::Option<EpistemicSecurityPolicy>,
    #[doc = "The maximum allowed physical network egress boundary for the data."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub network_boundary: ::std::option::Option<NetworkBoundary>,
    #[doc = "The strict Boolean constraint mandating a fully isolated subnet or eBPF mesh."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub network_isolation: ::std::option::Option<bool>,
    #[doc = "If True, mathematically forces the Tier 1 orchestrator to execute an EpistemicFirewall mask over the payload before it can be passed to any LLM or external API."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub pii_quarantine_required: ::std::option::Option<bool>,
}
impl ::std::default::Default for EpistemicSecurityProfile {
    fn default() -> Self {
        Self {
            clearance_tiers: Default::default(),
            egress_obfuscation: Default::default(),
            epistemic_security: Default::default(),
            network_boundary: Default::default(),
            network_isolation: Default::default(),
            pii_quarantine_required: Default::default(),
        }
    }
}
impl EpistemicSecurityProfile {
    pub fn builder() -> builder::EpistemicSecurityProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Subgraph Injection and Graph Neural Network (GNN)\nneighborhood sampling heuristics. As a ...Policy suffix, this defines rigid\nmathematical boundaries the orchestrator must enforce globally.\n\nCAUSAL AFFORDANCE: Authorizes the algorithmic injection of high-density semantic\nseeds or priors into an existing Knowledge Graph, ensuring topological diversity\nby clustering relationships into strictly bounded neighborhood buckets.\n\nEPISTEMIC BOUNDS: The semantic proximity for neighborhood sampling is\nmathematically clamped by similarity_threshold_alpha (ge=0.0, le=1.0). To\nprevent topological density explosions (hub nodes), the\nrelation_diversity_bucket_size is bounded (gt=0, le=18446744073709551615).\n\nMCP ROUTING TRIGGERS: Subgraph Injection, Graph Neural Networks, Neighborhood\nSampling, Topological Diversity, Semantic Seeding"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicSeedInjectionPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Subgraph Injection and Graph Neural Network (GNN)\\nneighborhood sampling heuristics. As a ...Policy suffix, this defines rigid\\nmathematical boundaries the orchestrator must enforce globally.\\n\\nCAUSAL AFFORDANCE: Authorizes the algorithmic injection of high-density semantic\\nseeds or priors into an existing Knowledge Graph, ensuring topological diversity\\nby clustering relationships into strictly bounded neighborhood buckets.\\n\\nEPISTEMIC BOUNDS: The semantic proximity for neighborhood sampling is\\nmathematically clamped by similarity_threshold_alpha (ge=0.0, le=1.0). To\\nprevent topological density explosions (hub nodes), the\\nrelation_diversity_bucket_size is bounded (gt=0, le=18446744073709551615).\\n\\nMCP ROUTING TRIGGERS: Subgraph Injection, Graph Neural Networks, Neighborhood\\nSampling, Topological Diversity, Semantic Seeding\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"relation_diversity_bucket_size\","]
#[doc = "    \"similarity_threshold_alpha\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"relation_diversity_bucket_size\": {"]
#[doc = "      \"title\": \"Relation Diversity Bucket Size\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"similarity_threshold_alpha\": {"]
#[doc = "      \"title\": \"Similarity Threshold Alpha\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicSeedInjectionPolicy {
    pub relation_diversity_bucket_size: ::std::num::NonZeroU64,
    pub similarity_threshold_alpha: f64,
}
impl EpistemicSeedInjectionPolicy {
    pub fn builder() -> builder::EpistemicSeedInjectionPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Encodes a macroscopic Petri net or Directed Acyclic Graph (DAG)\nformalizing standard operating procedures into mathematically traversable state\ntransitions. As a ...Manifest suffix, this defines a frozen, N-dimensional coordinate\nstate.\n\nCAUSAL AFFORDANCE: Physically bounds the executing agent (target_persona:\nProfileCIDState) to a deterministic sequence of CognitiveStateProfiles, unlocking\nthe ability for the orchestrator to dynamically evaluate execution\nvia Process Reward Models (prm_evaluations: list[ProcessRewardContract]) at each\ntopological node.\n\nEPISTEMIC BOUNDS: The cognitive_steps dictionary is constrained to max_length=1000\nto cap memory footprint. The @model_validator reject_ghost_nodes mathematically enforces\nreferential integrity, guaranteeing that no chronological_flow_edges AND no\nstructural_grammar_hashes point to an undefined state.\n\nMCP ROUTING TRIGGERS: Petri Net, Directed Acyclic Graph, Process Reward Model,\nTopological Flow, Referential Integrity"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicSOPManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Encodes a macroscopic Petri net or Directed Acyclic Graph (DAG)\\nformalizing standard operating procedures into mathematically traversable state\\ntransitions. As a ...Manifest suffix, this defines a frozen, N-dimensional coordinate\\nstate.\\n\\nCAUSAL AFFORDANCE: Physically bounds the executing agent (target_persona:\\nProfileCIDState) to a deterministic sequence of CognitiveStateProfiles, unlocking\\nthe ability for the orchestrator to dynamically evaluate execution\\nvia Process Reward Models (prm_evaluations: list[ProcessRewardContract]) at each\\ntopological node.\\n\\nEPISTEMIC BOUNDS: The cognitive_steps dictionary is constrained to max_length=1000\\nto cap memory footprint. The @model_validator reject_ghost_nodes mathematically enforces\\nreferential integrity, guaranteeing that no chronological_flow_edges AND no\\nstructural_grammar_hashes point to an undefined state.\\n\\nMCP ROUTING TRIGGERS: Petri Net, Directed Acyclic Graph, Process Reward Model,\\nTopological Flow, Referential Integrity\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"chronological_flow_edges\","]
#[doc = "    \"cognitive_steps\","]
#[doc = "    \"sop_cid\","]
#[doc = "    \"structural_grammar_hashes\","]
#[doc = "    \"target_persona\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"chronological_flow_edges\": {"]
#[doc = "      \"title\": \"Chronological Flow Edges\","]
#[doc = "      \"description\": \"The exact topological flow between step_cids.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"array\","]
#[doc = "        \"maxItems\": 2,"]
#[doc = "        \"minItems\": 2,"]
#[doc = "        \"prefixItems\": ["]
#[doc = "          {"]
#[doc = "            \"type\": \"string\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"string\""]
#[doc = "          }"]
#[doc = "        ]"]
#[doc = "      },"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"cognitive_steps\": {"]
#[doc = "      \"title\": \"Cognitive Steps\","]
#[doc = "      \"description\": \"Dictionary mapping step_cids to strict causal DAG constraints.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/CognitiveStateProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"prm_evaluations\": {"]
#[doc = "      \"title\": \"Prm Evaluations\","]
#[doc = "      \"description\": \"The strict array of Process Reward Contracts evaluating the logic.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/ProcessRewardContract\""]
#[doc = "      },"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"sop_cid\": {"]
#[doc = "      \"title\": \"Sop Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) for the Standard Operating Procedure.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"structural_grammar_hashes\": {"]
#[doc = "      \"title\": \"Structural Grammar Hashes\","]
#[doc = "      \"description\": \"Dictionary mapping step_cids to SHA-256 hashes of strict Context-Free Grammars or JSON Schemas.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"string\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"target_persona\": {"]
#[doc = "      \"description\": \"The deterministic cognitive routing boundary for the persona executing the SOP.\","]
#[doc = "      \"$ref\": \"#/$defs/ProfileCIDState\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicSopManifest {
    #[doc = "The exact topological flow between step_cids."]
    pub chronological_flow_edges: ::std::vec::Vec<[::serde_json::Value; 2usize]>,
    #[doc = "Dictionary mapping step_cids to strict causal DAG constraints."]
    pub cognitive_steps: ::std::collections::HashMap<::std::string::String, CognitiveStateProfile>,
    #[doc = "The strict array of Process Reward Contracts evaluating the logic."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub prm_evaluations: ::std::vec::Vec<ProcessRewardContract>,
    #[doc = "A Content Identifier (CID) for the Standard Operating Procedure."]
    pub sop_cid: SopCid,
    #[doc = "Dictionary mapping step_cids to SHA-256 hashes of strict Context-Free Grammars or JSON Schemas."]
    pub structural_grammar_hashes:
        ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    #[doc = "The deterministic cognitive routing boundary for the persona executing the SOP."]
    pub target_persona: ProfileCidState,
}
impl EpistemicSopManifest {
    pub fn builder() -> builder::EpistemicSopManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: An append-only historical coordinate recording the definitive failure of empirical validation.\n\nCAUSAL AFFORDANCE: Acts as the kinetic trigger for non-monotonic Truth Maintenance. By dropping belief mass to zero, it forces the orchestrator to emit a DefeasibleCascadeEvent to prune the ungrounded edge from the graph.\n\nEPISTEMIC BOUNDS: The `failed_citations` array mathematically proves that an exhaustive search was attempted but no retrieved snippet breached the required SLA threshold. The array is deterministically sorted for invariant hashing.\n\nMCP ROUTING TRIGGERS: Epistemic Starvation, Natural Language Inference, Truth Maintenance System, Defeasible Logic, Belief Mass Depletion"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicStarvationEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: An append-only historical coordinate recording the definitive failure of empirical validation.\\n\\nCAUSAL AFFORDANCE: Acts as the kinetic trigger for non-monotonic Truth Maintenance. By dropping belief mass to zero, it forces the orchestrator to emit a DefeasibleCascadeEvent to prune the ungrounded edge from the graph.\\n\\nEPISTEMIC BOUNDS: The `failed_citations` array mathematically proves that an exhaustive search was attempted but no retrieved snippet breached the required SLA threshold. The array is deterministically sorted for invariant hashing.\\n\\nMCP ROUTING TRIGGERS: Epistemic Starvation, Natural Language Inference, Truth Maintenance System, Defeasible Logic, Belief Mass Depletion\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"diagnostic_reason\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"failed_citations\","]
#[doc = "    \"starved_edge_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"diagnostic_reason\": {"]
#[doc = "      \"title\": \"Diagnostic Reason\","]
#[doc = "      \"description\": \"The semantic explanation for the starvation (e.g., 'Maximum search retries exhausted').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"failed_citations\": {"]
#[doc = "      \"title\": \"Failed Citations\","]
#[doc = "      \"description\": \"The array of citations evaluated that fell below the required NLI threshold.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EvidentiaryCitationState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"starved_edge_cid\": {"]
#[doc = "      \"title\": \"Starved Edge Cid\","]
#[doc = "      \"description\": \"The cryptographic pointer to the specific edge that failed empirical grounding.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"epistemic_starvation\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicStarvationEvent {
    #[doc = "The semantic explanation for the starvation (e.g., 'Maximum search retries exhausted')."]
    pub diagnostic_reason: DiagnosticReason,
    pub event_cid: EventCid,
    #[doc = "The array of citations evaluated that fell below the required NLI threshold."]
    pub failed_citations: ::std::vec::Vec<EvidentiaryCitationState>,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The cryptographic pointer to the specific edge that failed empirical grounding."]
    pub starved_edge_cid: StarvedEdgeCid,
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl EpistemicStarvationEvent {
    pub fn builder() -> builder::EpistemicStarvationEvent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Human-in-the-Loop (HITL) Supervisory Control Theory and Epistemic Regret tracking to measure out-of-band human physical attention kinematics.\n\nCAUSAL AFFORDANCE: Emits passive structural telemetry to update retrieval gradients and Bayesian priors based on human spatial interaction, without halting the underlying execution DAG.\n\nEPISTEMIC BOUNDS: The human interaction is rigidly confined to the `interaction_modality` Literal automaton. Temporal liveness of attention is bounded by `dwell_duration_ms` (`ge=0, le=18446744073709551615`). Target is locked to `target_node_cid` CID.\n\nMCP ROUTING TRIGGERS: Epistemic Regret, Supervisory Control Theory, Human-in-the-Loop, Dwell Time, Spatial Telemetry"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicTelemetryEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Human-in-the-Loop (HITL) Supervisory Control Theory and Epistemic Regret tracking to measure out-of-band human physical attention kinematics.\\n\\nCAUSAL AFFORDANCE: Emits passive structural telemetry to update retrieval gradients and Bayesian priors based on human spatial interaction, without halting the underlying execution DAG.\\n\\nEPISTEMIC BOUNDS: The human interaction is rigidly confined to the `interaction_modality` Literal automaton. Temporal liveness of attention is bounded by `dwell_duration_ms` (`ge=0, le=18446744073709551615`). Target is locked to `target_node_cid` CID.\\n\\nMCP ROUTING TRIGGERS: Epistemic Regret, Supervisory Control Theory, Human-in-the-Loop, Dwell Time, Spatial Telemetry\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"interaction_modality\","]
#[doc = "    \"target_node_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"dwell_duration_ms\": {"]
#[doc = "      \"title\": \"Dwell Duration Ms\","]
#[doc = "      \"description\": \"The strictly typed temporal bound measuring human attention focus.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"interaction_modality\": {"]
#[doc = "      \"title\": \"Interaction Modality\","]
#[doc = "      \"description\": \"The exact topological action the human operator performed on the projected manifold.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"expansion\","]
#[doc = "        \"collapse\","]
#[doc = "        \"dwell_focus\","]
#[doc = "        \"heuristic_rejection\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"spatial_coordinates\": {"]
#[doc = "      \"description\": \"Optional 3D trajectory of the human pointer event mapped to the spatial grid.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SE3TransformProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"title\": \"Target Node Cid\","]
#[doc = "      \"description\": \"The specific TaxonomicNodeState CID that was manipulated.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for telemetry events.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"epistemic_telemetry\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicTelemetryEvent {
    #[doc = "The strictly typed temporal bound measuring human attention focus."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub dwell_duration_ms: ::std::option::Option<u64>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The exact topological action the human operator performed on the projected manifold."]
    pub interaction_modality: InteractionModality,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "Optional 3D trajectory of the human pointer event mapped to the spatial grid."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub spatial_coordinates: ::std::option::Option<Se3TransformProfile>,
    #[doc = "The specific TaxonomicNodeState CID that was manipulated."]
    pub target_node_cid: TargetNodeCid,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "Discriminator type for telemetry events."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl EpistemicTelemetryEvent {
    pub fn builder() -> builder::EpistemicTelemetryEvent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes the Curry-Howard Correspondence, mapping pure logic to computational types to form an unassailable deductive chain. As a ...Manifest suffix, this defines a frozen, N-dimensional coordinate state.\n\nCAUSAL AFFORDANCE: Unlocks verifiable automated theorem proving. By presenting a strictly ordered, acyclic sequence of axioms (`axiomatic_chain`), it allows an independent auditor or secondary LLM to mechanically verify the logical deduction step-by-step.\n\nEPISTEMIC BOUNDS: The `axiomatic_chain` array is structurally declared with `min_length=1`. Crucially, it invokes the Topological Exemption from array sorting; the sequence order MUST mathematically preserve the chronological deduction steps.\n\nMCP ROUTING TRIGGERS: Curry-Howard Correspondence, Constructive Proof, Topological Sort, Deductive Reasoning, Automated Theorem Proving"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicTopologicalProofManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes the Curry-Howard Correspondence, mapping pure logic to computational types to form an unassailable deductive chain. As a ...Manifest suffix, this defines a frozen, N-dimensional coordinate state.\\n\\nCAUSAL AFFORDANCE: Unlocks verifiable automated theorem proving. By presenting a strictly ordered, acyclic sequence of axioms (`axiomatic_chain`), it allows an independent auditor or secondary LLM to mechanically verify the logical deduction step-by-step.\\n\\nEPISTEMIC BOUNDS: The `axiomatic_chain` array is structurally declared with `min_length=1`. Crucially, it invokes the Topological Exemption from array sorting; the sequence order MUST mathematically preserve the chronological deduction steps.\\n\\nMCP ROUTING TRIGGERS: Curry-Howard Correspondence, Constructive Proof, Topological Sort, Deductive Reasoning, Automated Theorem Proving\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"axiomatic_chain\","]
#[doc = "    \"proof_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"axiomatic_chain\": {"]
#[doc = "      \"title\": \"Axiomatic Chain\","]
#[doc = "      \"description\": \"The strictly ordered sequence of axioms forming the reasoning path.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EpistemicAxiomState\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 1,"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"proof_cid\": {"]
#[doc = "      \"title\": \"Proof Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) for this specific topological proof.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicTopologicalProofManifest {
    #[doc = "The strictly ordered sequence of axioms forming the reasoning path."]
    pub axiomatic_chain: ::std::vec::Vec<EpistemicAxiomState>,
    #[doc = "A Content Identifier (CID) for this specific topological proof."]
    pub proof_cid: ProofCid,
}
impl EpistemicTopologicalProofManifest {
    pub fn builder() -> builder::EpistemicTopologicalProofManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicTransmutationTask\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"artifact_event_cid\","]
#[doc = "    \"target_modalities\","]
#[doc = "    \"task_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"artifact_event_cid\": {"]
#[doc = "      \"title\": \"Artifact Event Cid\","]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring the MultimodalArtifactReceipt being processed.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"execution_cost_budget_magnitude\": {"]
#[doc = "      \"title\": \"Execution Cost Budget Magnitude\","]
#[doc = "      \"description\": \"Optional maximum economic expenditure authorized to run this VLM transmutation.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"optical_governance\": {"]
#[doc = "      \"description\": \"The structural boundaries for visual extraction.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/OpticalParsingSLA\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"schema_governance\": {"]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SchemaDrivenExtractionSLA\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_modalities\": {"]
#[doc = "      \"title\": \"Target Modalities\","]
#[doc = "      \"description\": \"The specific SOTA modality resolutions required for this extraction pass.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"enum\": ["]
#[doc = "          \"text\","]
#[doc = "          \"raster_image\","]
#[doc = "          \"vector_graphics\","]
#[doc = "          \"tabular_grid\","]
#[doc = "          \"n_dimensional_tensor\","]
#[doc = "          \"semantic_graph\""]
#[doc = "        ]"]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"task_cid\": {"]
#[doc = "      \"title\": \"Task Cid\","]
#[doc = "      \"description\": \"Unique identifier for this specific multimodal extraction intervention.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"epistemic_transmutation_task\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicTransmutationTask {
    #[doc = "The globally unique decentralized identifier (DID) anchoring the MultimodalArtifactReceipt being processed."]
    pub artifact_event_cid: ArtifactEventCid,
    #[doc = "Optional maximum economic expenditure authorized to run this VLM transmutation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub execution_cost_budget_magnitude: ::std::option::Option<u64>,
    #[doc = "The structural boundaries for visual extraction."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub optical_governance: ::std::option::Option<OpticalParsingSla>,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub schema_governance: ::std::option::Option<SchemaDrivenExtractionSla>,
    #[doc = "The specific SOTA modality resolutions required for this extraction pass."]
    pub target_modalities: ::std::vec::Vec<TargetModalitiesItem>,
    #[doc = "Unique identifier for this specific multimodal extraction intervention."]
    pub task_cid: TaskCid,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl EpistemicTransmutationTask {
    pub fn builder() -> builder::EpistemicTransmutationTask {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicUpsamplingTask\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"justification_vectors\","]
#[doc = "    \"source_entity\","]
#[doc = "    \"target_ontological_granularity\","]
#[doc = "    \"upsampling_confidence_threshold\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"justification_vectors\": {"]
#[doc = "      \"title\": \"Justification Vectors\","]
#[doc = "      \"description\": \"The strictly ordered matrix of reasoning paths mathematically justifying the topological expansion.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000,"]
#[doc = "      \"minItems\": 1,"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"source_entity\": {"]
#[doc = "      \"description\": \"The specific source contextualized entity subject to topological upsampling.\","]
#[doc = "      \"$ref\": \"#/$defs/ContextualizedSourceState\""]
#[doc = "    },"]
#[doc = "    \"target_ontological_granularity\": {"]
#[doc = "      \"title\": \"Target Ontological Granularity\","]
#[doc = "      \"description\": \"The explicitly declared target node classification or structural grain.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"epistemic_upsampling_task\""]
#[doc = "    },"]
#[doc = "    \"upsampling_confidence_threshold\": {"]
#[doc = "      \"title\": \"Upsampling Confidence Threshold\","]
#[doc = "      \"description\": \"The minimum acceptable certainty probability required to project the upsampled node.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicUpsamplingTask {
    #[doc = "The strictly ordered matrix of reasoning paths mathematically justifying the topological expansion."]
    pub justification_vectors: ::std::vec::Vec<JustificationVectorsItem>,
    #[doc = "The specific source contextualized entity subject to topological upsampling."]
    pub source_entity: ContextualizedSourceState,
    #[doc = "The explicitly declared target node classification or structural grain."]
    pub target_ontological_granularity: TargetOntologicalGranularity,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The minimum acceptable certainty probability required to project the upsampled node."]
    pub upsampling_confidence_threshold: f64,
}
impl EpistemicUpsamplingTask {
    pub fn builder() -> builder::EpistemicUpsamplingTask {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: The macroscopic task topology combining OpenSymbolicAI's data masking with SymbolicAI's logic enforcement.\n\nCAUSAL AFFORDANCE: Triggers the runtime to initiate a blind LLM inference cycle bounded by rigid mathematical proofs.\n\nEPISTEMIC BOUNDS: Bounded to a maximum of 10 remediation epochs to prevent thermodynamic free energy exhaustion. Arrays are deterministically sorted for RFC 8785 canonicalization.\n\nMCP ROUTING TRIGGERS: Bipartite Proposer-Verifier, Test-Time Compute, Zero-Trust Execution, Active Inference, Contract Topology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicZeroTrustContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: The macroscopic task topology combining OpenSymbolicAI's data masking with SymbolicAI's logic enforcement.\\n\\nCAUSAL AFFORDANCE: Triggers the runtime to initiate a blind LLM inference cycle bounded by rigid mathematical proofs.\\n\\nEPISTEMIC BOUNDS: Bounded to a maximum of 10 remediation epochs to prevent thermodynamic free energy exhaustion. Arrays are deterministically sorted for RFC 8785 canonicalization.\\n\\nMCP ROUTING TRIGGERS: Bipartite Proposer-Verifier, Test-Time Compute, Zero-Trust Execution, Active Inference, Contract Topology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"intent_cid\","]
#[doc = "    \"schema_blueprint_name\","]
#[doc = "    \"semantic_planning_task\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"intent_cid\": {"]
#[doc = "      \"title\": \"Intent Cid\","]
#[doc = "      \"description\": \"UUIDv7 mapping to the ledger.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"max_planning_remediation_epochs\": {"]
#[doc = "      \"title\": \"Max Planning Remediation Epochs\","]
#[doc = "      \"description\": \"Thermodynamic cap on SymbolicAI DbC retries.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"schema_blueprint_name\": {"]
#[doc = "      \"title\": \"Schema Blueprint Name\","]
#[doc = "      \"description\": \"The registered URI of the Pydantic schema used to generate the proxies.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 256"]
#[doc = "    },"]
#[doc = "    \"semantic_planning_task\": {"]
#[doc = "      \"title\": \"Semantic Planning Task\","]
#[doc = "      \"description\": \"The core semantic instruction for the blind LLM planner.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 4096"]
#[doc = "    },"]
#[doc = "    \"structural_post_conditions\": {"]
#[doc = "      \"title\": \"Structural Post Conditions\","]
#[doc = "      \"description\": \"DbC bounds checked after inference to ensure the structural plan is valid.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EpistemicConstraintPolicy\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"structural_pre_conditions\": {"]
#[doc = "      \"title\": \"Structural Pre Conditions\","]
#[doc = "      \"description\": \"DbC bounds checked before inference.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EpistemicConstraintPolicy\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a zero-trust contract.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"zero_trust_contract\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicZeroTrustContract {
    #[doc = "UUIDv7 mapping to the ledger."]
    pub intent_cid: IntentCid,
    #[doc = "Thermodynamic cap on SymbolicAI DbC retries."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_planning_remediation_epochs: ::std::option::Option<u64>,
    #[doc = "The registered URI of the Pydantic schema used to generate the proxies."]
    pub schema_blueprint_name: SchemaBlueprintName,
    #[doc = "The core semantic instruction for the blind LLM planner."]
    pub semantic_planning_task: SemanticPlanningTask,
    #[doc = "DbC bounds checked after inference to ensure the structural plan is valid."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub structural_post_conditions: ::std::vec::Vec<EpistemicConstraintPolicy>,
    #[doc = "DbC bounds checked before inference."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub structural_pre_conditions: ::std::vec::Vec<EpistemicConstraintPolicy>,
    #[doc = "Discriminator for a zero-trust contract."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl EpistemicZeroTrustContract {
    pub fn builder() -> builder::EpistemicZeroTrustContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A cryptographically frozen historical fact proving the flawless execution of an EpistemicZeroTrustContract.\n\nCAUSAL AFFORDANCE: Permits the orchestrator to append the transmuted payload to the global immutable ledger, certifying that prompt injection was structurally impossible and AST contracts were fulfilled.\n\nEPISTEMIC BOUNDS: `firewall_breach_detected` must strictly be False. Hashes are bounded to RFC 8785 canonicalization requirements.\n\nMCP ROUTING TRIGGERS: Cryptographic Ledger, Formal Verification Receipt, Immutable Provenance, Hash Canonicalization, Data Masking"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EpistemicZeroTrustReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A cryptographically frozen historical fact proving the flawless execution of an EpistemicZeroTrustContract.\\n\\nCAUSAL AFFORDANCE: Permits the orchestrator to append the transmuted payload to the global immutable ledger, certifying that prompt injection was structurally impossible and AST contracts were fulfilled.\\n\\nEPISTEMIC BOUNDS: `firewall_breach_detected` must strictly be False. Hashes are bounded to RFC 8785 canonicalization requirements.\\n\\nMCP ROUTING TRIGGERS: Cryptographic Ledger, Formal Verification Receipt, Immutable Provenance, Hash Canonicalization, Data Masking\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"intent_reference_cid\","]
#[doc = "    \"llm_blind_plan_hash\","]
#[doc = "    \"remediation_epochs_consumed\","]
#[doc = "    \"timestamp\","]
#[doc = "    \"transmuted_payload_hash\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"firewall_breach_detected\": {"]
#[doc = "      \"title\": \"Firewall Breach Detected\","]
#[doc = "      \"description\": \"A strictly False literal guaranteeing no raw entropy leaked into the LLM context.\","]
#[doc = "      \"type\": \"boolean\","]
#[doc = "      \"const\": false"]
#[doc = "    },"]
#[doc = "    \"intent_reference_cid\": {"]
#[doc = "      \"title\": \"Intent Reference Cid\","]
#[doc = "      \"description\": \"Pointer to the originating EpistemicZeroTrustContract.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"llm_blind_plan_hash\": {"]
#[doc = "      \"title\": \"Llm Blind Plan Hash\","]
#[doc = "      \"description\": \"RFC 8785 hash of the proxy-only structural logic generated by the LLM.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"remediation_epochs_consumed\": {"]
#[doc = "      \"title\": \"Remediation Epochs Consumed\","]
#[doc = "      \"description\": \"The exact count of DbC retries required.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 10.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a zero-trust receipt.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"zero_trust_receipt\""]
#[doc = "    },"]
#[doc = "    \"transmuted_payload_hash\": {"]
#[doc = "      \"title\": \"Transmuted Payload Hash\","]
#[doc = "      \"description\": \"RFC 8785 canonical hash of the final executed payload.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EpistemicZeroTrustReceipt {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "A strictly False literal guaranteeing no raw entropy leaked into the LLM context."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub firewall_breach_detected: ::std::option::Option<bool>,
    #[doc = "Pointer to the originating EpistemicZeroTrustContract."]
    pub intent_reference_cid: IntentReferenceCid,
    #[doc = "RFC 8785 hash of the proxy-only structural logic generated by the LLM."]
    pub llm_blind_plan_hash: LlmBlindPlanHash,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The exact count of DbC retries required."]
    pub remediation_epochs_consumed: i64,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "Discriminator for a zero-trust receipt."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "RFC 8785 canonical hash of the final executed payload."]
    pub transmuted_payload_hash: TransmutedPayloadHash,
}
impl EpistemicZeroTrustReceipt {
    pub fn builder() -> builder::EpistemicZeroTrustReceipt {
        Default::default()
    }
}
#[doc = "Signature or summary of the error causing the trip."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Error Signature\","]
#[doc = "  \"description\": \"Signature or summary of the error causing the trip.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ErrorSignature(::std::string::String);
impl ::std::ops::Deref for ErrorSignature {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ErrorSignature> for ::std::string::String {
    fn from(value: ErrorSignature) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ErrorSignature {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ErrorSignature {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ErrorSignature {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ErrorSignature {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ErrorSignature {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A rigid mathematical agreement governing when an agent is authorized\nto expand its test-time compute allocation (System 2 thinking) based on measured doubt.\nAs a ...Contract suffix, this object defines rigid mathematical boundaries.\n\nCAUSAL AFFORDANCE: Physically unlocks the LatentScratchpadReceipt, granting the agent\na budget of hidden tokens to execute a non-monotonic search tree (MCTS or Beam Search).\n\nEPISTEMIC BOUNDS: Mathematically bounded by uncertainty_escalation_threshold (ge=0.0,\nle=1.0). The computation is physically capped by max_latent_tokens_budget (gt=0,\nle=18446744073709551615) and max_test_time_compute_ms (gt=0, le=18446744073709551615) to prevent infinite\nloops and VRAM exhaustion.\n\nMCP ROUTING TRIGGERS: Test-Time Compute, System 2 Thinking, Epistemic Uncertainty,\nNon-Monotonic Escalation, Token Budgeting"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EscalationContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A rigid mathematical agreement governing when an agent is authorized\\nto expand its test-time compute allocation (System 2 thinking) based on measured doubt.\\nAs a ...Contract suffix, this object defines rigid mathematical boundaries.\\n\\nCAUSAL AFFORDANCE: Physically unlocks the LatentScratchpadReceipt, granting the agent\\na budget of hidden tokens to execute a non-monotonic search tree (MCTS or Beam Search).\\n\\nEPISTEMIC BOUNDS: Mathematically bounded by uncertainty_escalation_threshold (ge=0.0,\\nle=1.0). The computation is physically capped by max_latent_tokens_budget (gt=0,\\nle=18446744073709551615) and max_test_time_compute_ms (gt=0, le=18446744073709551615) to prevent infinite\\nloops and VRAM exhaustion.\\n\\nMCP ROUTING TRIGGERS: Test-Time Compute, System 2 Thinking, Epistemic Uncertainty,\\nNon-Monotonic Escalation, Token Budgeting\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_latent_tokens_budget\","]
#[doc = "    \"max_test_time_compute_ms\","]
#[doc = "    \"uncertainty_escalation_threshold\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_latent_tokens_budget\": {"]
#[doc = "      \"title\": \"Max Latent Tokens Budget\","]
#[doc = "      \"description\": \"The maximum number of hidden tokens the orchestrator is authorized to buy for the internal monologue.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"max_test_time_compute_ms\": {"]
#[doc = "      \"title\": \"Max Test Time Compute Ms\","]
#[doc = "      \"description\": \"The physical time limit allowed for the scratchpad search before forcing a timeout.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"uncertainty_escalation_threshold\": {"]
#[doc = "      \"title\": \"Uncertainty Escalation Threshold\","]
#[doc = "      \"description\": \"The exact Epistemic Uncertainty score that triggers the opening of the Latent Scratchpad.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EscalationContract {
    #[doc = "The maximum number of hidden tokens the orchestrator is authorized to buy for the internal monologue."]
    pub max_latent_tokens_budget: ::std::num::NonZeroU64,
    #[doc = "The physical time limit allowed for the scratchpad search before forcing a timeout."]
    pub max_test_time_compute_ms: ::std::num::NonZeroU64,
    #[doc = "The exact Epistemic Uncertainty score that triggers the opening of the Latent Scratchpad."]
    pub uncertainty_escalation_threshold: f64,
}
impl EscalationContract {
    pub fn builder() -> builder::EscalationContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Emitted when the deterministic Forge encounters an epistemic deficit it cannot resolve via rigid AST manipulation or formal solvers, triggering an escalation to the heuristic Claw Swarm via the Sovereign LLM Proxy. Do not instantiate for security overrides; use `InterventionIntent` instead.\n\nCAUSAL AFFORDANCE: Unlocks the Forge-to-Claw handoff by packaging the precise epistemic deficit, the contextual Merkle-DAG fragments required for the Claw agent's context window, and the thermodynamic budget ceiling that the Sovereign LLM Proxy will enforce via its circuit breaker.\n\nEPISTEMIC BOUNDS: The `target_solver_urn` is strictly anchored to the `urn:coreason:solver:` namespace prefix. The `context_window_cids` array is canonically sorted to guarantee RFC 8785 deterministic hashing. The `thermodynamic_budget` is bounded to `[1, 10_000_000]` tokens to prevent unbounded token burn.\n\nMCP ROUTING TRIGGERS: Epistemic Deficit Escalation, Forge-to-Claw Handoff, Sovereign LLM Proxy, Thermodynamic Circuit Breaker, MCTS Delegation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EscalationIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Emitted when the deterministic Forge encounters an epistemic deficit it cannot resolve via rigid AST manipulation or formal solvers, triggering an escalation to the heuristic Claw Swarm via the Sovereign LLM Proxy. Do not instantiate for security overrides; use `InterventionIntent` instead.\\n\\nCAUSAL AFFORDANCE: Unlocks the Forge-to-Claw handoff by packaging the precise epistemic deficit, the contextual Merkle-DAG fragments required for the Claw agent's context window, and the thermodynamic budget ceiling that the Sovereign LLM Proxy will enforce via its circuit breaker.\\n\\nEPISTEMIC BOUNDS: The `target_solver_urn` is strictly anchored to the `urn:coreason:solver:` namespace prefix. The `context_window_cids` array is canonically sorted to guarantee RFC 8785 deterministic hashing. The `thermodynamic_budget` is bounded to `[1, 10_000_000]` tokens to prevent unbounded token burn.\\n\\nMCP ROUTING TRIGGERS: Epistemic Deficit Escalation, Forge-to-Claw Handoff, Sovereign LLM Proxy, Thermodynamic Circuit Breaker, MCTS Delegation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"context_window_cids\","]
#[doc = "    \"epistemic_deficit_description\","]
#[doc = "    \"target_solver_urn\","]
#[doc = "    \"thermodynamic_budget\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"context_window_cids\": {"]
#[doc = "      \"title\": \"Context Window Cids\","]
#[doc = "      \"description\": \"An ordered list of Content Identifiers (CIDs) representing the code artifacts, Merkle-DAG fragments, and contextual state required by the Claw agent to resolve the deficit.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1,"]
#[doc = "        \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"epistemic_deficit_description\": {"]
#[doc = "      \"title\": \"Epistemic Deficit Description\","]
#[doc = "      \"description\": \"A structured natural-language description of the deterministic logic that failed, including the specific AST node, formal solver, or constraint that could not be satisfied.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 10000,"]
#[doc = "      \"minLength\": 1"]
#[doc = "    },"]
#[doc = "    \"target_solver_urn\": {"]
#[doc = "      \"title\": \"Target Solver Urn\","]
#[doc = "      \"description\": \"The fully qualified URN of the heuristic solver capability to which the deficit is being escalated.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^urn:coreason:solver:.*$\""]
#[doc = "    },"]
#[doc = "    \"thermodynamic_budget\": {"]
#[doc = "      \"title\": \"Thermodynamic Budget\","]
#[doc = "      \"description\": \"The maximum number of tokens the Sovereign LLM Proxy is authorized to burn for this escalation before triggering the thermodynamic circuit breaker (HTTP 429).\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 10000000.0,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for Forge-to-Claw epistemic deficit escalations.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"escalation\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EscalationIntent {
    #[doc = "An ordered list of Content Identifiers (CIDs) representing the code artifacts, Merkle-DAG fragments, and contextual state required by the Claw agent to resolve the deficit."]
    pub context_window_cids: ::std::vec::Vec<ContextWindowCidsItem>,
    #[doc = "A structured natural-language description of the deterministic logic that failed, including the specific AST node, formal solver, or constraint that could not be satisfied."]
    pub epistemic_deficit_description: EpistemicDeficitDescription,
    #[doc = "The fully qualified URN of the heuristic solver capability to which the deficit is being escalated."]
    pub target_solver_urn: TargetSolverUrn,
    #[doc = "The maximum number of tokens the Sovereign LLM Proxy is authorized to burn for this escalation before triggering the thermodynamic circuit breaker (HTTP 429)."]
    pub thermodynamic_budget: ::std::num::NonZeroU64,
    #[doc = "Discriminator for Forge-to-Claw epistemic deficit escalations."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl EscalationIntent {
    pub fn builder() -> builder::EscalationIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Enforces Algorithmic Mechanism Design and Proof-of-Stake (PoS) physics, forcing agents to cryptographically lock thermodynamic compute capacity prior to execution.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator's clearinghouse to automatically slash or refund the locked budget based on the deterministic evaluation of the `release_condition_metric`.\n\nEPISTEMIC BOUNDS: Collateral is rigidly bounded by `escrow_locked_magnitude` (`ge=0, le=18446744073709551615`) to physically prevent integer overflow during thermodynamic tallying.\n\nMCP ROUTING TRIGGERS: Algorithmic Mechanism Design, Proof-of-Stake, Nash Equilibrium, Sybil Resistance, Escrow Collateralization"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EscrowPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Enforces Algorithmic Mechanism Design and Proof-of-Stake (PoS) physics, forcing agents to cryptographically lock thermodynamic compute capacity prior to execution.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator's clearinghouse to automatically slash or refund the locked budget based on the deterministic evaluation of the `release_condition_metric`.\\n\\nEPISTEMIC BOUNDS: Collateral is rigidly bounded by `escrow_locked_magnitude` (`ge=0, le=18446744073709551615`) to physically prevent integer overflow during thermodynamic tallying.\\n\\nMCP ROUTING TRIGGERS: Algorithmic Mechanism Design, Proof-of-Stake, Nash Equilibrium, Sybil Resistance, Escrow Collateralization\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"escrow_locked_magnitude\","]
#[doc = "    \"refund_target_node_cid\","]
#[doc = "    \"release_condition_metric\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"escrow_locked_magnitude\": {"]
#[doc = "      \"title\": \"Escrow Locked Magnitude\","]
#[doc = "      \"description\": \"The strictly typed integer amount cryptographically locked prior to execution.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"refund_target_node_cid\": {"]
#[doc = "      \"title\": \"Refund Target Node Cid\","]
#[doc = "      \"description\": \"The exact NodeCIDState to return funds to if the release condition fails.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"release_condition_metric\": {"]
#[doc = "      \"title\": \"Release Condition Metric\","]
#[doc = "      \"description\": \"A declarative pointer to the SLA or QA rubric required to release the funds.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EscrowPolicy {
    #[doc = "The strictly typed integer amount cryptographically locked prior to execution."]
    pub escrow_locked_magnitude: u64,
    #[doc = "The exact NodeCIDState to return funds to if the release condition fails."]
    pub refund_target_node_cid: RefundTargetNodeCid,
    #[doc = "A declarative pointer to the SLA or QA rubric required to release the funds."]
    pub release_condition_metric: ReleaseConditionMetric,
}
impl EscrowPolicy {
    pub fn builder() -> builder::EscrowPolicy {
        Default::default()
    }
}
#[doc = "The evaluation strategy: 'strict' pre-fetches schemas, 'lazy' uses Coalgebraic Thunking to prevent State-Space Explosion."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Eval Strategy\","]
#[doc = "  \"description\": \"The evaluation strategy: 'strict' pre-fetches schemas, 'lazy' uses Coalgebraic Thunking to prevent State-Space Explosion.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"strict\","]
#[doc = "    \"lazy\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum EvalStrategy {
    #[serde(rename = "strict")]
    Strict,
    #[serde(rename = "lazy")]
    Lazy,
}
impl ::std::fmt::Display for EvalStrategy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Strict => f.write_str("strict"),
            Self::Lazy => f.write_str("lazy"),
        }
    }
}
impl ::std::str::FromStr for EvalStrategy {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "strict" => Ok(Self::Strict),
            "lazy" => Ok(Self::Lazy),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for EvalStrategy {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EvalStrategy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EvalStrategy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative, frozen snapshot of an Actor-Critic (Generator-Discriminator) micro-topology, establishing a zero-sum minimax game between two discrete node identities.\n\nCAUSAL AFFORDANCE: Executes a finite, adversarial generation-evaluation-revision loop, forcing the `generator_node_cid` to propose states and the `evaluator_node_cid` to strictly critique them.\n\nEPISTEMIC BOUNDS: State-Space Explosion is mathematically prevented by capping `max_revision_loops` (`ge=1, le=18446744073709551615`). The `@model_validator` structurally guarantees both nodes exist in the topology's nodes registry AND are disjoint identities.\n\nMCP ROUTING TRIGGERS: Actor-Critic Architecture, Minimax Optimization, Adversarial Critique, Dual-Process Revision, Generative Adversarial Loop"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EvaluatorOptimizerTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative, frozen snapshot of an Actor-Critic (Generator-Discriminator) micro-topology, establishing a zero-sum minimax game between two discrete node identities.\\n\\nCAUSAL AFFORDANCE: Executes a finite, adversarial generation-evaluation-revision loop, forcing the `generator_node_cid` to propose states and the `evaluator_node_cid` to strictly critique them.\\n\\nEPISTEMIC BOUNDS: State-Space Explosion is mathematically prevented by capping `max_revision_loops` (`ge=1, le=18446744073709551615`). The `@model_validator` structurally guarantees both nodes exist in the topology's nodes registry AND are disjoint identities.\\n\\nMCP ROUTING TRIGGERS: Actor-Critic Architecture, Minimax Optimization, Adversarial Critique, Dual-Process Revision, Generative Adversarial Loop\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"evaluator_node_cid\","]
#[doc = "    \"generator_node_cid\","]
#[doc = "    \"max_revision_loops\","]
#[doc = "    \"nodes\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"epistemic_enforcement\": {"]
#[doc = "      \"description\": \"Ties the topology to the Truth Maintenance layer.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TruthMaintenancePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"evaluator_node_cid\": {"]
#[doc = "      \"description\": \"The deterministic capability pointer representing the critic scoring the payload.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"generator_node_cid\": {"]
#[doc = "      \"description\": \"The deterministic capability pointer representing the actor generating the payload.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this topology's configuration.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"lifecycle_phase\": {"]
#[doc = "      \"title\": \"Lifecycle Phase\","]
#[doc = "      \"description\": \"The execution phase of the graph. 'draft' allows incomplete structural state.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"draft\","]
#[doc = "        \"live\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_revision_loops\": {"]
#[doc = "      \"title\": \"Max Revision Loops\","]
#[doc = "      \"description\": \"The absolute limit on Actor-Critic cycles to prevent infinite compute burn.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"nodes\": {"]
#[doc = "      \"title\": \"Nodes\","]
#[doc = "      \"description\": \"Flat registry of all nodes in this topology.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyNodeProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"observability\": {"]
#[doc = "      \"description\": \"The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ObservabilityLODPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"require_multimodal_grounding\": {"]
#[doc = "      \"title\": \"Require Multimodal Grounding\","]
#[doc = "      \"description\": \"If True, the evaluator_node_cid MUST mathematically mask all tokens outside the MultimodalTokenAnchorState during its forward pass to execute pure adversarial Proposer-Critique validation.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"semantic_flow\": {"]
#[doc = "      \"description\": \"The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticFlowPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"shared_state_contract\": {"]
#[doc = "      \"description\": \"The schema-on-write contract governing the internal state of this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StateContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for an Evaluator-Optimizer loop.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"evaluator_optimizer\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EvaluatorOptimizerTopologyManifest {
    #[doc = "The AI's declarative rationale for selecting this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "Ties the topology to the Truth Maintenance layer."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_enforcement: ::std::option::Option<TruthMaintenancePolicy>,
    #[doc = "The deterministic capability pointer representing the critic scoring the payload."]
    pub evaluator_node_cid: NodeCidState,
    #[doc = "The deterministic capability pointer representing the actor generating the payload."]
    pub generator_node_cid: NodeCidState,
    #[doc = "Cryptographic/audit justification for this topology's configuration."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The execution phase of the graph. 'draft' allows incomplete structural state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub lifecycle_phase: ::std::option::Option<LifecyclePhase>,
    #[doc = "The absolute limit on Actor-Critic cycles to prevent infinite compute burn."]
    pub max_revision_loops: ::std::num::NonZeroU64,
    #[doc = "Flat registry of all nodes in this topology."]
    pub nodes: ::std::collections::HashMap<::std::string::String, AnyNodeProfile>,
    #[doc = "The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub observability: ::std::option::Option<ObservabilityLodPolicy>,
    #[doc = "If True, the evaluator_node_cid MUST mathematically mask all tokens outside the MultimodalTokenAnchorState during its forward pass to execute pure adversarial Proposer-Critique validation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub require_multimodal_grounding: ::std::option::Option<bool>,
    #[doc = "The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_flow: ::std::option::Option<SemanticFlowPolicy>,
    #[doc = "The schema-on-write contract governing the internal state of this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub shared_state_contract: ::std::option::Option<StateContract>,
    #[doc = "Discriminator for an Evaluator-Optimizer loop."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl EvaluatorOptimizerTopologyManifest {
    pub fn builder() -> builder::EvaluatorOptimizerTopologyManifest {
        Default::default()
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Event Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct EventCid(::std::string::String);
impl ::std::ops::Deref for EventCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<EventCid> for ::std::string::String {
    fn from(value: EventCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for EventCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for EventCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for EventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for EventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for EventCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: EvictionPolicy implements Information Bottleneck Theory and the\nEbbinghaus Forgetting Curve. It is a rigid mathematical boundary dictating how the\nactive context partition sheds low-salience episodic memories to prevent attention dilution.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator's tensor-pruning heuristic to physically purge,\nsummarize, or decay historical nodes from the GPU VRAM, while mathematically guaranteeing that\nthe protected_event_cids array remains perfectly invariant in the context window.\n\nEPISTEMIC BOUNDS: The absolute physical boundary is enforced by the max_retained_tokens\ninteger limit (gt=0). The eviction behavior is deterministically restricted to the string\nliterals 'fifo', 'salience_decay', or 'summarize' to prevent hallucinated memory management.\n\nMCP ROUTING TRIGGERS: Information Bottleneck, Ebbinghaus Forgetting Curve, Salience Decay, LRU Cache Eviction, Attention Dilution"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EvictionPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: EvictionPolicy implements Information Bottleneck Theory and the\\nEbbinghaus Forgetting Curve. It is a rigid mathematical boundary dictating how the\\nactive context partition sheds low-salience episodic memories to prevent attention dilution.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator's tensor-pruning heuristic to physically purge,\\nsummarize, or decay historical nodes from the GPU VRAM, while mathematically guaranteeing that\\nthe protected_event_cids array remains perfectly invariant in the context window.\\n\\nEPISTEMIC BOUNDS: The absolute physical boundary is enforced by the max_retained_tokens\\ninteger limit (gt=0). The eviction behavior is deterministically restricted to the string\\nliterals 'fifo', 'salience_decay', or 'summarize' to prevent hallucinated memory management.\\n\\nMCP ROUTING TRIGGERS: Information Bottleneck, Ebbinghaus Forgetting Curve, Salience Decay, LRU Cache Eviction, Attention Dilution\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_retained_tokens\","]
#[doc = "    \"strategy\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_retained_tokens\": {"]
#[doc = "      \"title\": \"Max Retained Tokens\","]
#[doc = "      \"description\": \"The strict geometric upper bound of the Epistemic Quarantine's token capacity.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"protected_event_cids\": {"]
#[doc = "      \"title\": \"Protected Event Cids\","]
#[doc = "      \"description\": \"Explicit array of Content Identifiers (CIDs) the orchestrator is mathematically forbidden from retracting.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"strategy\": {"]
#[doc = "      \"title\": \"Strategy\","]
#[doc = "      \"description\": \"The mathematical heuristic used to select which semantic memories are retracted or compressed.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"fifo\","]
#[doc = "        \"salience_decay\","]
#[doc = "        \"summarize\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EvictionPolicy {
    #[doc = "The strict geometric upper bound of the Epistemic Quarantine's token capacity."]
    pub max_retained_tokens: ::std::num::NonZeroU64,
    #[doc = "Explicit array of Content Identifiers (CIDs) the orchestrator is mathematically forbidden from retracting."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub protected_event_cids: ::std::vec::Vec<ProtectedEventCidsItem>,
    #[doc = "The mathematical heuristic used to select which semantic memories are retracted or compressed."]
    pub strategy: Strategy,
}
impl EvictionPolicy {
    pub fn builder() -> builder::EvictionPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative coordinate representing an immutable, localized snippet of external evidence retrieved by an oracle, coupled with its calculated Natural Language Inference (NLI) score.\n\nCAUSAL AFFORDANCE: Physically anchors an abductive hypothesis to empirical reality, providing the exact string evaluated by the NLI cross-encoder to prevent source drift.\n\nEPISTEMIC BOUNDS: The textual premise is volumetrically clamped by `extracted_snippet` (`max_length=10000`). Entailment probability is bounded `[0.0, 1.0]`.\n\nMCP ROUTING TRIGGERS: Retrieval-Augmented Fact-Checking, Natural Language Inference, Evidentiary Coordinate, Cross-Encoder Validation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EvidentiaryCitationState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative coordinate representing an immutable, localized snippet of external evidence retrieved by an oracle, coupled with its calculated Natural Language Inference (NLI) score.\\n\\nCAUSAL AFFORDANCE: Physically anchors an abductive hypothesis to empirical reality, providing the exact string evaluated by the NLI cross-encoder to prevent source drift.\\n\\nEPISTEMIC BOUNDS: The textual premise is volumetrically clamped by `extracted_snippet` (`max_length=10000`). Entailment probability is bounded `[0.0, 1.0]`.\\n\\nMCP ROUTING TRIGGERS: Retrieval-Augmented Fact-Checking, Natural Language Inference, Evidentiary Coordinate, Cross-Encoder Validation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"citation_cid\","]
#[doc = "    \"extracted_snippet\","]
#[doc = "    \"nli_entailment_score\","]
#[doc = "    \"source_url\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"citation_cid\": {"]
#[doc = "      \"title\": \"Citation Cid\","]
#[doc = "      \"description\": \"Cryptographic anchor for the specific piece of evidence.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"extracted_snippet\": {"]
#[doc = "      \"title\": \"Extracted Snippet\","]
#[doc = "      \"description\": \"The exact text evaluated by the NLI model.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 10000"]
#[doc = "    },"]
#[doc = "    \"nli_entailment_score\": {"]
#[doc = "      \"title\": \"Nli Entailment Score\","]
#[doc = "      \"description\": \"The conditional probability that the snippet entails the proposed causal edge.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"publication_timestamp\": {"]
#[doc = "      \"title\": \"Publication Timestamp\","]
#[doc = "      \"description\": \"Optional temporal boundary allowing downstream algorithms to apply temporal discounting.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 253402300799.0,"]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"source_url\": {"]
#[doc = "      \"title\": \"Source Url\","]
#[doc = "      \"description\": \"The canonical origin of the evidence.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"format\": \"uri\","]
#[doc = "      \"maxLength\": 2083,"]
#[doc = "      \"minLength\": 1"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EvidentiaryCitationState {
    #[doc = "Cryptographic anchor for the specific piece of evidence."]
    pub citation_cid: CitationCid,
    #[doc = "The exact text evaluated by the NLI model."]
    pub extracted_snippet: ExtractedSnippet,
    #[doc = "The conditional probability that the snippet entails the proposed causal edge."]
    pub nli_entailment_score: f64,
    #[doc = "Optional temporal boundary allowing downstream algorithms to apply temporal discounting."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub publication_timestamp: ::std::option::Option<f64>,
    #[doc = "The canonical origin of the evidence."]
    pub source_url: ::std::string::String,
}
impl EvidentiaryCitationState {
    pub fn builder() -> builder::EvidentiaryCitationState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EvidentiaryGroundingSLA\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"minimum_nli_entailment_score\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"allowed_evidence_domains\": {"]
#[doc = "      \"title\": \"Allowed Evidence Domains\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"minimum_nli_entailment_score\": {"]
#[doc = "      \"title\": \"Minimum Nli Entailment Score\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"require_independent_sources\": {"]
#[doc = "      \"title\": \"Require Independent Sources\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 10.0,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"required_deduction_receipt_cid\": {"]
#[doc = "      \"description\": \"If grounding via strict hierarchies (e.g., medical ontologies), this MUST point to a FormalVerificationReceipt with is_proved=True.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"ungrounded_link_action\": {"]
#[doc = "      \"title\": \"Ungrounded Link Action\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"sever_edge\","]
#[doc = "        \"flag_for_human\","]
#[doc = "        \"decay_weight\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EvidentiaryGroundingSla {
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub allowed_evidence_domains: ::std::vec::Vec<AllowedEvidenceDomainsItem>,
    pub minimum_nli_entailment_score: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub require_independent_sources: ::std::option::Option<::std::num::NonZeroU64>,
    #[doc = "If grounding via strict hierarchies (e.g., medical ontologies), this MUST point to a FormalVerificationReceipt with is_proved=True."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub required_deduction_receipt_cid: ::std::option::Option<NodeCidState>,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub ungrounded_link_action: ::std::option::Option<UngroundedLinkAction>,
}
impl EvidentiaryGroundingSla {
    pub fn builder() -> builder::EvidentiaryGroundingSla {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes the Toulmin Model of Argumentation by creating a structural bridge between a localized EpistemicArgumentClaimState and a globally verifiable Merkle-DAG coordinate.\n\nCAUSAL AFFORDANCE: Physically anchors a non-monotonic proposition to an immutable historical fact, unlocking the ability for downstream evaluators to mathematically trace the justification logic back to its evidentiary origin.\n\nEPISTEMIC BOUNDS: Requires either a `source_event_cid` or `source_semantic_node_cid` (both optional, bounded to 128-char CIDs via strict regex `^[a-zA-Z0-9_.:-]+$`). The inferential leap is constrained by `justification`, capped at `max_length=2000` characters to prevent context-window exhaustion.\n\nMCP ROUTING TRIGGERS: Toulmin Model, Evidentiary Warrant, Inferential Bridge, Grounding Coordinate, Argumentation Theory"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EvidentiaryWarrantState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes the Toulmin Model of Argumentation by creating a structural bridge between a localized EpistemicArgumentClaimState and a globally verifiable Merkle-DAG coordinate.\\n\\nCAUSAL AFFORDANCE: Physically anchors a non-monotonic proposition to an immutable historical fact, unlocking the ability for downstream evaluators to mathematically trace the justification logic back to its evidentiary origin.\\n\\nEPISTEMIC BOUNDS: Requires either a `source_event_cid` or `source_semantic_node_cid` (both optional, bounded to 128-char CIDs via strict regex `^[a-zA-Z0-9_.:-]+$`). The inferential leap is constrained by `justification`, capped at `max_length=2000` characters to prevent context-window exhaustion.\\n\\nMCP ROUTING TRIGGERS: Toulmin Model, Evidentiary Warrant, Inferential Bridge, Grounding Coordinate, Argumentation Theory\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"justification\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"The logical premise explaining why this evidence supports the claim.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"source_event_cid\": {"]
#[doc = "      \"title\": \"Source Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for a specific observation in the EpistemicLedgerState.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"source_semantic_node_cid\": {"]
#[doc = "      \"title\": \"Source Semantic Node Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for a specific concept in the Semantic Knowledge Graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EvidentiaryWarrantState {
    #[doc = "The logical premise explaining why this evidence supports the claim."]
    pub justification: Justification,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for a specific observation in the EpistemicLedgerState."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub source_event_cid: ::std::option::Option<::std::string::String>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for a specific concept in the Semantic Knowledge Graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub source_semantic_node_cid: ::std::option::Option<::std::string::String>,
}
impl EvidentiaryWarrantState {
    pub fn builder() -> builder::EvidentiaryWarrantState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes a Genetic Algorithm (GA) or Evolutionary Strategy (ES) topology for the gradient-free optimization of agent populations over discrete temporal generations.\n\nCAUSAL AFFORDANCE: Orchestrates the iterative instantiation, evaluation, and culling of autonomous agents, actively applying stochastic perturbations (`MutationPolicy`) and chromosomal combinations (`CrossoverPolicy`) to maximize fitness.\n\nEPISTEMIC BOUNDS: The state space explosion is physically restricted by integer limits on `population_size` (`le=18446744073709551615`) and `generations` (`le=1.0`). The `@model_validator` mathematically guarantees that `fitness_objectives` are deterministically sorted by `target_metric`.\n\nMCP ROUTING TRIGGERS: Genetic Algorithm, Evolutionary Strategy, Gradient-Free Optimization, Population Dynamics, Multi-Objective Optimization"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"EvolutionaryTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes a Genetic Algorithm (GA) or Evolutionary Strategy (ES) topology for the gradient-free optimization of agent populations over discrete temporal generations.\\n\\nCAUSAL AFFORDANCE: Orchestrates the iterative instantiation, evaluation, and culling of autonomous agents, actively applying stochastic perturbations (`MutationPolicy`) and chromosomal combinations (`CrossoverPolicy`) to maximize fitness.\\n\\nEPISTEMIC BOUNDS: The state space explosion is physically restricted by integer limits on `population_size` (`le=18446744073709551615`) and `generations` (`le=1.0`). The `@model_validator` mathematically guarantees that `fitness_objectives` are deterministically sorted by `target_metric`.\\n\\nMCP ROUTING TRIGGERS: Genetic Algorithm, Evolutionary Strategy, Gradient-Free Optimization, Population Dynamics, Multi-Objective Optimization\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"crossover\","]
#[doc = "    \"fitness_objectives\","]
#[doc = "    \"generations\","]
#[doc = "    \"mutation\","]
#[doc = "    \"nodes\","]
#[doc = "    \"population_size\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"crossover\": {"]
#[doc = "      \"description\": \"The mathematical rules for combining elite agents.\","]
#[doc = "      \"$ref\": \"#/$defs/CrossoverPolicy\""]
#[doc = "    },"]
#[doc = "    \"epistemic_enforcement\": {"]
#[doc = "      \"description\": \"Ties the topology to the Truth Maintenance layer.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TruthMaintenancePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"fitness_objectives\": {"]
#[doc = "      \"title\": \"Fitness Objectives\","]
#[doc = "      \"description\": \"The multi-dimensional criteria used to score and cull the population.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/FitnessObjectiveProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"generations\": {"]
#[doc = "      \"title\": \"Generations\","]
#[doc = "      \"description\": \"The absolute limit on evolutionary breeding cycles.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this topology's configuration.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"lifecycle_phase\": {"]
#[doc = "      \"title\": \"Lifecycle Phase\","]
#[doc = "      \"description\": \"The execution phase of the graph. 'draft' allows incomplete structural state.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"draft\","]
#[doc = "        \"live\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"mutation\": {"]
#[doc = "      \"description\": \"The constraints governing random heuristic mutations.\","]
#[doc = "      \"$ref\": \"#/$defs/MutationPolicy\""]
#[doc = "    },"]
#[doc = "    \"nodes\": {"]
#[doc = "      \"title\": \"Nodes\","]
#[doc = "      \"description\": \"Flat registry of all nodes in this topology.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyNodeProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"observability\": {"]
#[doc = "      \"description\": \"The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ObservabilityLODPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"population_size\": {"]
#[doc = "      \"title\": \"Population Size\","]
#[doc = "      \"description\": \"The number of concurrent agents instantiated per generation.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"semantic_flow\": {"]
#[doc = "      \"description\": \"The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticFlowPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"shared_state_contract\": {"]
#[doc = "      \"description\": \"The schema-on-write contract governing the internal state of this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StateContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for an Evolutionary topology.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"evolutionary\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EvolutionaryTopologyManifest {
    #[doc = "The AI's declarative rationale for selecting this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "The mathematical rules for combining elite agents."]
    pub crossover: CrossoverPolicy,
    #[doc = "Ties the topology to the Truth Maintenance layer."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_enforcement: ::std::option::Option<TruthMaintenancePolicy>,
    #[doc = "The multi-dimensional criteria used to score and cull the population."]
    pub fitness_objectives: ::std::vec::Vec<FitnessObjectiveProfile>,
    #[doc = "The absolute limit on evolutionary breeding cycles."]
    pub generations: i64,
    #[doc = "Cryptographic/audit justification for this topology's configuration."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The execution phase of the graph. 'draft' allows incomplete structural state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub lifecycle_phase: ::std::option::Option<LifecyclePhase>,
    #[doc = "The constraints governing random heuristic mutations."]
    pub mutation: MutationPolicy,
    #[doc = "Flat registry of all nodes in this topology."]
    pub nodes: ::std::collections::HashMap<::std::string::String, AnyNodeProfile>,
    #[doc = "The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub observability: ::std::option::Option<ObservabilityLodPolicy>,
    #[doc = "The number of concurrent agents instantiated per generation."]
    pub population_size: u64,
    #[doc = "The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_flow: ::std::option::Option<SemanticFlowPolicy>,
    #[doc = "The schema-on-write contract governing the internal state of this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub shared_state_contract: ::std::option::Option<StateContract>,
    #[doc = "Discriminator for an Evolutionary topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl EvolutionaryTopologyManifest {
    pub fn builder() -> builder::EvolutionaryTopologyManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements the mathematical Reader/Writer/State (RWS) Monad, completely enveloping execution inside pure functions.\n\n    CAUSAL AFFORDANCE: Acts as the envelope functor that strictly maps a pure value into a bounded computational context.\n\n    EPISTEMIC BOUNDS: The execution configuration absolutely forbids external keys via extra=forbid and isolates strictly to trace, state, and payload variables.\n\n    MCP ROUTING TRIGGERS: Reader Writer State Monad, Pure Functions, Envelope Functor, Execution Context, Algebraic Structures"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ExecutionEnvelopeState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements the mathematical Reader/Writer/State (RWS) Monad, completely enveloping execution inside pure functions.\\n\\n    CAUSAL AFFORDANCE: Acts as the envelope functor that strictly maps a pure value into a bounded computational context.\\n\\n    EPISTEMIC BOUNDS: The execution configuration absolutely forbids external keys via extra=forbid and isolates strictly to trace, state, and payload variables.\\n\\n    MCP ROUTING TRIGGERS: Reader Writer State Monad, Pure Functions, Envelope Functor, Execution Context, Algebraic Structures\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"payload\","]
#[doc = "    \"state_vector\","]
#[doc = "    \"trace_context\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"payload\": {"]
#[doc = "      \"title\": \"Payload\","]
#[doc = "      \"description\": \"Represents the pure value payload data structure, domain-specific.\""]
#[doc = "    },"]
#[doc = "    \"state_vector\": {"]
#[doc = "      \"description\": \"Represents the State monad of Labeled Transition Systems.\","]
#[doc = "      \"$ref\": \"#/$defs/StateVectorProfile\""]
#[doc = "    },"]
#[doc = "    \"trace_context\": {"]
#[doc = "      \"description\": \"Represents the Reader/Writer monad for causality and recursion.\","]
#[doc = "      \"$ref\": \"#/$defs/TraceContextState\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ExecutionEnvelopeState {
    #[doc = "Represents the pure value payload data structure, domain-specific."]
    pub payload: ::serde_json::Value,
    #[doc = "Represents the State monad of Labeled Transition Systems."]
    pub state_vector: StateVectorProfile,
    #[doc = "Represents the Reader/Writer monad for causality and recursion."]
    pub trace_context: TraceContextState,
}
impl ExecutionEnvelopeState {
    pub fn builder() -> builder::ExecutionEnvelopeState {
        Default::default()
    }
}
#[doc = "The SHA-256 hash of the complete execution payload, providing undeniable cryptographic provenance for the Merkle-DAG audit trail."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Execution Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the complete execution payload, providing undeniable cryptographic provenance for the Merkle-DAG audit trail.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ExecutionHash(::std::string::String);
impl ::std::ops::Deref for ExecutionHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ExecutionHash> for ::std::string::String {
    fn from(value: ExecutionHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ExecutionHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ExecutionHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ExecutionHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ExecutionHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ExecutionHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The strict virtual machine target mandated for dynamic execution."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Execution Runtime\","]
#[doc = "  \"description\": \"The strict virtual machine target mandated for dynamic execution.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"wasm32-wasi\","]
#[doc = "    \"riscv32-zkvm\","]
#[doc = "    \"bpf\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ExecutionRuntime {
    #[serde(rename = "wasm32-wasi")]
    Wasm32Wasi,
    #[serde(rename = "riscv32-zkvm")]
    Riscv32Zkvm,
    #[serde(rename = "bpf")]
    Bpf,
}
impl ::std::fmt::Display for ExecutionRuntime {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Wasm32Wasi => f.write_str("wasm32-wasi"),
            Self::Riscv32Zkvm => f.write_str("riscv32-zkvm"),
            Self::Bpf => f.write_str("bpf"),
        }
    }
}
impl ::std::str::FromStr for ExecutionRuntime {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "wasm32-wasi" => Ok(Self::Wasm32Wasi),
            "riscv32-zkvm" => Ok(Self::Riscv32Zkvm),
            "bpf" => Ok(Self::Bpf),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ExecutionRuntime {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ExecutionRuntime {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ExecutionRuntime {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: The rigid physical boundary dictating the absolute time and memory limits for kinetic execution, practically bounding the Halting Problem within the swarm.\n\nCAUSAL AFFORDANCE: Acts as the hardware guillotine. Instructs the orchestrator's C++/Rust runtime to physically sever the thread, drop the VRAM context, or kill the WASM container if an agent exceeds its footprint, preventing Denial of Service (DoS).\n\nEPISTEMIC BOUNDS: Absolute physical limits are clamped via intrinsic Pydantic limits: `max_execution_time_ms` (`le=18446744073709551615`, `gt=0`) and `max_compute_footprint_mb` (`le=18446744073709551615`, `gt=0`).\n\nMCP ROUTING TRIGGERS: Hardware Guillotine, Halting Problem Bounding, VRAM Allocation, Process Termination, Resource Exhaustion"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ExecutionSLA\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: The rigid physical boundary dictating the absolute time and memory limits for kinetic execution, practically bounding the Halting Problem within the swarm.\\n\\nCAUSAL AFFORDANCE: Acts as the hardware guillotine. Instructs the orchestrator's C++/Rust runtime to physically sever the thread, drop the VRAM context, or kill the WASM container if an agent exceeds its footprint, preventing Denial of Service (DoS).\\n\\nEPISTEMIC BOUNDS: Absolute physical limits are clamped via intrinsic Pydantic limits: `max_execution_time_ms` (`le=18446744073709551615`, `gt=0`) and `max_compute_footprint_mb` (`le=18446744073709551615`, `gt=0`).\\n\\nMCP ROUTING TRIGGERS: Hardware Guillotine, Halting Problem Bounding, VRAM Allocation, Process Termination, Resource Exhaustion\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_execution_time_ms\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_compute_footprint_mb\": {"]
#[doc = "      \"title\": \"Max Compute Footprint Mb\","]
#[doc = "      \"description\": \"The maximum physical compute footprint allowed for the tool's execution sandbox.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"exclusiveMinimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_execution_time_ms\": {"]
#[doc = "      \"title\": \"Max Execution Time Ms\","]
#[doc = "      \"description\": \"The maximum allowed execution time in milliseconds before the orchestrator kills the process.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ExecutionSla {
    #[doc = "The maximum physical compute footprint allowed for the tool's execution sandbox."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_compute_footprint_mb: ::std::option::Option<::std::num::NonZeroU64>,
    #[doc = "The maximum allowed execution time in milliseconds before the orchestrator kills the process."]
    pub max_execution_time_ms: ::std::num::NonZeroU64,
}
impl ExecutionSla {
    pub fn builder() -> builder::ExecutionSla {
        Default::default()
    }
}
#[doc = "The physical transport layer topology for the execution."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Execution Substrate\","]
#[doc = "  \"description\": \"The physical transport layer topology for the execution.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"mcp_local\","]
#[doc = "    \"mcp_remote\","]
#[doc = "    \"direct_ffi\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ExecutionSubstrate {
    #[serde(rename = "mcp_local")]
    McpLocal,
    #[serde(rename = "mcp_remote")]
    McpRemote,
    #[serde(rename = "direct_ffi")]
    DirectFfi,
}
impl ::std::fmt::Display for ExecutionSubstrate {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::McpLocal => f.write_str("mcp_local"),
            Self::McpRemote => f.write_str("mcp_remote"),
            Self::DirectFfi => f.write_str("direct_ffi"),
        }
    }
}
impl ::std::str::FromStr for ExecutionSubstrate {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "mcp_local" => Ok(Self::McpLocal),
            "mcp_remote" => Ok(Self::McpRemote),
            "direct_ffi" => Ok(Self::DirectFfi),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ExecutionSubstrate {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ExecutionSubstrate {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ExecutionSubstrate {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative blueprint defining the hardware and software prerequisites to safely load an external compute engine.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator's JIT compiler to fetch and verify external packages before kinetic execution, ensuring Dependency Isomorphism.\n\nEPISTEMIC BOUNDS: VRAM constrained strictly above zero. Dependencies are deterministically sorted to preserve RFC 8785 canonical hashing.\n\nMCP ROUTING TRIGGERS: Coalgebraic Thunking, Dependency Isomorphism, JIT Hydration, VRAM Allocation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ExecutionSubstrateProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative blueprint defining the hardware and software prerequisites to safely load an external compute engine.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator's JIT compiler to fetch and verify external packages before kinetic execution, ensuring Dependency Isomorphism.\\n\\nEPISTEMIC BOUNDS: VRAM constrained strictly above zero. Dependencies are deterministically sorted to preserve RFC 8785 canonical hashing.\\n\\nMCP ROUTING TRIGGERS: Coalgebraic Thunking, Dependency Isomorphism, JIT Hydration, VRAM Allocation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"dialect\","]
#[doc = "    \"required_package_signatures\","]
#[doc = "    \"supports_lazy_hydration\","]
#[doc = "    \"vram_overhead_mb\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"dialect\": {"]
#[doc = "      \"title\": \"Dialect\","]
#[doc = "      \"description\": \"The discrete open-source engine URN identifier.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "    },"]
#[doc = "    \"required_package_signatures\": {"]
#[doc = "      \"title\": \"Required Package Signatures\","]
#[doc = "      \"description\": \"A whitelist of exact PEP 508 dependency specifiers or wheel hashes.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"supports_lazy_hydration\": {"]
#[doc = "      \"title\": \"Supports Lazy Hydration\","]
#[doc = "      \"description\": \"Whether the orchestrator can utilize Coalgebraic Thunking to unmount the engine between invocations to save VRAM.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"vram_overhead_mb\": {"]
#[doc = "      \"title\": \"Vram Overhead Mb\","]
#[doc = "      \"description\": \"The physical thermodynamic cost (in MB) of loading the library.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ExecutionSubstrateProfile {
    #[doc = "The discrete open-source engine URN identifier."]
    pub dialect: Dialect,
    #[doc = "A whitelist of exact PEP 508 dependency specifiers or wheel hashes."]
    pub required_package_signatures: ::std::vec::Vec<RequiredPackageSignaturesItem>,
    #[doc = "Whether the orchestrator can utilize Coalgebraic Thunking to unmount the engine between invocations to save VRAM."]
    pub supports_lazy_hydration: bool,
    #[doc = "The physical thermodynamic cost (in MB) of loading the library."]
    pub vram_overhead_mb: u64,
}
impl ExecutionSubstrateProfile {
    pub fn builder() -> builder::ExecutionSubstrateProfile {
        Default::default()
    }
}
#[doc = "A string representing the original escrow boundary breached."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Exhausted Escrow Cid\","]
#[doc = "  \"description\": \"A string representing the original escrow boundary breached.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ExhaustedEscrowCid(::std::string::String);
impl ::std::ops::Deref for ExhaustedEscrowCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ExhaustedEscrowCid> for ::std::string::String {
    fn from(value: ExhaustedEscrowCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ExhaustedEscrowCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ExhaustedEscrowCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ExhaustedEscrowCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ExhaustedEscrowCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ExhaustedEscrowCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Nassim Taleb's Black Swan Theory by injecting\nOut-of-Distribution (OOD) epistemic shocks into the causal graph. As an ...Event suffix,\nthis is an append-only coordinate on the Merkle-DAG that the LLM must never hallucinate\na mutation to.\n\nCAUSAL AFFORDANCE: Forces the active reasoning topology to process a high-entropy\nsynthetic_payload, actively testing the swarm's non-monotonic truth maintenance,\ndefeasible reasoning, and overall topological resilience.\n\nEPISTEMIC BOUNDS: Cryptographically targets a specific Merkle root via target_node_hash\n(strict SHA-256 pattern ^[a-f0-9]{64}$) and bounds the Variational Free Energy via\nbayesian_surprise_score [ge=0.0, le=1.0, allow_inf_nan=False]. The @model_validator\nphysically guarantees execution is halted if the attached escrow is not strictly positive.\n\nMCP ROUTING TRIGGERS: Black Swan Theory, Out-of-Distribution Shock, Variational Free\nEnergy, Exogenous Perturbation, Epistemic Stress Test"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ExogenousEpistemicEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Nassim Taleb's Black Swan Theory by injecting\\nOut-of-Distribution (OOD) epistemic shocks into the causal graph. As an ...Event suffix,\\nthis is an append-only coordinate on the Merkle-DAG that the LLM must never hallucinate\\na mutation to.\\n\\nCAUSAL AFFORDANCE: Forces the active reasoning topology to process a high-entropy\\nsynthetic_payload, actively testing the swarm's non-monotonic truth maintenance,\\ndefeasible reasoning, and overall topological resilience.\\n\\nEPISTEMIC BOUNDS: Cryptographically targets a specific Merkle root via target_node_hash\\n(strict SHA-256 pattern ^[a-f0-9]{64}$) and bounds the Variational Free Energy via\\nbayesian_surprise_score [ge=0.0, le=1.0, allow_inf_nan=False]. The @model_validator\\nphysically guarantees execution is halted if the attached escrow is not strictly positive.\\n\\nMCP ROUTING TRIGGERS: Black Swan Theory, Out-of-Distribution Shock, Variational Free\\nEnergy, Exogenous Perturbation, Epistemic Stress Test\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"bayesian_surprise_score\","]
#[doc = "    \"escrow\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"shock_cid\","]
#[doc = "    \"synthetic_payload\","]
#[doc = "    \"target_node_hash\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"bayesian_surprise_score\": {"]
#[doc = "      \"title\": \"Bayesian Surprise Score\","]
#[doc = "      \"description\": \"Strictly bounded mathematical quantification of the epistemic decay or Variational Free Energy.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"escrow\": {"]
#[doc = "      \"description\": \"The cryptographic Proof-of-Stake funding the shock.\","]
#[doc = "      \"$ref\": \"#/$defs/SimulationEscrowContract\""]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"shock_cid\": {"]
#[doc = "      \"title\": \"Shock Cid\","]
#[doc = "      \"description\": \"Cryptographic identifier for the Black Swan event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"synthetic_payload\": {"]
#[doc = "      \"title\": \"Synthetic Payload\","]
#[doc = "      \"description\": \"Bounded dictionary representing the injected hallucination or observation.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"target_node_hash\": {"]
#[doc = "      \"title\": \"Target Node Hash\","]
#[doc = "      \"description\": \"Regex-bound SHA-256 string targeting a specific Merkle root in the epistemic graph.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for an exogenous event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"exogenous_event\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ExogenousEpistemicEvent {
    #[doc = "Strictly bounded mathematical quantification of the epistemic decay or Variational Free Energy."]
    pub bayesian_surprise_score: f64,
    #[doc = "The cryptographic Proof-of-Stake funding the shock."]
    pub escrow: SimulationEscrowContract,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "Cryptographic identifier for the Black Swan event."]
    pub shock_cid: ShockCid,
    #[doc = "Bounded dictionary representing the injected hallucination or observation."]
    pub synthetic_payload: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "Regex-bound SHA-256 string targeting a specific Merkle root in the epistemic graph."]
    pub target_node_hash: TargetNodeHash,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "Discriminator type for an exogenous event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl ExogenousEpistemicEvent {
    pub fn builder() -> builder::ExogenousEpistemicEvent {
        Default::default()
    }
}
#[doc = "The mathematical paradigm governing how context is expanded."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Expansion Paradigm\","]
#[doc = "  \"description\": \"The mathematical paradigm governing how context is expanded.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"sliding_window\","]
#[doc = "    \"hierarchical_merge\","]
#[doc = "    \"document_summary\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ExpansionParadigm {
    #[serde(rename = "sliding_window")]
    SlidingWindow,
    #[serde(rename = "hierarchical_merge")]
    HierarchicalMerge,
    #[serde(rename = "document_summary")]
    DocumentSummary,
}
impl ::std::fmt::Display for ExpansionParadigm {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::SlidingWindow => f.write_str("sliding_window"),
            Self::HierarchicalMerge => f.write_str("hierarchical_merge"),
            Self::DocumentSummary => f.write_str("document_summary"),
        }
    }
}
impl ::std::str::FromStr for ExpansionParadigm {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "sliding_window" => Ok(Self::SlidingWindow),
            "hierarchical_merge" => Ok(Self::HierarchicalMerge),
            "document_summary" => Ok(Self::DocumentSummary),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ExpansionParadigm {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ExpansionParadigm {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ExpansionParadigm {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The explicit structural definition of the mathematical covariant bound requirement."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Expected Type Geometry\","]
#[doc = "  \"description\": \"The explicit structural definition of the mathematical covariant bound requirement.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ExpectedTypeGeometry(::std::string::String);
impl ::std::ops::Deref for ExpectedTypeGeometry {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ExpectedTypeGeometry> for ::std::string::String {
    fn from(value: ExpectedTypeGeometry) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ExpectedTypeGeometry {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ExpectedTypeGeometry {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ExpectedTypeGeometry {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ExpectedTypeGeometry {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ExpectedTypeGeometry {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The mathematical function dictating how rapidly lateral ThoughtBranches are restricted over time."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Exploration Decay Curve\","]
#[doc = "  \"description\": \"The mathematical function dictating how rapidly lateral ThoughtBranches are restricted over time.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"linear\","]
#[doc = "    \"exponential\","]
#[doc = "    \"step\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ExplorationDecayCurve {
    #[serde(rename = "linear")]
    Linear,
    #[serde(rename = "exponential")]
    Exponential,
    #[serde(rename = "step")]
    Step,
}
impl ::std::fmt::Display for ExplorationDecayCurve {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Linear => f.write_str("linear"),
            Self::Exponential => f.write_str("exponential"),
            Self::Step => f.write_str("step"),
        }
    }
}
impl ::std::str::FromStr for ExplorationDecayCurve {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "linear" => Ok(Self::Linear),
            "exponential" => Ok(Self::Exponential),
            "step" => Ok(Self::Step),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ExplorationDecayCurve {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ExplorationDecayCurve {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ExplorationDecayCurve {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`ExportCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Export Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ExportCid(::std::string::String);
impl ::std::ops::Deref for ExportCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ExportCid> for ::std::string::String {
    fn from(value: ExportCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ExportCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ExportCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ExportCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ExportCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ExportCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The exact text evaluated by the NLI model."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Extracted Snippet\","]
#[doc = "  \"description\": \"The exact text evaluated by the NLI model.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 10000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ExtractedSnippet(::std::string::String);
impl ::std::ops::Deref for ExtractedSnippet {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ExtractedSnippet> for ::std::string::String {
    fn from(value: ExtractedSnippet) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ExtractedSnippet {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 10000usize {
            return Err("longer than 10000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ExtractedSnippet {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ExtractedSnippet {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ExtractedSnippet {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ExtractedSnippet {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The URN of the specific extraction framework utilized (e.g., 'urn:coreason:extraction:docling_graph_explicit')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Extraction Framework\","]
#[doc = "  \"description\": \"The URN of the specific extraction framework utilized (e.g., 'urn:coreason:extraction:docling_graph_explicit').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ExtractionFramework(::std::string::String);
impl ::std::ops::Deref for ExtractionFramework {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ExtractionFramework> for ::std::string::String {
    fn from(value: ExtractionFramework) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ExtractionFramework {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^urn:coreason:.*$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^urn:coreason:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ExtractionFramework {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ExtractionFramework {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ExtractionFramework {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ExtractionFramework {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Edward Tufte's principles of Small Multiples (Trellis displays) by establishing a categorical partitioning matrix for high-dimensional data projections.\n\nCAUSAL AFFORDANCE: Authorizes the rendering engine to recursively split and project a singular visual grammar into a grid of structurally isomorphic sub-manifolds based on distinct categorical fields.\n\nEPISTEMIC BOUNDS: The partitioning constraints (`row_field`, `column_field`) are both optional (`default=None`) and physically bounded by `max_length=2000` to mathematically prevent Dictionary Bombing and OOM crashes during matrix generation.\n\nMCP ROUTING TRIGGERS: Small Multiples, Trellis Display, Isomorphic Sub-Manifold, High-Dimensional Projection, Categorical Partitioning"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"FacetMatrixProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Edward Tufte's principles of Small Multiples (Trellis displays) by establishing a categorical partitioning matrix for high-dimensional data projections.\\n\\nCAUSAL AFFORDANCE: Authorizes the rendering engine to recursively split and project a singular visual grammar into a grid of structurally isomorphic sub-manifolds based on distinct categorical fields.\\n\\nEPISTEMIC BOUNDS: The partitioning constraints (`row_field`, `column_field`) are both optional (`default=None`) and physically bounded by `max_length=2000` to mathematically prevent Dictionary Bombing and OOM crashes during matrix generation.\\n\\nMCP ROUTING TRIGGERS: Small Multiples, Trellis Display, Isomorphic Sub-Manifold, High-Dimensional Projection, Categorical Partitioning\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"properties\": {"]
#[doc = "    \"column_field\": {"]
#[doc = "      \"title\": \"Column Field\","]
#[doc = "      \"description\": \"The dataset field used to split the chart into columns.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"row_field\": {"]
#[doc = "      \"title\": \"Row Field\","]
#[doc = "      \"description\": \"The dataset field used to split the chart into rows.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct FacetMatrixProfile {
    #[doc = "The dataset field used to split the chart into columns."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub column_field: ::std::option::Option<::std::string::String>,
    #[doc = "The dataset field used to split the chart into rows."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub row_field: ::std::option::Option<::std::string::String>,
}
impl ::std::default::Default for FacetMatrixProfile {
    fn default() -> Self {
        Self {
            column_field: Default::default(),
            row_field: Default::default(),
        }
    }
}
impl FacetMatrixProfile {
    pub fn builder() -> builder::FacetMatrixProfile {
        Default::default()
    }
}
#[doc = "`FailedProjectionCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Failed Projection Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct FailedProjectionCid(::std::string::String);
impl ::std::ops::Deref for FailedProjectionCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<FailedProjectionCid> for ::std::string::String {
    fn from(value: FailedProjectionCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for FailedProjectionCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for FailedProjectionCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FailedProjectionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FailedProjectionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for FailedProjectionCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The exact RFC 6902 JSON pointer isolating the topological failure."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Failing Pointer\","]
#[doc = "  \"description\": \"The exact RFC 6902 JSON pointer isolating the topological failure.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct FailingPointer(::std::string::String);
impl ::std::ops::Deref for FailingPointer {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<FailingPointer> for ::std::string::String {
    fn from(value: FailingPointer) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for FailingPointer {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for FailingPointer {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FailingPointer {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FailingPointer {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for FailingPointer {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The deterministic default applied if intent classification falls below the safety threshold."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Fallback Heuristic\","]
#[doc = "  \"description\": \"The deterministic default applied if intent classification falls below the safety threshold.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"chronological\","]
#[doc = "    \"entity_centric\","]
#[doc = "    \"semantic_cluster\","]
#[doc = "    \"confidence_decay\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum FallbackHeuristic {
    #[serde(rename = "chronological")]
    Chronological,
    #[serde(rename = "entity_centric")]
    EntityCentric,
    #[serde(rename = "semantic_cluster")]
    SemanticCluster,
    #[serde(rename = "confidence_decay")]
    ConfidenceDecay,
}
impl ::std::fmt::Display for FallbackHeuristic {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Chronological => f.write_str("chronological"),
            Self::EntityCentric => f.write_str("entity_centric"),
            Self::SemanticCluster => f.write_str("semantic_cluster"),
            Self::ConfidenceDecay => f.write_str("confidence_decay"),
        }
    }
}
impl ::std::str::FromStr for FallbackHeuristic {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "chronological" => Ok(Self::Chronological),
            "entity_centric" => Ok(Self::EntityCentric),
            "semantic_cluster" => Ok(Self::SemanticCluster),
            "confidence_decay" => Ok(Self::ConfidenceDecay),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for FallbackHeuristic {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FallbackHeuristic {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FallbackHeuristic {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Graceful Degradation within a Markov Decision Process (MDP), executing a deterministic policy intervention to escape an absorbing state (terminal failure) upon node collapse. As an ...Intent suffix, this is a kinetic execution trigger.\n\nCAUSAL AFFORDANCE: Re-routes the probabilistic execution wave from a failing primary node (`target_node_cid`) to a pre-verified, lower-variance backup node (`fallback_node_cid`), actively bypassing structural collapse and maintaining systemic liveness.\n\nEPISTEMIC BOUNDS: Enforces strict structural referential integrity by requiring both `target_node_cid` and `fallback_node_cid` to resolve to mathematically valid `NodeCIDState` DIDs, severing hallucinated graph traversals.\n\nMCP ROUTING TRIGGERS: Markov Decision Process, Absorbing State, Graceful Degradation, Control-Flow Override, Policy Intervention"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"FallbackIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Graceful Degradation within a Markov Decision Process (MDP), executing a deterministic policy intervention to escape an absorbing state (terminal failure) upon node collapse. As an ...Intent suffix, this is a kinetic execution trigger.\\n\\nCAUSAL AFFORDANCE: Re-routes the probabilistic execution wave from a failing primary node (`target_node_cid`) to a pre-verified, lower-variance backup node (`fallback_node_cid`), actively bypassing structural collapse and maintaining systemic liveness.\\n\\nEPISTEMIC BOUNDS: Enforces strict structural referential integrity by requiring both `target_node_cid` and `fallback_node_cid` to resolve to mathematically valid `NodeCIDState` DIDs, severing hallucinated graph traversals.\\n\\nMCP ROUTING TRIGGERS: Markov Decision Process, Absorbing State, Graceful Degradation, Control-Flow Override, Policy Intervention\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"fallback_node_cid\","]
#[doc = "    \"target_node_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"fallback_node_cid\": {"]
#[doc = "      \"description\": \"The deterministic capability pointer representing the node to use as a fallback.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"description\": \"The deterministic capability pointer representing the failing node.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The type of the resilience payload.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"fallback_intent\","]
#[doc = "      \"le\": 18446744073709551615"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct FallbackIntent {
    #[doc = "The deterministic capability pointer representing the node to use as a fallback."]
    pub fallback_node_cid: NodeCidState,
    #[doc = "The deterministic capability pointer representing the failing node."]
    pub target_node_cid: NodeCidState,
    #[doc = "The type of the resilience payload."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl FallbackIntent {
    pub fn builder() -> builder::FallbackIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes a Hard Real-Time Systems deadline for Supervisory Control\nTheory interactions, mathematically bounding the Halting Problem during human-in-the-loop\npauses. As an ...SLA suffix, this object enforces rigid mathematical boundaries globally.\n\nCAUSAL AFFORDANCE: Dictates the deterministic timeout_action\n(Literal[\"fail_safe\", \"proceed_with_defaults\", \"escalate\"]) the orchestrator must execute\nwhen the temporal limit expires, structurally preventing execution deadlocks. If\nescalation is selected, traffic routes to the optional escalation_target_node_cid.\n\nEPISTEMIC BOUNDS: The temporal envelope is physically capped by timeout_seconds (gt=0,\nle=18446744073709551615 — a strict 24-hour absolute maximum TTL). Escalation routing targets a valid\nNodeCIDState (escalation_target_node_cid, default=None).\n\nMCP ROUTING TRIGGERS: Hard Real-Time Systems, Supervisory Control Theory, Execution\nDeadlock Prevention, Bounded Delay, Liveness Guarantee"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"FallbackSLA\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes a Hard Real-Time Systems deadline for Supervisory Control\\nTheory interactions, mathematically bounding the Halting Problem during human-in-the-loop\\npauses. As an ...SLA suffix, this object enforces rigid mathematical boundaries globally.\\n\\nCAUSAL AFFORDANCE: Dictates the deterministic timeout_action\\n(Literal[\\\"fail_safe\\\", \\\"proceed_with_defaults\\\", \\\"escalate\\\"]) the orchestrator must execute\\nwhen the temporal limit expires, structurally preventing execution deadlocks. If\\nescalation is selected, traffic routes to the optional escalation_target_node_cid.\\n\\nEPISTEMIC BOUNDS: The temporal envelope is physically capped by timeout_seconds (gt=0,\\nle=18446744073709551615 — a strict 24-hour absolute maximum TTL). Escalation routing targets a valid\\nNodeCIDState (escalation_target_node_cid, default=None).\\n\\nMCP ROUTING TRIGGERS: Hard Real-Time Systems, Supervisory Control Theory, Execution\\nDeadlock Prevention, Bounded Delay, Liveness Guarantee\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"timeout_action\","]
#[doc = "    \"timeout_seconds\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"escalation_target_node_cid\": {"]
#[doc = "      \"description\": \"The specific NodeCIDState to route the execution to if the escalate action is triggered.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timeout_action\": {"]
#[doc = "      \"title\": \"Timeout Action\","]
#[doc = "      \"description\": \"The action to take when the timeout expires.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"fail_safe\","]
#[doc = "        \"proceed_with_defaults\","]
#[doc = "        \"escalate\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timeout_seconds\": {"]
#[doc = "      \"title\": \"Timeout Seconds\","]
#[doc = "      \"description\": \"The maximum allowed delay for a human intervention.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct FallbackSla {
    #[doc = "The specific NodeCIDState to route the execution to if the escalate action is triggered."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub escalation_target_node_cid: ::std::option::Option<NodeCidState>,
    #[doc = "The action to take when the timeout expires."]
    pub timeout_action: TimeoutAction,
    #[doc = "The maximum allowed delay for a human intervention."]
    pub timeout_seconds: ::std::num::NonZeroU64,
}
impl FallbackSla {
    pub fn builder() -> builder::FallbackSla {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A contract deploying constraint oracles to hunt for counter-models to falsify a hypothesis."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"FalsificationContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A contract deploying constraint oracles to hunt for counter-models to falsify a hypothesis.\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"target_hypothesis_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"counter_model_receipt_cid\": {"]
#[doc = "      \"description\": \"MUST point to a FormalVerificationReceipt evaluating to SATISFIABLE to collapse the hypothesis.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"falsification_solver\": {"]
#[doc = "      \"title\": \"Falsification Solver\","]
#[doc = "      \"description\": \"The constraint oracle tasked with finding a counter-model.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"clingo\","]
#[doc = "        \"z3\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_hypothesis_cid\": {"]
#[doc = "      \"description\": \"Pointer to the hypothesis claim being challenged.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"falsification_contract\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct FalsificationContract {
    #[doc = "MUST point to a FormalVerificationReceipt evaluating to SATISFIABLE to collapse the hypothesis."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub counter_model_receipt_cid: ::std::option::Option<NodeCidState>,
    #[doc = "The constraint oracle tasked with finding a counter-model."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub falsification_solver: ::std::option::Option<FalsificationSolver>,
    #[doc = "Pointer to the hypothesis claim being challenged."]
    pub target_hypothesis_cid: NodeCidState,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl FalsificationContract {
    pub fn builder() -> builder::FalsificationContract {
        Default::default()
    }
}
#[doc = "The constraint oracle tasked with finding a counter-model."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Falsification Solver\","]
#[doc = "  \"description\": \"The constraint oracle tasked with finding a counter-model.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"clingo\","]
#[doc = "    \"z3\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum FalsificationSolver {
    #[serde(rename = "clingo")]
    Clingo,
    #[serde(rename = "z3")]
    Z3,
}
impl ::std::fmt::Display for FalsificationSolver {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Clingo => f.write_str("clingo"),
            Self::Z3 => f.write_str("z3"),
        }
    }
}
impl ::std::str::FromStr for FalsificationSolver {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "clingo" => Ok(Self::Clingo),
            "z3" => Ok(Self::Z3),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for FalsificationSolver {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FalsificationSolver {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FalsificationSolver {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`FalsifiedHypothesisCidsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct FalsifiedHypothesisCidsItem(::std::string::String);
impl ::std::ops::Deref for FalsifiedHypothesisCidsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<FalsifiedHypothesisCidsItem> for ::std::string::String {
    fn from(value: FalsifiedHypothesisCidsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for FalsifiedHypothesisCidsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for FalsifiedHypothesisCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FalsifiedHypothesisCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FalsifiedHypothesisCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for FalsifiedHypothesisCidsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The expected data schema or regex pattern that, if returned by the tool, kills the hypothesis."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Falsifying Observation Signature\","]
#[doc = "  \"description\": \"The expected data schema or regex pattern that, if returned by the tool, kills the hypothesis.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct FalsifyingObservationSignature(::std::string::String);
impl ::std::ops::Deref for FalsifyingObservationSignature {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<FalsifyingObservationSignature> for ::std::string::String {
    fn from(value: FalsifyingObservationSignature) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for FalsifyingObservationSignature {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for FalsifyingObservationSignature {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FalsifyingObservationSignature {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FalsifyingObservationSignature {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for FalsifyingObservationSignature {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A cryptographic Lineage Watermark (CID) tracking this specific dimensional collapse."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Fault Cid\","]
#[doc = "  \"description\": \"A cryptographic Lineage Watermark (CID) tracking this specific dimensional collapse.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct FaultCid(::std::string::String);
impl ::std::ops::Deref for FaultCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<FaultCid> for ::std::string::String {
    fn from(value: FaultCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for FaultCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for FaultCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FaultCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FaultCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for FaultCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The specific homomorphic encryption dialect used to encode the ciphertext."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Fhe Scheme\","]
#[doc = "  \"description\": \"The specific homomorphic encryption dialect used to encode the ciphertext.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"ckks\","]
#[doc = "    \"bgv\","]
#[doc = "    \"bfv\","]
#[doc = "    \"tfhe\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum FheScheme {
    #[serde(rename = "ckks")]
    Ckks,
    #[serde(rename = "bgv")]
    Bgv,
    #[serde(rename = "bfv")]
    Bfv,
    #[serde(rename = "tfhe")]
    Tfhe,
}
impl ::std::fmt::Display for FheScheme {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Ckks => f.write_str("ckks"),
            Self::Bgv => f.write_str("bgv"),
            Self::Bfv => f.write_str("bfv"),
            Self::Tfhe => f.write_str("tfhe"),
        }
    }
}
impl ::std::str::FromStr for FheScheme {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "ckks" => Ok(Self::Ckks),
            "bgv" => Ok(Self::Bgv),
            "bfv" => Ok(Self::Bfv),
            "tfhe" => Ok(Self::Tfhe),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for FheScheme {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FheScheme {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FheScheme {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The exact column or field name from the semantic series."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Field\","]
#[doc = "  \"description\": \"The exact column or field name from the semantic series.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Field(::std::string::String);
impl ::std::ops::Deref for Field {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Field> for ::std::string::String {
    fn from(value: Field) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Field {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Field {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Field {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Field {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Field {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A string pointing to the exact TokenBurnReceipt CID that pushed the state over the limit."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Final Burn Receipt Cid\","]
#[doc = "  \"description\": \"A string pointing to the exact TokenBurnReceipt CID that pushed the state over the limit.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct FinalBurnReceiptCid(::std::string::String);
impl ::std::ops::Deref for FinalBurnReceiptCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<FinalBurnReceiptCid> for ::std::string::String {
    fn from(value: FinalBurnReceiptCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for FinalBurnReceiptCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for FinalBurnReceiptCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FinalBurnReceiptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FinalBurnReceiptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for FinalBurnReceiptCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines a specific mathematical objective function (fitness dimension)\nwithin a multi-objective optimization landscape for evaluating agent phenotypes. As a\n...Profile suffix, this is a declarative, frozen snapshot of an evaluation geometry.\n\nCAUSAL AFFORDANCE: Provides the mathematical vector (OptimizationDirectionProfile:\nminimize/maximize) and scalar weight required by the orchestrator to score an agent's\nexecution telemetry, ultimately determining its survival on the Pareto Efficiency\nfrontier.\n\nEPISTEMIC BOUNDS: The relative influence of this objective is mathematically clamped by\nthe weight field (le=1.0, default=1.0) to prevent gradient or reward explosion during\nfitness aggregation. The target_metric is bounded to max_length=2000.\n\nMCP ROUTING TRIGGERS: Fitness Landscape, Objective Function, Multi-Objective\nOptimization, Phenotype Scoring, Pareto Efficiency"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"FitnessObjectiveProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines a specific mathematical objective function (fitness dimension)\\nwithin a multi-objective optimization landscape for evaluating agent phenotypes. As a\\n...Profile suffix, this is a declarative, frozen snapshot of an evaluation geometry.\\n\\nCAUSAL AFFORDANCE: Provides the mathematical vector (OptimizationDirectionProfile:\\nminimize/maximize) and scalar weight required by the orchestrator to score an agent's\\nexecution telemetry, ultimately determining its survival on the Pareto Efficiency\\nfrontier.\\n\\nEPISTEMIC BOUNDS: The relative influence of this objective is mathematically clamped by\\nthe weight field (le=1.0, default=1.0) to prevent gradient or reward explosion during\\nfitness aggregation. The target_metric is bounded to max_length=2000.\\n\\nMCP ROUTING TRIGGERS: Fitness Landscape, Objective Function, Multi-Objective\\nOptimization, Phenotype Scoring, Pareto Efficiency\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"direction\","]
#[doc = "    \"target_metric\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"direction\": {"]
#[doc = "      \"description\": \"Whether the algorithm should maximize or minimize this metric.\","]
#[doc = "      \"$ref\": \"#/$defs/OptimizationDirectionProfile\""]
#[doc = "    },"]
#[doc = "    \"target_metric\": {"]
#[doc = "      \"title\": \"Target Metric\","]
#[doc = "      \"description\": \"The specific telemetry or execution metric to evaluate (e.g., 'latency', 'accuracy').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"weight\": {"]
#[doc = "      \"title\": \"Weight\","]
#[doc = "      \"description\": \"The relative importance of this objective in a multi-objective generation.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct FitnessObjectiveProfile {
    #[doc = "Whether the algorithm should maximize or minimize this metric."]
    pub direction: OptimizationDirectionProfile,
    #[doc = "The specific telemetry or execution metric to evaluate (e.g., 'latency', 'accuracy')."]
    pub target_metric: TargetMetric,
    #[doc = "The relative importance of this objective in a multi-objective generation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub weight: ::std::option::Option<f64>,
}
impl FitnessObjectiveProfile {
    pub fn builder() -> builder::FitnessObjectiveProfile {
        Default::default()
    }
}
#[doc = "The specific neural architecture used to estimate flow."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Flow Estimation Matrix\","]
#[doc = "  \"description\": \"The specific neural architecture used to estimate flow.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct FlowEstimationMatrix(::std::string::String);
impl ::std::ops::Deref for FlowEstimationMatrix {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<FlowEstimationMatrix> for ::std::string::String {
    fn from(value: FlowEstimationMatrix) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for FlowEstimationMatrix {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for FlowEstimationMatrix {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FlowEstimationMatrix {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FlowEstimationMatrix {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for FlowEstimationMatrix {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`ForbiddenIntentsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ForbiddenIntentsItem(::std::string::String);
impl ::std::ops::Deref for ForbiddenIntentsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ForbiddenIntentsItem> for ::std::string::String {
    fn from(value: ForbiddenIntentsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ForbiddenIntentsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ForbiddenIntentsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ForbiddenIntentsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ForbiddenIntentsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ForbiddenIntentsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The raw code or formal proof syntax generated by the LLM to be evaluated."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Formal Grammar Payload\","]
#[doc = "  \"description\": \"The raw code or formal proof syntax generated by the LLM to be evaluated.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct FormalGrammarPayload(::std::string::String);
impl ::std::ops::Deref for FormalGrammarPayload {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<FormalGrammarPayload> for ::std::string::String {
    fn from(value: FormalGrammarPayload) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for FormalGrammarPayload {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for FormalGrammarPayload {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FormalGrammarPayload {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FormalGrammarPayload {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for FormalGrammarPayload {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The exact topological logic required to execute the crosswalk, strictly written as a flat, executable formal logic string (e.g., SWRL, ASP, or Prolog syntax) rather than a nested dictionary."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Formal Logic Clauses\","]
#[doc = "  \"description\": \"The exact topological logic required to execute the crosswalk, strictly written as a flat, executable formal logic string (e.g., SWRL, ASP, or Prolog syntax) rather than a nested dictionary.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 65536"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct FormalLogicClauses(::std::string::String);
impl ::std::ops::Deref for FormalLogicClauses {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<FormalLogicClauses> for ::std::string::String {
    fn from(value: FormalLogicClauses) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for FormalLogicClauses {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 65536usize {
            return Err("longer than 65536 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for FormalLogicClauses {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FormalLogicClauses {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FormalLogicClauses {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for FormalLogicClauses {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A unified categorical abstraction for all formal logic, constraint satisfaction, and theorem-proving hypotheses.\n\nCAUSAL AFFORDANCE: Physically authorizes the orchestrator to model and solve logic domains by mapping the declarative payload to the target solver defined by the dialect_urn.\n\nEPISTEMIC BOUNDS: Constrained strictly to formal syntaxes (e.g., SMT-LIB, Lean 4, ASP, Prolog) via high-capacity string bounds.\n\nMCP ROUTING TRIGGERS: Automated Theorem Proving, Constraint Satisfaction, Logic Programming, Substrate Oracle"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"FormalLogicPremise\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A unified categorical abstraction for all formal logic, constraint satisfaction, and theorem-proving hypotheses.\\n\\nCAUSAL AFFORDANCE: Physically authorizes the orchestrator to model and solve logic domains by mapping the declarative payload to the target solver defined by the dialect_urn.\\n\\nEPISTEMIC BOUNDS: Constrained strictly to formal syntaxes (e.g., SMT-LIB, Lean 4, ASP, Prolog) via high-capacity string bounds.\\n\\nMCP ROUTING TRIGGERS: Automated Theorem Proving, Constraint Satisfaction, Logic Programming, Substrate Oracle\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"dialect_urn\","]
#[doc = "    \"formal_statement\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"dialect_urn\": {"]
#[doc = "      \"title\": \"Dialect Urn\","]
#[doc = "      \"description\": \"The URN identifying the specific formal dialect or solver (e.g., 'urn:coreason:dialect:lean4', 'urn:coreason:dialect:clingo').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "    },"]
#[doc = "    \"formal_statement\": {"]
#[doc = "      \"title\": \"Formal Statement\","]
#[doc = "      \"description\": \"The primary logical query, theorem, or ASP program.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"formal_logic_premise\""]
#[doc = "    },"]
#[doc = "    \"verification_script\": {"]
#[doc = "      \"title\": \"Verification Script\","]
#[doc = "      \"description\": \"Optional auxiliary scripts required for verification, such as Lean 4 tactic proofs or Prolog ephemeral facts.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct FormalLogicPremise {
    #[doc = "The URN identifying the specific formal dialect or solver (e.g., 'urn:coreason:dialect:lean4', 'urn:coreason:dialect:clingo')."]
    pub dialect_urn: DialectUrn,
    #[doc = "The primary logical query, theorem, or ASP program."]
    pub formal_statement: FormalStatement,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "Optional auxiliary scripts required for verification, such as Lean 4 tactic proofs or Prolog ephemeral facts."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub verification_script: ::std::option::Option<::std::string::String>,
}
impl FormalLogicPremise {
    pub fn builder() -> builder::FormalLogicPremise {
        Default::default()
    }
}
#[doc = "The primary logical query, theorem, or ASP program."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Formal Statement\","]
#[doc = "  \"description\": \"The primary logical query, theorem, or ASP program.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct FormalStatement(::std::string::String);
impl ::std::ops::Deref for FormalStatement {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<FormalStatement> for ::std::string::String {
    fn from(value: FormalStatement) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for FormalStatement {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for FormalStatement {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FormalStatement {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FormalStatement {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for FormalStatement {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The formal SMT-LIB or Lean4 language representation of the symbolic rule."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Formal Syntax Smt\","]
#[doc = "  \"description\": \"The formal SMT-LIB or Lean4 language representation of the symbolic rule.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct FormalSyntaxSmt(::std::string::String);
impl ::std::ops::Deref for FormalSyntaxSmt {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<FormalSyntaxSmt> for ::std::string::String {
    fn from(value: FormalSyntaxSmt) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for FormalSyntaxSmt {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for FormalSyntaxSmt {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FormalSyntaxSmt {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FormalSyntaxSmt {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for FormalSyntaxSmt {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Leverages Automated Theorem Proving and the Curry-Howard\nCorrespondence to bind the causal graph to a mathematically verified safety\ninvariant. As a ...Contract suffix, this enforces rigid mathematical\nboundaries globally.\n\nCAUSAL AFFORDANCE: Authorizes the Rust/C++ orchestrator to ingest a compiled\nproof artifact and mechanically verify that the topology cannot transition into\na catastrophic or forbidden geometric state. The invariant_theorem\n(max_length=2000) specifies the exact safety assertion.\n\nEPISTEMIC BOUNDS: The theorem prover dialect is strictly locked to the\nproof_system Literal [\"tla_plus\", \"lean4\", \"coq\", \"z3\"]. Cryptographic\nintegrity is guaranteed by the compiled_proof_hash (SHA-256 regex\n^[a-f0-9]{64}$).\n\nMCP ROUTING TRIGGERS: Automated Theorem Proving, Curry-Howard Correspondence,\nSafety Invariant, TLA+, Formal Methods"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"FormalVerificationContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Leverages Automated Theorem Proving and the Curry-Howard\\nCorrespondence to bind the causal graph to a mathematically verified safety\\ninvariant. As a ...Contract suffix, this enforces rigid mathematical\\nboundaries globally.\\n\\nCAUSAL AFFORDANCE: Authorizes the Rust/C++ orchestrator to ingest a compiled\\nproof artifact and mechanically verify that the topology cannot transition into\\na catastrophic or forbidden geometric state. The invariant_theorem\\n(max_length=2000) specifies the exact safety assertion.\\n\\nEPISTEMIC BOUNDS: The theorem prover dialect is strictly locked to the\\nproof_system Literal [\\\"tla_plus\\\", \\\"lean4\\\", \\\"coq\\\", \\\"z3\\\"]. Cryptographic\\nintegrity is guaranteed by the compiled_proof_hash (SHA-256 regex\\n^[a-f0-9]{64}$).\\n\\nMCP ROUTING TRIGGERS: Automated Theorem Proving, Curry-Howard Correspondence,\\nSafety Invariant, TLA+, Formal Methods\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"compiled_proof_hash\","]
#[doc = "    \"invariant_theorem\","]
#[doc = "    \"proof_system\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"compiled_proof_hash\": {"]
#[doc = "      \"title\": \"Compiled Proof Hash\","]
#[doc = "      \"description\": \"The SHA-256 fingerprint of the verified proof object that the Rust/C++ orchestrator must load and check.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"invariant_theorem\": {"]
#[doc = "      \"title\": \"Invariant Theorem\","]
#[doc = "      \"description\": \"The exact mathematical assertion or safety invariant being proven (e.g., 'No data classified as CONFIDENTIAL routes externally').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"proof_system\": {"]
#[doc = "      \"title\": \"Proof System\","]
#[doc = "      \"description\": \"The mathematical dialect and theorem prover used to compile the proof.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"lean4\","]
#[doc = "        \"z3\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"verified_receipt_cid\": {"]
#[doc = "      \"description\": \"Pointer to a FormalVerificationReceipt or HoareLogicProofReceipt validating the logic.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct FormalVerificationContract {
    #[doc = "The SHA-256 fingerprint of the verified proof object that the Rust/C++ orchestrator must load and check."]
    pub compiled_proof_hash: CompiledProofHash,
    #[doc = "The exact mathematical assertion or safety invariant being proven (e.g., 'No data classified as CONFIDENTIAL routes externally')."]
    pub invariant_theorem: InvariantTheorem,
    #[doc = "The mathematical dialect and theorem prover used to compile the proof."]
    pub proof_system: ProofSystem,
    #[doc = "Pointer to a FormalVerificationReceipt or HoareLogicProofReceipt validating the logic."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub verified_receipt_cid: ::std::option::Option<NodeCidState>,
}
impl FormalVerificationContract {
    pub fn builder() -> builder::FormalVerificationContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the unified outcome of a formal logic evaluation or theorem proof.\n\nCAUSAL AFFORDANCE: Unlocks System 2 remediation loops or graph progression by providing deterministic, algebraically verified execution traces and truth values.\n\nEPISTEMIC BOUNDS: Cryptographically anchored to the Merkle-DAG. The boolean 'is_proved' definitively represents mathematical truth.\n\nMCP ROUTING TRIGGERS: System 2 Remediation, Mathematical Truth, Proof Verification, Epistemic Ledger"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"FormalVerificationReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the unified outcome of a formal logic evaluation or theorem proof.\\n\\nCAUSAL AFFORDANCE: Unlocks System 2 remediation loops or graph progression by providing deterministic, algebraically verified execution traces and truth values.\\n\\nEPISTEMIC BOUNDS: Cryptographically anchored to the Merkle-DAG. The boolean 'is_proved' definitively represents mathematical truth.\\n\\nMCP ROUTING TRIGGERS: System 2 Remediation, Mathematical Truth, Proof Verification, Epistemic Ledger\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"is_proved\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"causal_provenance_cid\": {"]
#[doc = "      \"description\": \"Pointer to the specific node or intent that requested this formal verification.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"extracted_bindings\": {"]
#[doc = "      \"title\": \"Extracted Bindings\","]
#[doc = "      \"description\": \"Topological Exemption: DO NOT SORT. Captures answer sets or unification bindings extracted by the oracle.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"object\","]
#[doc = "        \"additionalProperties\": {"]
#[doc = "          \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "        }"]
#[doc = "      },"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"failing_context\": {"]
#[doc = "      \"title\": \"Failing Context\","]
#[doc = "      \"description\": \"The specific failing tactic state, counter-model, or syntax error preventing verification.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"is_proved\": {"]
#[doc = "      \"title\": \"Is Proved\","]
#[doc = "      \"description\": \"The definitive Boolean evaluating whether the proof succeeded, the program is satisfiable, or the deduction holds true.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The RFC 8785 Canonical hash of the immediate causal ancestor.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"satisfiability_state\": {"]
#[doc = "      \"title\": \"Satisfiability State\","]
#[doc = "      \"description\": \"Detailed satisfiability state, primarily utilized by ASP/SMT solvers.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\","]
#[doc = "          \"enum\": ["]
#[doc = "            \"SATISFIABLE\","]
#[doc = "            \"UNSATISFIABLE\","]
#[doc = "            \"UNKNOWN\","]
#[doc = "            \"OPTIMUM FOUND\""]
#[doc = "          ]"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"The precise temporal coordinate of the event realization.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"formal_verification_receipt\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct FormalVerificationReceipt {
    #[doc = "Pointer to the specific node or intent that requested this formal verification."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub causal_provenance_cid: ::std::option::Option<NodeCidState>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "Topological Exemption: DO NOT SORT. Captures answer sets or unification bindings extracted by the oracle."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub extracted_bindings:
        ::std::vec::Vec<::std::collections::HashMap<::std::string::String, JsonPrimitiveState>>,
    #[doc = "The specific failing tactic state, counter-model, or syntax error preventing verification."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub failing_context: ::std::option::Option<::std::string::String>,
    #[doc = "The definitive Boolean evaluating whether the proof succeeded, the program is satisfiable, or the deduction holds true."]
    pub is_proved: bool,
    #[doc = "The RFC 8785 Canonical hash of the immediate causal ancestor."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "Detailed satisfiability state, primarily utilized by ASP/SMT solvers."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub satisfiability_state: ::std::option::Option<FormalVerificationReceiptSatisfiabilityState>,
    #[doc = "The precise temporal coordinate of the event realization."]
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl FormalVerificationReceipt {
    pub fn builder() -> builder::FormalVerificationReceipt {
        Default::default()
    }
}
#[doc = "`FormalVerificationReceiptSatisfiabilityState`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"SATISFIABLE\","]
#[doc = "    \"UNSATISFIABLE\","]
#[doc = "    \"UNKNOWN\","]
#[doc = "    \"OPTIMUM FOUND\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum FormalVerificationReceiptSatisfiabilityState {
    #[serde(rename = "SATISFIABLE")]
    Satisfiable,
    #[serde(rename = "UNSATISFIABLE")]
    Unsatisfiable,
    #[serde(rename = "UNKNOWN")]
    Unknown,
    #[serde(rename = "OPTIMUM FOUND")]
    OptimumFound,
}
impl ::std::fmt::Display for FormalVerificationReceiptSatisfiabilityState {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Satisfiable => f.write_str("SATISFIABLE"),
            Self::Unsatisfiable => f.write_str("UNSATISFIABLE"),
            Self::Unknown => f.write_str("UNKNOWN"),
            Self::OptimumFound => f.write_str("OPTIMUM FOUND"),
        }
    }
}
impl ::std::str::FromStr for FormalVerificationReceiptSatisfiabilityState {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "SATISFIABLE" => Ok(Self::Satisfiable),
            "UNSATISFIABLE" => Ok(Self::Unsatisfiable),
            "UNKNOWN" => Ok(Self::Unknown),
            "OPTIMUM FOUND" => Ok(Self::OptimumFound),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for FormalVerificationReceiptSatisfiabilityState {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String>
    for FormalVerificationReceiptSatisfiabilityState
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String>
    for FormalVerificationReceiptSatisfiabilityState
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The identifier of the underlying model."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Foundation Matrix Name\","]
#[doc = "  \"description\": \"The identifier of the underlying model.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct FoundationMatrixName(::std::string::String);
impl ::std::ops::Deref for FoundationMatrixName {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<FoundationMatrixName> for ::std::string::String {
    fn from(value: FoundationMatrixName) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for FoundationMatrixName {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for FoundationMatrixName {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FoundationMatrixName {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FoundationMatrixName {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for FoundationMatrixName {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The unique cryptographic identifier for this local spatial volume."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Frame Cid\","]
#[doc = "  \"description\": \"The unique cryptographic identifier for this local spatial volume.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct FrameCid(::std::string::String);
impl ::std::ops::Deref for FrameCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<FrameCid> for ::std::string::String {
    fn from(value: FrameCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for FrameCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for FrameCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FrameCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FrameCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for FrameCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The explicit wave-collapse opcode dictating the resolution of concurrent branches."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Fusion Function\","]
#[doc = "  \"description\": \"The explicit wave-collapse opcode dictating the resolution of concurrent branches.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"weighted_consensus\","]
#[doc = "    \"highest_confidence\","]
#[doc = "    \"brier_score_collapse\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum FusionFunction {
    #[serde(rename = "weighted_consensus")]
    WeightedConsensus,
    #[serde(rename = "highest_confidence")]
    HighestConfidence,
    #[serde(rename = "brier_score_collapse")]
    BrierScoreCollapse,
}
impl ::std::fmt::Display for FusionFunction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::WeightedConsensus => f.write_str("weighted_consensus"),
            Self::HighestConfidence => f.write_str("highest_confidence"),
            Self::BrierScoreCollapse => f.write_str("brier_score_collapse"),
        }
    }
}
impl ::std::str::FromStr for FusionFunction {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "weighted_consensus" => Ok(Self::WeightedConsensus),
            "highest_confidence" => Ok(Self::HighestConfidence),
            "brier_score_collapse" => Ok(Self::BrierScoreCollapse),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for FusionFunction {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for FusionFunction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for FusionFunction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Asynchronous Epistemic Signaling, indicating\nthat the presented manifold requires no reciprocal causal action from the\nhuman operator.\n\nCAUSAL AFFORDANCE: Triggers a stateless UI projection event, allowing the\nswarm to update the human on peripheral task completions without halting the\nunderlying Directed Acyclic Graph (DAG) execution.\n\nEPISTEMIC BOUNDS: The execution path is rigidly constrained by the\nLiteral[\"fyi\"] type discriminator, physically preventing this object from\nbeing parsed as a blocking Mixed-Initiative state.\n\nMCP ROUTING TRIGGERS: Asynchronous Telemetry, Epistemic Signaling, Stateless\nProjection, Human-in-the-Loop"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"FYIIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Asynchronous Epistemic Signaling, indicating\\nthat the presented manifold requires no reciprocal causal action from the\\nhuman operator.\\n\\nCAUSAL AFFORDANCE: Triggers a stateless UI projection event, allowing the\\nswarm to update the human on peripheral task completions without halting the\\nunderlying Directed Acyclic Graph (DAG) execution.\\n\\nEPISTEMIC BOUNDS: The execution path is rigidly constrained by the\\nLiteral[\\\"fyi\\\"] type discriminator, physically preventing this object from\\nbeing parsed as a blocking Mixed-Initiative state.\\n\\nMCP ROUTING TRIGGERS: Asynchronous Telemetry, Epistemic Signaling, Stateless\\nProjection, Human-in-the-Loop\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"properties\": {"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for an FYI intent.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"fyi\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct FyiIntent {
    #[doc = "Discriminator for an FYI intent."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl ::std::default::Default for FyiIntent {
    fn default() -> Self {
        Self {
            topology_class: Default::default(),
        }
    }
}
impl FyiIntent {
    pub fn builder() -> builder::FyiIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Ergodic Theory and Branching Factor Analysis to\nrigorously bound the topological expansion of synthetic or fractal graphs. As\nan ...SLA suffix, this enforces rigid mathematical boundaries globally.\n\nCAUSAL AFFORDANCE: Acts as a physical gas limit on generative expansion,\nauthorizing the orchestrator to cull recursive encapsulation before it induces\nstate-space explosion or GPU VRAM exhaustion.\n\nEPISTEMIC BOUNDS: Both max_topological_depth and max_node_fanout are strictly\npositive (ge=1, le=18446744073709551615). Synthetic token economy is capped by\nmax_synthetic_tokens (ge=1, le=18446744073709551615). Geometric explosion prevention\nis delegated to runtime Admission Controllers.\n\nMCP ROUTING TRIGGERS: Ergodic Theory, Branching Factor Analysis, State-Space\nExplosion, Fractal Graph Bounding, Gas Limit"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"GenerativeManifoldSLA\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Ergodic Theory and Branching Factor Analysis to\\nrigorously bound the topological expansion of synthetic or fractal graphs. As\\nan ...SLA suffix, this enforces rigid mathematical boundaries globally.\\n\\nCAUSAL AFFORDANCE: Acts as a physical gas limit on generative expansion,\\nauthorizing the orchestrator to cull recursive encapsulation before it induces\\nstate-space explosion or GPU VRAM exhaustion.\\n\\nEPISTEMIC BOUNDS: Both max_topological_depth and max_node_fanout are strictly\\npositive (ge=1, le=18446744073709551615). Synthetic token economy is capped by\\nmax_synthetic_tokens (ge=1, le=18446744073709551615). Geometric explosion prevention\\nis delegated to runtime Admission Controllers.\\n\\nMCP ROUTING TRIGGERS: Ergodic Theory, Branching Factor Analysis, State-Space\\nExplosion, Fractal Graph Bounding, Gas Limit\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_node_fanout\","]
#[doc = "    \"max_synthetic_tokens\","]
#[doc = "    \"max_topological_depth\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_node_fanout\": {"]
#[doc = "      \"title\": \"Max Node Fanout\","]
#[doc = "      \"description\": \"The maximum number of horizontally connected nodes per topology tier.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"max_synthetic_tokens\": {"]
#[doc = "      \"title\": \"Max Synthetic Tokens\","]
#[doc = "      \"description\": \"The economic constraint on the entire generated mock payload.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"max_topological_depth\": {"]
#[doc = "      \"title\": \"Max Topological Depth\","]
#[doc = "      \"description\": \"The absolute physical depth limit for recursive encapsulation.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct GenerativeManifoldSla {
    #[doc = "The maximum number of horizontally connected nodes per topology tier."]
    pub max_node_fanout: ::std::num::NonZeroU64,
    #[doc = "The economic constraint on the entire generated mock payload."]
    pub max_synthetic_tokens: ::std::num::NonZeroU64,
    #[doc = "The absolute physical depth limit for recursive encapsulation."]
    pub max_topological_depth: ::std::num::NonZeroU64,
}
impl GenerativeManifoldSla {
    pub fn builder() -> builder::GenerativeManifoldSla {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Acts as a macroscopic Topological Data Analysis (TDA) manifold\nprojection, mapping continuous vector geometries into a discrete, traversable Directed\nAcyclic Graph (DAG). As a ...Manifest suffix, this defines a frozen, N-dimensional\ncoordinate state.\n\nCAUSAL AFFORDANCE: Projects the comprehensive Virtual File System (VFS) state to the\nhuman UI or agentic context, structurally proving the geometric relations of all\nsubordinate TaxonomicNodeStates.\n\nEPISTEMIC BOUNDS: The nodes matrix is physically capped at max_length=1000\nproperties to prevent memory overflow. The @model_validator mathematically verifies DAG\nintegrity by ensuring the root_node_cid explicitly exists within the projection matrix,\npreventing ghost nodes.\n\nMCP ROUTING TRIGGERS: Manifold Learning, Topological Data Analysis, Directed Acyclic\nGraph, Generative Taxonomy, Holographic Projection"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"GenerativeTaxonomyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Acts as a macroscopic Topological Data Analysis (TDA) manifold\\nprojection, mapping continuous vector geometries into a discrete, traversable Directed\\nAcyclic Graph (DAG). As a ...Manifest suffix, this defines a frozen, N-dimensional\\ncoordinate state.\\n\\nCAUSAL AFFORDANCE: Projects the comprehensive Virtual File System (VFS) state to the\\nhuman UI or agentic context, structurally proving the geometric relations of all\\nsubordinate TaxonomicNodeStates.\\n\\nEPISTEMIC BOUNDS: The nodes matrix is physically capped at max_length=1000\\nproperties to prevent memory overflow. The @model_validator mathematically verifies DAG\\nintegrity by ensuring the root_node_cid explicitly exists within the projection matrix,\\npreventing ghost nodes.\\n\\nMCP ROUTING TRIGGERS: Manifold Learning, Topological Data Analysis, Directed Acyclic\\nGraph, Generative Taxonomy, Holographic Projection\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"manifest_cid\","]
#[doc = "    \"nodes\","]
#[doc = "    \"root_node_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"manifest_cid\": {"]
#[doc = "      \"title\": \"Manifest Cid\","]
#[doc = "      \"description\": \"Unique Content Identifier (CID) for this generated taxonomy.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"nodes\": {"]
#[doc = "      \"title\": \"Nodes\","]
#[doc = "      \"description\": \"Flat dictionary matrix containing all nodes within the manifold.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/TaxonomicNodeState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"root_node_cid\": {"]
#[doc = "      \"title\": \"Root Node Cid\","]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring the top-level TaxonomicNodeState initiating the tree.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct GenerativeTaxonomyManifest {
    #[doc = "Unique Content Identifier (CID) for this generated taxonomy."]
    pub manifest_cid: ManifestCid,
    #[doc = "Flat dictionary matrix containing all nodes within the manifold."]
    pub nodes: ::std::collections::HashMap<::std::string::String, TaxonomicNodeState>,
    #[doc = "The globally unique decentralized identifier (DID) anchoring the top-level TaxonomicNodeState initiating the tree."]
    pub root_node_cid: RootNodeCid,
}
impl GenerativeTaxonomyManifest {
    pub fn builder() -> builder::GenerativeTaxonomyManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Superimposes macro-economic and thermodynamic constraints over the\nswarm's execution graph to prevent unbounded compute exhaustion. As a ...Policy suffix,\nthis object defines rigid mathematical boundaries that the orchestrator must enforce\nglobally.\n\nCAUSAL AFFORDANCE: Acts as the ultimate hardware guillotine, authorizing the orchestrator\nto physically sever the execution thread if thermodynamic, economic, or temporal budgets\nare breached. Includes a mandatory zero-trust @model_validator enforcing that a\ncritical-severity root governance anchor exists in the DAG.\n\nEPISTEMIC BOUNDS: Enforces absolute physical ceilings: max_budget_magnitude\n(le=18446744073709551615), max_global_tokens (le=18446744073709551615), global_timeout_seconds (ge=0,\nle=18446744073709551615 — a strict 24-hour TTL), and optional max_carbon_budget_gco2eq (ge=0.0,\nle=18446744073709551615.0). An optional FormalVerificationContract provides mathematical proofs of\nstructural correctness.\n\nMCP ROUTING TRIGGERS: Thermodynamic Compute Limits, Hardware Guillotine, Halting Problem\nBounding, ESG Constraint, Execution Envelope"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"GlobalGovernancePolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Superimposes macro-economic and thermodynamic constraints over the\\nswarm's execution graph to prevent unbounded compute exhaustion. As a ...Policy suffix,\\nthis object defines rigid mathematical boundaries that the orchestrator must enforce\\nglobally.\\n\\nCAUSAL AFFORDANCE: Acts as the ultimate hardware guillotine, authorizing the orchestrator\\nto physically sever the execution thread if thermodynamic, economic, or temporal budgets\\nare breached. Includes a mandatory zero-trust @model_validator enforcing that a\\ncritical-severity root governance anchor exists in the DAG.\\n\\nEPISTEMIC BOUNDS: Enforces absolute physical ceilings: max_budget_magnitude\\n(le=18446744073709551615), max_global_tokens (le=18446744073709551615), global_timeout_seconds (ge=0,\\nle=18446744073709551615 — a strict 24-hour TTL), and optional max_carbon_budget_gco2eq (ge=0.0,\\nle=18446744073709551615.0). An optional FormalVerificationContract provides mathematical proofs of\\nstructural correctness.\\n\\nMCP ROUTING TRIGGERS: Thermodynamic Compute Limits, Hardware Guillotine, Halting Problem\\nBounding, ESG Constraint, Execution Envelope\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"global_timeout_seconds\","]
#[doc = "    \"mandatory_license_rule\","]
#[doc = "    \"max_budget_magnitude\","]
#[doc = "    \"max_global_tokens\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"formal_verification\": {"]
#[doc = "      \"description\": \"The mathematical proof of structural correctness mandated for this execution graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/FormalVerificationContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"global_timeout_seconds\": {"]
#[doc = "      \"title\": \"Global Timeout Seconds\","]
#[doc = "      \"description\": \"The absolute Time-To-Live (TTL) for the execution envelope before graceful termination.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"mandatory_license_rule\": {"]
#[doc = "      \"description\": \"The mathematical governance constraint enforcing the root safety and licensing boundary on all execution paths.\","]
#[doc = "      \"$ref\": \"#/$defs/EpistemicGuardrailsManifest\""]
#[doc = "    },"]
#[doc = "    \"max_budget_magnitude\": {"]
#[doc = "      \"title\": \"Max Budget Magnitude\","]
#[doc = "      \"description\": \"The absolute maximum economic cost allowed for the entire swarm lifecycle.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"max_carbon_budget_gco2eq\": {"]
#[doc = "      \"title\": \"Max Carbon Budget Gco2Eq\","]
#[doc = "      \"description\": \"The absolute physical energy footprint allowed for this execution graph. If exceeded, the orchestrator terminates the swarm.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_global_tokens\": {"]
#[doc = "      \"title\": \"Max Global Tokens\","]
#[doc = "      \"description\": \"The maximum aggregate token usage allowed across all nodes.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"temporal_conflict_policy\": {"]
#[doc = "      \"description\": \"The mathematical CRDT ruleset governing distributed state synchronization.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TemporalConflictResolutionPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct GlobalGovernancePolicy {
    #[doc = "The mathematical proof of structural correctness mandated for this execution graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub formal_verification: ::std::option::Option<FormalVerificationContract>,
    #[doc = "The absolute Time-To-Live (TTL) for the execution envelope before graceful termination."]
    pub global_timeout_seconds: u64,
    #[doc = "The mathematical governance constraint enforcing the root safety and licensing boundary on all execution paths."]
    pub mandatory_license_rule: EpistemicGuardrailsManifest,
    #[doc = "The absolute maximum economic cost allowed for the entire swarm lifecycle."]
    pub max_budget_magnitude: u64,
    #[doc = "The absolute physical energy footprint allowed for this execution graph. If exceeded, the orchestrator terminates the swarm."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_carbon_budget_gco2eq: ::std::option::Option<f64>,
    #[doc = "The maximum aggregate token usage allowed across all nodes."]
    pub max_global_tokens: u64,
    #[doc = "The mathematical CRDT ruleset governing distributed state synchronization."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub temporal_conflict_policy: ::std::option::Option<TemporalConflictResolutionPolicy>,
}
impl GlobalGovernancePolicy {
    pub fn builder() -> builder::GlobalGovernancePolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A macroscopic topological container that persists global contextual qualifiers (e.g., patient cohorts, operational environments, temporal scopes) across the Merkle-DAG, shielding downstream atomic propositions from context collapse.\n\n    CAUSAL AFFORDANCE: Instructs the orchestrator's verification engine to natively execute mathematical dominance checks between a payload's classification and its context.\n\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\n\n    MCP ROUTING TRIGGERS: Contextual Qualifiers, Topological Container, Semantic Invariant, Context Collapse"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"GlobalSemanticInvariantProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A macroscopic topological container that persists global contextual qualifiers (e.g., patient cohorts, operational environments, temporal scopes) across the Merkle-DAG, shielding downstream atomic propositions from context collapse.\\n\\n    CAUSAL AFFORDANCE: Instructs the orchestrator's verification engine to natively execute mathematical dominance checks between a payload's classification and its context.\\n\\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\\n\\n    MCP ROUTING TRIGGERS: Contextual Qualifiers, Topological Container, Semantic Invariant, Context Collapse\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"invariant_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"categorical_cohorts\": {"]
#[doc = "      \"title\": \"Categorical Cohorts\","]
#[doc = "      \"description\": \"Universal set-theoretic definitions of the entities or subjects the artifact governs.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"invariant_cid\": {"]
#[doc = "      \"title\": \"Invariant Cid\","]
#[doc = "      \"description\": \"The cryptographic Merkle-DAG anchor for the invariant block.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"operational_perimeters\": {"]
#[doc = "      \"title\": \"Operational Perimeters\","]
#[doc = "      \"description\": \"An untyped but volumetrically bounded dictionary defining study arms, jurisdictions, or specific environmental conditions.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"temporal_observation_horizons\": {"]
#[doc = "      \"title\": \"Temporal Observation Horizons\","]
#[doc = "      \"description\": \"The valid chronological windows encompassing the artifact.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/TemporalBoundsProfile\""]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct GlobalSemanticInvariantProfile {
    #[doc = "Universal set-theoretic definitions of the entities or subjects the artifact governs."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub categorical_cohorts: ::std::vec::Vec<CategoricalCohortsItem>,
    #[doc = "The cryptographic Merkle-DAG anchor for the invariant block."]
    pub invariant_cid: InvariantCid,
    #[doc = "An untyped but volumetrically bounded dictionary defining study arms, jurisdictions, or specific environmental conditions."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub operational_perimeters:
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "The valid chronological windows encompassing the artifact."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub temporal_observation_horizons: ::std::vec::Vec<TemporalBoundsProfile>,
}
impl GlobalSemanticInvariantProfile {
    pub fn builder() -> builder::GlobalSemanticInvariantProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Acts as a structural invariant profile mapping the macroscopic dimensional properties of an artifact prior to deep inference.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator's routing engine to allocate specific functional experts and reserve physical VRAM budgets without needing to parse the full artifact into the active context window.\n\nEPISTEMIC BOUNDS: Memory allocation limits are mathematically bounded by token_density (ge=0, le=18446744073709551615). The @model_validator deterministically sorts the detected_modalities enum array, guaranteeing zero-variance RFC 8785 canonical hashing across distributed nodes.\n\nMCP ROUTING TRIGGERS: Structural Indexing, VRAM Budgeting, Representation Engineering, Modality Detection, RFC 8785 Canonicalization"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"GlobalSemanticProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Acts as a structural invariant profile mapping the macroscopic dimensional properties of an artifact prior to deep inference.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator's routing engine to allocate specific functional experts and reserve physical VRAM budgets without needing to parse the full artifact into the active context window.\\n\\nEPISTEMIC BOUNDS: Memory allocation limits are mathematically bounded by token_density (ge=0, le=18446744073709551615). The @model_validator deterministically sorts the detected_modalities enum array, guaranteeing zero-variance RFC 8785 canonical hashing across distributed nodes.\\n\\nMCP ROUTING TRIGGERS: Structural Indexing, VRAM Budgeting, Representation Engineering, Modality Detection, RFC 8785 Canonicalization\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"artifact_event_cid\","]
#[doc = "    \"detected_modalities\","]
#[doc = "    \"token_density\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"artifact_event_cid\": {"]
#[doc = "      \"title\": \"Artifact Event Cid\","]
#[doc = "      \"description\": \"The exact genesis globally unique decentralized identifier (DID) anchoring the MultimodalArtifactReceipt entering the routing tier.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"detected_modalities\": {"]
#[doc = "      \"title\": \"Detected Modalities\","]
#[doc = "      \"description\": \"The strictly typed enum array of physical modalities detected in the artifact.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"enum\": ["]
#[doc = "          \"text\","]
#[doc = "          \"raster_image\","]
#[doc = "          \"vector_graphics\","]
#[doc = "          \"tabular_grid\","]
#[doc = "          \"n_dimensional_tensor\""]
#[doc = "        ]"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"token_density\": {"]
#[doc = "      \"title\": \"Token Density\","]
#[doc = "      \"description\": \"The mathematical token density governing downstream compute budget allocation.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct GlobalSemanticProfile {
    #[doc = "The exact genesis globally unique decentralized identifier (DID) anchoring the MultimodalArtifactReceipt entering the routing tier."]
    pub artifact_event_cid: ArtifactEventCid,
    #[doc = "The strictly typed enum array of physical modalities detected in the artifact."]
    pub detected_modalities: ::std::vec::Vec<DetectedModalitiesItem>,
    #[doc = "The mathematical token density governing downstream compute budget allocation."]
    pub token_density: u64,
}
impl GlobalSemanticProfile {
    pub fn builder() -> builder::GlobalSemanticProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines a discrete objective dimension within a Multi-Attribute\nUtility Theory (MAUT) framework. As a ...Profile suffix, this is a declarative,\nfrozen snapshot of an evaluation geometry.\n\nCAUSAL AFFORDANCE: Provides the orchestrator's reward model with a formalized\nmathematical vector to compute partial utility scores during algorithmic adjudication.\nThe description field (max_length=2000) carries the exact logical boundary.\n\nEPISTEMIC BOUNDS: The objective significance is physically constrained by weight\n(ge=0.0, le=100.0). The geometric perimeter is locked to a 128-char criterion_cid CID\nregex.\n\nMCP ROUTING TRIGGERS: Multi-Criteria Decision Analysis, Dimensional Weighting,\nBehavioral Scoring, MCDA, Scalar Boundary"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"GradingCriterionProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines a discrete objective dimension within a Multi-Attribute\\nUtility Theory (MAUT) framework. As a ...Profile suffix, this is a declarative,\\nfrozen snapshot of an evaluation geometry.\\n\\nCAUSAL AFFORDANCE: Provides the orchestrator's reward model with a formalized\\nmathematical vector to compute partial utility scores during algorithmic adjudication.\\nThe description field (max_length=2000) carries the exact logical boundary.\\n\\nEPISTEMIC BOUNDS: The objective significance is physically constrained by weight\\n(ge=0.0, le=100.0). The geometric perimeter is locked to a 128-char criterion_cid CID\\nregex.\\n\\nMCP ROUTING TRIGGERS: Multi-Criteria Decision Analysis, Dimensional Weighting,\\nBehavioral Scoring, MCDA, Scalar Boundary\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"criterion_cid\","]
#[doc = "    \"description\","]
#[doc = "    \"weight\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"criterion_cid\": {"]
#[doc = "      \"title\": \"Criterion Cid\","]
#[doc = "      \"description\": \"Unique identifier for the grading criterion.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"description\": {"]
#[doc = "      \"title\": \"Description\","]
#[doc = "      \"description\": \"The exact mathematical or logical boundary the target must satisfy to pass this dimensional check.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"weight\": {"]
#[doc = "      \"title\": \"Weight\","]
#[doc = "      \"description\": \"Weight or significance of this criterion.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 100.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct GradingCriterionProfile {
    #[doc = "Unique identifier for the grading criterion."]
    pub criterion_cid: CriterionCid,
    #[doc = "The exact mathematical or logical boundary the target must satisfy to pass this dimensional check."]
    pub description: Description,
    #[doc = "Weight or significance of this criterion."]
    pub weight: f64,
}
impl GradingCriterionProfile {
    pub fn builder() -> builder::GradingCriterionProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Leland Wilkinson's Grammar of Graphics to deterministically project N-dimensional Epistemic Ledger state into a 2D topological manifold.\n\nCAUSAL AFFORDANCE: Authorizes the frontend rendering engine to construct geometric marks (`Literal[\"point\", \"line\", \"area\", \"bar\", \"rect\", \"arc\"]`) driven strictly by the underlying `ledger_source_cid`.\n\nEPISTEMIC BOUNDS: Bounded by a rigid `encodings` array sorted mathematically by `channel` via a `@model_validator` to preserve RFC 8785 canonical hashing. Prevents hallucinated visuals by strictly linking to a verified `ledger_source_cid` CID.\n\nMCP ROUTING TRIGGERS: Grammar of Graphics, Data Visualization, Geometric Projection, Declarative UI, Retinal Variables"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"GrammarPanelProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Leland Wilkinson's Grammar of Graphics to deterministically project N-dimensional Epistemic Ledger state into a 2D topological manifold.\\n\\nCAUSAL AFFORDANCE: Authorizes the frontend rendering engine to construct geometric marks (`Literal[\\\"point\\\", \\\"line\\\", \\\"area\\\", \\\"bar\\\", \\\"rect\\\", \\\"arc\\\"]`) driven strictly by the underlying `ledger_source_cid`.\\n\\nEPISTEMIC BOUNDS: Bounded by a rigid `encodings` array sorted mathematically by `channel` via a `@model_validator` to preserve RFC 8785 canonical hashing. Prevents hallucinated visuals by strictly linking to a verified `ledger_source_cid` CID.\\n\\nMCP ROUTING TRIGGERS: Grammar of Graphics, Data Visualization, Geometric Projection, Declarative UI, Retinal Variables\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"encodings\","]
#[doc = "    \"ledger_source_cid\","]
#[doc = "    \"mark\","]
#[doc = "    \"panel_cid\","]
#[doc = "    \"title\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"billboard_physics\": {"]
#[doc = "      \"description\": \"The kinematic constraint anchoring this 2D panel to the 3D topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SpatialBillboardContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"encodings\": {"]
#[doc = "      \"title\": \"Encodings\","]
#[doc = "      \"description\": \"The mapping of structural fields to visual channels.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/VisualEncodingProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"facet\": {"]
#[doc = "      \"description\": \"Optional faceting matrix for small multiples.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/FacetMatrixProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"ledger_source_cid\": {"]
#[doc = "      \"title\": \"Ledger Source Cid\","]
#[doc = "      \"description\": \"The cryptographic pointer to the semantic series in the EpistemicLedgerState.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"mark\": {"]
#[doc = "      \"title\": \"Mark\","]
#[doc = "      \"description\": \"The geometric shape used to represent the matrix.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"point\","]
#[doc = "        \"line\","]
#[doc = "        \"area\","]
#[doc = "        \"bar\","]
#[doc = "        \"rect\","]
#[doc = "        \"arc\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"panel_cid\": {"]
#[doc = "      \"title\": \"Panel Cid\","]
#[doc = "      \"description\": \"The unique identifier for this UI panel.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"title\": {"]
#[doc = "      \"title\": \"Title\","]
#[doc = "      \"description\": \"The declarative semantic anchor summarizing the underlying visual grammar.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for Grammar of Graphics charts.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"grammar\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct GrammarPanelProfile {
    #[doc = "The kinematic constraint anchoring this 2D panel to the 3D topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub billboard_physics: ::std::option::Option<SpatialBillboardContract>,
    #[doc = "The mapping of structural fields to visual channels."]
    pub encodings: ::std::vec::Vec<VisualEncodingProfile>,
    #[doc = "Optional faceting matrix for small multiples."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub facet: ::std::option::Option<FacetMatrixProfile>,
    #[doc = "The cryptographic pointer to the semantic series in the EpistemicLedgerState."]
    pub ledger_source_cid: LedgerSourceCid,
    #[doc = "The geometric shape used to represent the matrix."]
    pub mark: Mark,
    #[doc = "The unique identifier for this UI panel."]
    pub panel_cid: PanelCid,
    #[doc = "The declarative semantic anchor summarizing the underlying visual grammar."]
    pub title: Title,
    #[doc = "Discriminator for Grammar of Graphics charts."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl GrammarPanelProfile {
    pub fn builder() -> builder::GrammarPanelProfile {
        Default::default()
    }
}
#[doc = "`GraphCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Graph Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct GraphCid(::std::string::String);
impl ::std::ops::Deref for GraphCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<GraphCid> for ::std::string::String {
    fn from(value: GraphCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for GraphCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for GraphCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for GraphCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for GraphCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for GraphCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A rigid Graph Isomorphism and Dimensionality Reduction protocol\ndefining the deterministic translation of high-dimensional neurosymbolic Knowledge\nGraphs into flat, tabular matrices for standard OLAP processing. As a ...Policy\nsuffix, this object defines rigid mathematical boundaries.\n\nCAUSAL AFFORDANCE: Forces the structural projection engine to serialize complex\nsemantic nodes and edges into wide-columnar arrays or adjacency matrices. The\npreserve_cryptographic_lineage boolean (default=True) guarantees Merkle-DAG hashes\nsurvive the flattening transformation.\n\nEPISTEMIC BOUNDS: The reduction geometry is rigidly constrained by Literal enums for\nnode_projection_mode [\"wide_columnar\", \"struct_array\"] and edge_projection_mode\n[\"adjacency_matrix\", \"map_array\"], mathematically severing the capability for agents\nto hallucinate unsupported tabular schemas.\n\nMCP ROUTING TRIGGERS: Graph Isomorphism, Dimensionality Reduction, Adjacency Matrix,\nWide-Columnar Projection, Structural Serialization"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"GraphFlatteningPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A rigid Graph Isomorphism and Dimensionality Reduction protocol\\ndefining the deterministic translation of high-dimensional neurosymbolic Knowledge\\nGraphs into flat, tabular matrices for standard OLAP processing. As a ...Policy\\nsuffix, this object defines rigid mathematical boundaries.\\n\\nCAUSAL AFFORDANCE: Forces the structural projection engine to serialize complex\\nsemantic nodes and edges into wide-columnar arrays or adjacency matrices. The\\npreserve_cryptographic_lineage boolean (default=True) guarantees Merkle-DAG hashes\\nsurvive the flattening transformation.\\n\\nEPISTEMIC BOUNDS: The reduction geometry is rigidly constrained by Literal enums for\\nnode_projection_mode [\\\"wide_columnar\\\", \\\"struct_array\\\"] and edge_projection_mode\\n[\\\"adjacency_matrix\\\", \\\"map_array\\\"], mathematically severing the capability for agents\\nto hallucinate unsupported tabular schemas.\\n\\nMCP ROUTING TRIGGERS: Graph Isomorphism, Dimensionality Reduction, Adjacency Matrix,\\nWide-Columnar Projection, Structural Serialization\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"edge_projection_mode\","]
#[doc = "    \"node_projection_mode\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"edge_projection_mode\": {"]
#[doc = "      \"title\": \"Edge Projection Mode\","]
#[doc = "      \"description\": \"How to flatten SemanticEdgeState.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"adjacency_matrix\","]
#[doc = "        \"map_array\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"node_projection_mode\": {"]
#[doc = "      \"title\": \"Node Projection Mode\","]
#[doc = "      \"description\": \"How to flatten SemanticNodeState.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"wide_columnar\","]
#[doc = "        \"struct_array\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"preserve_cryptographic_lineage\": {"]
#[doc = "      \"title\": \"Preserve Cryptographic Lineage\","]
#[doc = "      \"description\": \"Forces the inclusion of MultimodalTokenAnchorState hashes in the flattened row.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct GraphFlatteningPolicy {
    #[doc = "How to flatten SemanticEdgeState."]
    pub edge_projection_mode: EdgeProjectionMode,
    #[doc = "How to flatten SemanticNodeState."]
    pub node_projection_mode: NodeProjectionMode,
    #[doc = "Forces the inclusion of MultimodalTokenAnchorState hashes in the flattened row."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub preserve_cryptographic_lineage: ::std::option::Option<bool>,
}
impl GraphFlatteningPolicy {
    pub fn builder() -> builder::GraphFlatteningPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Tracks a deterministic security boundary violation emitted by the NeMo Guardrails proxy. This event is a frozen historical fact representing a failed cryptographic or semantic check.\n\nCAUSAL AFFORDANCE: Triggers an immediate suspension of the active execution trajectory and publishes a high-severity alert to the telemetry broker for remediation.\n\nEPISTEMIC BOUNDS: The event must include the specific HTTP status code (e.g., 401, 403, 406, 422) and the opaque violation manifest emitted by the proxy.\n\nMCP ROUTING TRIGGERS: Security, Guardrails, Data Loss Prevention, Policy Violation, Telemetry"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"GuardrailViolationEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Tracks a deterministic security boundary violation emitted by the NeMo Guardrails proxy. This event is a frozen historical fact representing a failed cryptographic or semantic check.\\n\\nCAUSAL AFFORDANCE: Triggers an immediate suspension of the active execution trajectory and publishes a high-severity alert to the telemetry broker for remediation.\\n\\nEPISTEMIC BOUNDS: The event must include the specific HTTP status code (e.g., 401, 403, 406, 422) and the opaque violation manifest emitted by the proxy.\\n\\nMCP ROUTING TRIGGERS: Security, Guardrails, Data Loss Prevention, Policy Violation, Telemetry\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"status_code\","]
#[doc = "    \"timestamp\","]
#[doc = "    \"violation_id\","]
#[doc = "    \"violation_type\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"status_code\": {"]
#[doc = "      \"title\": \"Status Code\","]
#[doc = "      \"description\": \"The HTTP status code returned by the Guardrails proxy.\","]
#[doc = "      \"type\": \"integer\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The type of the security violation payload.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"guardrail_violation_event\""]
#[doc = "    },"]
#[doc = "    \"violation_details\": {"]
#[doc = "      \"title\": \"Violation Details\","]
#[doc = "      \"description\": \"Detailed manifest from the Guardrails proxy.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": true"]
#[doc = "    },"]
#[doc = "    \"violation_id\": {"]
#[doc = "      \"title\": \"Violation Id\","]
#[doc = "      \"description\": \"Unique identifier for the violation event.\","]
#[doc = "      \"type\": \"string\""]
#[doc = "    },"]
#[doc = "    \"violation_type\": {"]
#[doc = "      \"title\": \"Violation Type\","]
#[doc = "      \"description\": \"The classification of the violation (e.g., 'pii_leak', 'toxic_content').\","]
#[doc = "      \"type\": \"string\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct GuardrailViolationEvent {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The HTTP status code returned by the Guardrails proxy."]
    pub status_code: i64,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "The type of the security violation payload."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "Detailed manifest from the Guardrails proxy."]
    #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
    pub violation_details: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    #[doc = "Unique identifier for the violation event."]
    pub violation_id: ::std::string::String,
    #[doc = "The classification of the violation (e.g., 'pii_leak', 'toxic_content')."]
    pub violation_type: ::std::string::String,
}
impl GuardrailViolationEvent {
    pub fn builder() -> builder::GuardrailViolationEvent {
        Default::default()
    }
}
#[doc = "Unique identifier for this symbolic delegation."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Handoff Cid\","]
#[doc = "  \"description\": \"Unique identifier for this symbolic delegation.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct HandoffCid(::std::string::String);
impl ::std::ops::Deref for HandoffCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<HandoffCid> for ::std::string::String {
    fn from(value: HandoffCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for HandoffCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for HandoffCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for HandoffCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for HandoffCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for HandoffCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents a Remote Attestation Quote generated by a Trusted Execution Environment (TEE) mathematically proving physical silicon isolation.\n\nCAUSAL AFFORDANCE: Authorizes the swarm orchestrator to securely inject RESTRICTED classification payloads into the agent's context by proving the host OS cannot read or tamper with the working memory.\n\nEPISTEMIC BOUNDS: Physically bounded by the 8192-byte `max_length` of `hardware_signature_blob`. Mathematically anchored to the exact memory state via `platform_measurement_hash` (strict SHA-256 pattern `^[a-f0-9]{64}$` representing PCRs). The `enclave_class` is constrained via URN pattern.\n\nMCP ROUTING TRIGGERS: Trusted Execution Environment, Remote Attestation, Platform Configuration Register, Hardware Root-of-Trust, SGX/TDX/Nitro"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"HardwareEnclaveReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents a Remote Attestation Quote generated by a Trusted Execution Environment (TEE) mathematically proving physical silicon isolation.\\n\\nCAUSAL AFFORDANCE: Authorizes the swarm orchestrator to securely inject RESTRICTED classification payloads into the agent's context by proving the host OS cannot read or tamper with the working memory.\\n\\nEPISTEMIC BOUNDS: Physically bounded by the 8192-byte `max_length` of `hardware_signature_blob`. Mathematically anchored to the exact memory state via `platform_measurement_hash` (strict SHA-256 pattern `^[a-f0-9]{64}$` representing PCRs). The `enclave_class` is constrained via URN pattern.\\n\\nMCP ROUTING TRIGGERS: Trusted Execution Environment, Remote Attestation, Platform Configuration Register, Hardware Root-of-Trust, SGX/TDX/Nitro\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"enclave_class\","]
#[doc = "    \"hardware_signature_blob\","]
#[doc = "    \"platform_measurement_hash\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"enclave_class\": {"]
#[doc = "      \"title\": \"Enclave Class\","]
#[doc = "      \"description\": \"The URN representing the physical silicon architecture generating the root-of-trust quote (e.g., 'urn:coreason:enclave:intel_tdx').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "    },"]
#[doc = "    \"hardware_signature_blob\": {"]
#[doc = "      \"title\": \"Hardware Signature Blob\","]
#[doc = "      \"description\": \"The base64-encoded hardware quote signed by the silicon manufacturer's master private key.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 8192"]
#[doc = "    },"]
#[doc = "    \"platform_measurement_hash\": {"]
#[doc = "      \"title\": \"Platform Measurement Hash\","]
#[doc = "      \"description\": \"The cryptographic hash of the Platform Configuration Registers (PCRs) proving the memory state was physically isolated.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct HardwareEnclaveReceipt {
    #[doc = "The URN representing the physical silicon architecture generating the root-of-trust quote (e.g., 'urn:coreason:enclave:intel_tdx')."]
    pub enclave_class: EnclaveClass,
    #[doc = "The base64-encoded hardware quote signed by the silicon manufacturer's master private key."]
    pub hardware_signature_blob: HardwareSignatureBlob,
    #[doc = "The cryptographic hash of the Platform Configuration Registers (PCRs) proving the memory state was physically isolated."]
    pub platform_measurement_hash: PlatformMeasurementHash,
}
impl HardwareEnclaveReceipt {
    pub fn builder() -> builder::HardwareEnclaveReceipt {
        Default::default()
    }
}
#[doc = "The base64-encoded hardware quote signed by the silicon manufacturer's master private key."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Hardware Signature Blob\","]
#[doc = "  \"description\": \"The base64-encoded hardware quote signed by the silicon manufacturer's master private key.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 8192"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct HardwareSignatureBlob(::std::string::String);
impl ::std::ops::Deref for HardwareSignatureBlob {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<HardwareSignatureBlob> for ::std::string::String {
    fn from(value: HardwareSignatureBlob) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for HardwareSignatureBlob {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 8192usize {
            return Err("longer than 8192 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for HardwareSignatureBlob {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for HardwareSignatureBlob {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for HardwareSignatureBlob {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for HardwareSignatureBlob {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A verifiable Directed Acyclic Graph (DAG) representing the nested visual and logical containment of an ingested multimodal artifact (e.g., Docling Output).\n\nCAUSAL AFFORDANCE: Replaces flat token arrays with an adjacency matrix, instructing the orchestrator exactly how spatial blocks physically encapsulate one another.\n\nEPISTEMIC BOUNDS: Dictionary sizes are volumetrically clamped (`max_length=100000`). The `verify_dom_dag_integrity` `@model_validator` executes a DFS mathematical proof via networkx to guarantee the absence of cyclical containment paradoxes.\n\nMCP ROUTING TRIGGERS: Spatial-Semantic Isomorphism, Document Object Model, Containment DAG, Visual Hierarchy, Rhetorical Bounding"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"HierarchicalDOMManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A verifiable Directed Acyclic Graph (DAG) representing the nested visual and logical containment of an ingested multimodal artifact (e.g., Docling Output).\\n\\nCAUSAL AFFORDANCE: Replaces flat token arrays with an adjacency matrix, instructing the orchestrator exactly how spatial blocks physically encapsulate one another.\\n\\nEPISTEMIC BOUNDS: Dictionary sizes are volumetrically clamped (`max_length=100000`). The `verify_dom_dag_integrity` `@model_validator` executes a DFS mathematical proof via networkx to guarantee the absence of cyclical containment paradoxes.\\n\\nMCP ROUTING TRIGGERS: Spatial-Semantic Isomorphism, Document Object Model, Containment DAG, Visual Hierarchy, Rhetorical Bounding\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"blocks\","]
#[doc = "    \"dom_cid\","]
#[doc = "    \"root_block_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"blocks\": {"]
#[doc = "      \"title\": \"Blocks\","]
#[doc = "      \"description\": \"The localized registry of all extracted spatial blocks.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 100000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/DocumentLayoutRegionState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"containment_edges\": {"]
#[doc = "      \"title\": \"Containment Edges\","]
#[doc = "      \"description\": \"Directed edges defining the parent-child spatial containment (Parent -> Child).\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"array\","]
#[doc = "        \"maxItems\": 2,"]
#[doc = "        \"minItems\": 2,"]
#[doc = "        \"prefixItems\": ["]
#[doc = "          {"]
#[doc = "            \"type\": \"string\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"string\""]
#[doc = "          }"]
#[doc = "        ]"]
#[doc = "      },"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"dom_cid\": {"]
#[doc = "      \"title\": \"Dom Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"root_block_cid\": {"]
#[doc = "      \"title\": \"Root Block Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"hierarchical_dom\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct HierarchicalDomManifest {
    #[doc = "The localized registry of all extracted spatial blocks."]
    pub blocks: ::std::collections::HashMap<::std::string::String, DocumentLayoutRegionState>,
    #[doc = "Directed edges defining the parent-child spatial containment (Parent -> Child)."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub containment_edges: ::std::vec::Vec<[::serde_json::Value; 2usize]>,
    pub dom_cid: DomCid,
    pub root_block_cid: RootBlockCid,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl HierarchicalDomManifest {
    pub fn builder() -> builder::HierarchicalDomManifest {
        Default::default()
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the specific historical state node where the agent mathematically diverged to simulate an alternative path."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Historical Event Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the specific historical state node where the agent mathematically diverged to simulate an alternative path.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct HistoricalEventCid(::std::string::String);
impl ::std::ops::Deref for HistoricalEventCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<HistoricalEventCid> for ::std::string::String {
    fn from(value: HistoricalEventCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for HistoricalEventCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for HistoricalEventCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for HistoricalEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for HistoricalEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for HistoricalEventCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Hoare Logic to provide cryptographic proof of algorithmic preconditions and postconditions prior to capability execution.\n\n    CAUSAL AFFORDANCE: Instructs the orchestrator's verification engine to validate the formal proof geometry prior to allocating swarm budget to a generated tool or component.\n\n    EPISTEMIC BOUNDS: Strictly relies on arrays of AlgebraicRefinementContracts, demanding at least one pre-bound and post-bound. Formal systems are strictly bounded by a Literal automaton constraint.\n\n    MCP ROUTING TRIGGERS: Hoare Logic, Automated Theorem Proving, Preconditions Postconditions, Formal Verification, Cryptographic Proof"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"HoareLogicProofReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Hoare Logic to provide cryptographic proof of algorithmic preconditions and postconditions prior to capability execution.\\n\\n    CAUSAL AFFORDANCE: Instructs the orchestrator's verification engine to validate the formal proof geometry prior to allocating swarm budget to a generated tool or component.\\n\\n    EPISTEMIC BOUNDS: Strictly relies on arrays of AlgebraicRefinementContracts, demanding at least one pre-bound and post-bound. Formal systems are strictly bounded by a Literal automaton constraint.\\n\\n    MCP ROUTING TRIGGERS: Hoare Logic, Automated Theorem Proving, Preconditions Postconditions, Formal Verification, Cryptographic Proof\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"capability_cid\","]
#[doc = "    \"postconditions\","]
#[doc = "    \"preconditions\","]
#[doc = "    \"proof_system\","]
#[doc = "    \"verified_theorem_hash\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"capability_cid\": {"]
#[doc = "      \"title\": \"Capability Cid\","]
#[doc = "      \"description\": \"The 128-char DID boundary physically binding this proof to the target executable matrix.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"postconditions\": {"]
#[doc = "      \"title\": \"Postconditions\","]
#[doc = "      \"description\": \"The strictly bounded array of subsequent AlgebraicRefinementContracts representing the Q state geometry.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/AlgebraicRefinementContract\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"preconditions\": {"]
#[doc = "      \"title\": \"Preconditions\","]
#[doc = "      \"description\": \"The strictly bounded array of foundational AlgebraicRefinementContracts representing the P state geometry.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/AlgebraicRefinementContract\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"proof_system\": {"]
#[doc = "      \"title\": \"Proof System\","]
#[doc = "      \"description\": \"The strict mathematical automaton engine responsible for evaluating the structural boundary.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"lean4\","]
#[doc = "        \"z3\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"verified_theorem_hash\": {"]
#[doc = "      \"title\": \"Verified Theorem Hash\","]
#[doc = "      \"description\": \"The absolute cryptographic SHA-256 hash mathematically proving formal state verification.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct HoareLogicProofReceipt {
    #[doc = "The 128-char DID boundary physically binding this proof to the target executable matrix."]
    pub capability_cid: CapabilityCid,
    #[doc = "The strictly bounded array of subsequent AlgebraicRefinementContracts representing the Q state geometry."]
    pub postconditions: ::std::vec::Vec<AlgebraicRefinementContract>,
    #[doc = "The strictly bounded array of foundational AlgebraicRefinementContracts representing the P state geometry."]
    pub preconditions: ::std::vec::Vec<AlgebraicRefinementContract>,
    #[doc = "The strict mathematical automaton engine responsible for evaluating the structural boundary."]
    pub proof_system: ProofSystem,
    #[doc = "The absolute cryptographic SHA-256 hash mathematically proving formal state verification."]
    pub verified_theorem_hash: VerifiedTheoremHash,
}
impl HoareLogicProofReceipt {
    pub fn builder() -> builder::HoareLogicProofReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Lattice-Based Cryptography to enable the evaluation of geometric and arithmetic operations directly on an encrypted tensor state.\n\nCAUSAL AFFORDANCE: Permits an external, untrusted orchestrator to calculate geometric distances or compute reward gradients on sensitive representations without exposing plaintext.\n\nEPISTEMIC BOUNDS: The encryption dialect is rigidly locked to the `fhe_scheme` Literal automaton `[\"ckks\", \"bgv\", \"bfv\", \"tfhe\"]`. Cryptographic memory explosion is prevented by capping `ciphertext_blob` at `max_length=5000000`. `public_key_cid` is a 128-char CID.\n\nMCP ROUTING TRIGGERS: Fully Homomorphic Encryption, Lattice-Based Cryptography, CKKS Scheme, Privacy-Preserving Computation, Encrypted Tensor"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"HomomorphicEncryptionProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Lattice-Based Cryptography to enable the evaluation of geometric and arithmetic operations directly on an encrypted tensor state.\\n\\nCAUSAL AFFORDANCE: Permits an external, untrusted orchestrator to calculate geometric distances or compute reward gradients on sensitive representations without exposing plaintext.\\n\\nEPISTEMIC BOUNDS: The encryption dialect is rigidly locked to the `fhe_scheme` Literal automaton `[\\\"ckks\\\", \\\"bgv\\\", \\\"bfv\\\", \\\"tfhe\\\"]`. Cryptographic memory explosion is prevented by capping `ciphertext_blob` at `max_length=5000000`. `public_key_cid` is a 128-char CID.\\n\\nMCP ROUTING TRIGGERS: Fully Homomorphic Encryption, Lattice-Based Cryptography, CKKS Scheme, Privacy-Preserving Computation, Encrypted Tensor\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"ciphertext_blob\","]
#[doc = "    \"fhe_scheme\","]
#[doc = "    \"public_key_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"ciphertext_blob\": {"]
#[doc = "      \"title\": \"Ciphertext Blob\","]
#[doc = "      \"description\": \"The base64-encoded homomorphic ciphertext.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 5000000"]
#[doc = "    },"]
#[doc = "    \"fhe_scheme\": {"]
#[doc = "      \"title\": \"Fhe Scheme\","]
#[doc = "      \"description\": \"The specific homomorphic encryption dialect used to encode the ciphertext.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"ckks\","]
#[doc = "        \"bgv\","]
#[doc = "        \"bfv\","]
#[doc = "        \"tfhe\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"public_key_cid\": {"]
#[doc = "      \"title\": \"Public Key Cid\","]
#[doc = "      \"description\": \"The Content Identifier (CID) of the public evaluation key the orchestrator must utilize to perform privacy-preserving geometric math on ciphertext without epistemic contamination.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct HomomorphicEncryptionProfile {
    #[doc = "The base64-encoded homomorphic ciphertext."]
    pub ciphertext_blob: CiphertextBlob,
    #[doc = "The specific homomorphic encryption dialect used to encode the ciphertext."]
    pub fhe_scheme: FheScheme,
    #[doc = "The Content Identifier (CID) of the public evaluation key the orchestrator must utilize to perform privacy-preserving geometric math on ciphertext without epistemic contamination."]
    pub public_key_cid: PublicKeyCid,
}
impl HomomorphicEncryptionProfile {
    pub fn builder() -> builder::HomomorphicEncryptionProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes a Stateless Client-Server Architecture for JSON-RPC 2.0 message passing, serving as the egress manifold for Zero-Trust Network Access (ZTNA).\n\nCAUSAL AFFORDANCE: Instructs the orchestrator to open an out-of-band HTTP socket, transmitting structured semantic payloads while strictly confining custom headers to prevent protocol manipulation.\n\nEPISTEMIC BOUNDS: The `headers` dictionary is mathematically bounded (`max_length=2000`).\n\nMCP ROUTING TRIGGERS: Stateless Architecture, Zero-Trust Network Access, HTTP Request Smuggling Prevention, JSON-RPC Egress, Out-of-Band Socket"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"HTTPTransportProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes a Stateless Client-Server Architecture for JSON-RPC 2.0 message passing, serving as the egress manifold for Zero-Trust Network Access (ZTNA).\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator to open an out-of-band HTTP socket, transmitting structured semantic payloads while strictly confining custom headers to prevent protocol manipulation.\\n\\nEPISTEMIC BOUNDS: The `headers` dictionary is mathematically bounded (`max_length=2000`).\\n\\nMCP ROUTING TRIGGERS: Stateless Architecture, Zero-Trust Network Access, HTTP Request Smuggling Prevention, JSON-RPC Egress, Out-of-Band Socket\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"uri\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"headers\": {"]
#[doc = "      \"title\": \"Headers\","]
#[doc = "      \"description\": \"HTTP headers, strictly bounded for zero-trust credentials.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Type of transport.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"http\""]
#[doc = "    },"]
#[doc = "    \"uri\": {"]
#[doc = "      \"title\": \"Uri\","]
#[doc = "      \"description\": \"The HTTP URL endpoint for the stateless connection.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"format\": \"uri\","]
#[doc = "      \"maxLength\": 2083,"]
#[doc = "      \"minLength\": 1"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct HttpTransportProfile {
    #[doc = "HTTP headers, strictly bounded for zero-trust credentials."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub headers:
        ::std::collections::HashMap<::std::string::String, HttpTransportProfileHeadersValue>,
    #[doc = "Type of transport."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The HTTP URL endpoint for the stateless connection."]
    pub uri: ::std::string::String,
}
impl HttpTransportProfile {
    pub fn builder() -> builder::HttpTransportProfile {
        Default::default()
    }
}
#[doc = "`HttpTransportProfileHeadersValue`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct HttpTransportProfileHeadersValue(::std::string::String);
impl ::std::ops::Deref for HttpTransportProfileHeadersValue {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<HttpTransportProfileHeadersValue> for ::std::string::String {
    fn from(value: HttpTransportProfileHeadersValue) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for HttpTransportProfileHeadersValue {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for HttpTransportProfileHeadersValue {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for HttpTransportProfileHeadersValue {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for HttpTransportProfileHeadersValue {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for HttpTransportProfileHeadersValue {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Translates unstructured human goals into the deterministic physics required to trigger the Agentic Forge.\n\nCAUSAL AFFORDANCE: Maps an unstructured human objective to a dense VectorEmbeddingState target, initiating capability generation.\n\nEPISTEMIC BOUNDS: `allocated_budget_magnitude` is strictly bounded between 1 and 1,000,000,000 to lock escrow. Discriminator locked to `Literal[\"human_directive\"]`.\n\nMCP ROUTING TRIGGERS: Human-in-the-Loop, Intent Translation, Agentic Forge, Objective Setting, Budget Allocation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"HumanDirectiveIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Translates unstructured human goals into the deterministic physics required to trigger the Agentic Forge.\\n\\nCAUSAL AFFORDANCE: Maps an unstructured human objective to a dense VectorEmbeddingState target, initiating capability generation.\\n\\nEPISTEMIC BOUNDS: `allocated_budget_magnitude` is strictly bounded between 1 and 1,000,000,000 to lock escrow. Discriminator locked to `Literal[\\\"human_directive\\\"]`.\\n\\nMCP ROUTING TRIGGERS: Human-in-the-Loop, Intent Translation, Agentic Forge, Objective Setting, Budget Allocation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"allocated_budget_magnitude\","]
#[doc = "    \"natural_language_goal\","]
#[doc = "    \"target_qos\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"allocated_budget_magnitude\": {"]
#[doc = "      \"title\": \"Allocated Budget Magnitude\","]
#[doc = "      \"description\": \"The absolute thermodynamic token budget the human is locking in escrow.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"natural_language_goal\": {"]
#[doc = "      \"title\": \"Natural Language Goal\","]
#[doc = "      \"description\": \"The raw, unstructured human objective.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 5000"]
#[doc = "    },"]
#[doc = "    \"target_qos\": {"]
#[doc = "      \"description\": \"The priority classification for Spot Market compute routing.\","]
#[doc = "      \"$ref\": \"#/$defs/QoSClassificationProfile\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for a human directive.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"human_directive\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct HumanDirectiveIntent {
    #[doc = "The absolute thermodynamic token budget the human is locking in escrow."]
    pub allocated_budget_magnitude: ::std::num::NonZeroU64,
    #[doc = "The raw, unstructured human objective."]
    pub natural_language_goal: NaturalLanguageGoal,
    #[doc = "The priority classification for Spot Market compute routing."]
    pub target_qos: QoSClassificationProfile,
    #[doc = "Discriminator type for a human directive."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl HumanDirectiveIntent {
    pub fn builder() -> builder::HumanDirectiveIntent {
        Default::default()
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this abductive leap to the Merkle-DAG."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Hypothesis Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this abductive leap to the Merkle-DAG.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct HypothesisCid(::std::string::String);
impl ::std::ops::Deref for HypothesisCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<HypothesisCid> for ::std::string::String {
    fn from(value: HypothesisCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for HypothesisCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for HypothesisCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for HypothesisCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for HypothesisCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for HypothesisCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Instantiates an abductive reasoning branch governed by Popperian Falsification and Bayesian updating on the Merkle-DAG.\n\nCAUSAL AFFORDANCE: Commits a formalized causal premise into the EpistemicLedgerState, unlocking the orchestration of empirical testing via active inference to falsify or verify the embedded causal model.\n\nEPISTEMIC BOUNDS: `bayesian_prior` is clamped `[ge=0.0, le=1.0]`. Identity is cryptographically locked via `hypothesis_cid` (128-char CID). `falsification_conditions` deterministically sorted by `@model_validator`.\n\nMCP ROUTING TRIGGERS: Abductive Reasoning, Popperian Falsification, Bayesian Prior, Causal Hypothesis, Epistemic Commitment"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"HypothesisGenerationEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Instantiates an abductive reasoning branch governed by Popperian Falsification and Bayesian updating on the Merkle-DAG.\\n\\nCAUSAL AFFORDANCE: Commits a formalized causal premise into the EpistemicLedgerState, unlocking the orchestration of empirical testing via active inference to falsify or verify the embedded causal model.\\n\\nEPISTEMIC BOUNDS: `bayesian_prior` is clamped `[ge=0.0, le=1.0]`. Identity is cryptographically locked via `hypothesis_cid` (128-char CID). `falsification_conditions` deterministically sorted by `@model_validator`.\\n\\nMCP ROUTING TRIGGERS: Abductive Reasoning, Popperian Falsification, Bayesian Prior, Causal Hypothesis, Epistemic Commitment\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"bayesian_prior\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"falsification_conditions\","]
#[doc = "    \"hypothesis_cid\","]
#[doc = "    \"premise_text\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"bayesian_prior\": {"]
#[doc = "      \"title\": \"Bayesian Prior\","]
#[doc = "      \"description\": \"The agent's initial probabilistic belief in this hypothesis before testing.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"causal_model\": {"]
#[doc = "      \"description\": \"The formal DAG representing the agent's structural assumptions about the environment.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StructuralCausalGraphProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"falsification_conditions\": {"]
#[doc = "      \"title\": \"Falsification Conditions\","]
#[doc = "      \"description\": \"The strict array of strict conditions that the orchestrator must test to attempt to disprove this premise.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EmpiricalFalsificationContract\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"hypothesis_cid\": {"]
#[doc = "      \"title\": \"Hypothesis Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this abductive leap to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"premise_text\": {"]
#[doc = "      \"title\": \"Premise Text\","]
#[doc = "      \"description\": \"The natural language explanation of the abductive theory.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"status\": {"]
#[doc = "      \"title\": \"Status\","]
#[doc = "      \"description\": \"The current validity state of this hypothesis in the EpistemicLedgerState.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"active\","]
#[doc = "        \"falsified\","]
#[doc = "        \"verified\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a hypothesis generation event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"hypothesis\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct HypothesisGenerationEvent {
    #[doc = "The agent's initial probabilistic belief in this hypothesis before testing."]
    pub bayesian_prior: f64,
    #[doc = "The formal DAG representing the agent's structural assumptions about the environment."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub causal_model: ::std::option::Option<StructuralCausalGraphProfile>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The strict array of strict conditions that the orchestrator must test to attempt to disprove this premise."]
    pub falsification_conditions: ::std::vec::Vec<EmpiricalFalsificationContract>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this abductive leap to the Merkle-DAG."]
    pub hypothesis_cid: HypothesisCid,
    #[doc = "The natural language explanation of the abductive theory."]
    pub premise_text: PremiseText,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The current validity state of this hypothesis in the EpistemicLedgerState."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub status: ::std::option::Option<Status>,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "Discriminator for a hypothesis generation event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl HypothesisGenerationEvent {
    pub fn builder() -> builder::HypothesisGenerationEvent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Cryptographically freezes an agent's probabilistic belief in a HypothesisGenerationEvent as an immutable economic stake on the Epistemic Ledger.\n\nCAUSAL AFFORDANCE: Projects the agent's internal `implied_probability` into the shared LMSR order book, injecting liquidity and actively shifting the global consensus gradient.\n\nEPISTEMIC BOUNDS: `agent_cid` and `target_hypothesis_cid` are strictly bounded to 128-char CIDs. `staked_magnitude` is constrained to a strictly positive integer `le=18446744073709551615, gt=0`. `implied_probability` is bounded `ge=0.0, le=1.0`.\n\nMCP ROUTING TRIGGERS: Epistemic Staking, Brier Score Input, Belief Freezing, Market Order"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"HypothesisStakeReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Cryptographically freezes an agent's probabilistic belief in a HypothesisGenerationEvent as an immutable economic stake on the Epistemic Ledger.\\n\\nCAUSAL AFFORDANCE: Projects the agent's internal `implied_probability` into the shared LMSR order book, injecting liquidity and actively shifting the global consensus gradient.\\n\\nEPISTEMIC BOUNDS: `agent_cid` and `target_hypothesis_cid` are strictly bounded to 128-char CIDs. `staked_magnitude` is constrained to a strictly positive integer `le=18446744073709551615, gt=0`. `implied_probability` is bounded `ge=0.0, le=1.0`.\\n\\nMCP ROUTING TRIGGERS: Epistemic Staking, Brier Score Input, Belief Freezing, Market Order\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"agent_cid\","]
#[doc = "    \"implied_probability\","]
#[doc = "    \"staked_magnitude\","]
#[doc = "    \"target_hypothesis_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"agent_cid\": {"]
#[doc = "      \"title\": \"Agent Cid\","]
#[doc = "      \"description\": \"The deterministic capability pointer representing the agent placing the stake.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"implied_probability\": {"]
#[doc = "      \"title\": \"Implied Probability\","]
#[doc = "      \"description\": \"The agent's calculated internal confidence score.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"staked_magnitude\": {"]
#[doc = "      \"title\": \"Staked Magnitude\","]
#[doc = "      \"description\": \"The volume of compute budget committed to this position.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"target_hypothesis_cid\": {"]
#[doc = "      \"title\": \"Target Hypothesis Cid\","]
#[doc = "      \"description\": \"The exact HypothesisGenerationEvent the agent is betting on.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct HypothesisStakeReceipt {
    #[doc = "The deterministic capability pointer representing the agent placing the stake."]
    pub agent_cid: AgentCid,
    #[doc = "The agent's calculated internal confidence score."]
    pub implied_probability: f64,
    #[doc = "The volume of compute budget committed to this position."]
    pub staked_magnitude: ::std::num::NonZeroU64,
    #[doc = "The exact HypothesisGenerationEvent the agent is betting on."]
    pub target_hypothesis_cid: TargetHypothesisCid,
}
impl HypothesisStakeReceipt {
    pub fn builder() -> builder::HypothesisStakeReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Maintains the quantum-like probability mass of mutually exclusive semantic manifolds, delaying wave collapse until deterministically evaluated.\n\nCAUSAL AFFORDANCE: Delays premature wave collapse by preserving competing hypotheses and their precise statistical probability mass.\n\nEPISTEMIC BOUNDS: Mathematically asserts that the sum of competing_manifolds probabilities is <= 1.0. Enforces deterministic sorting of residual_entropy_vectors for RFC 8785 compliance.\n\nMCP ROUTING TRIGGERS: Hypothesis Superposition, Wave Collapse, Probability Mass, Defeasible Superposition"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"HypothesisSuperpositionState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Maintains the quantum-like probability mass of mutually exclusive semantic manifolds, delaying wave collapse until deterministically evaluated.\\n\\nCAUSAL AFFORDANCE: Delays premature wave collapse by preserving competing hypotheses and their precise statistical probability mass.\\n\\nEPISTEMIC BOUNDS: Mathematically asserts that the sum of competing_manifolds probabilities is <= 1.0. Enforces deterministic sorting of residual_entropy_vectors for RFC 8785 compliance.\\n\\nMCP ROUTING TRIGGERS: Hypothesis Superposition, Wave Collapse, Probability Mass, Defeasible Superposition\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"competing_manifolds\","]
#[doc = "    \"superposition_cid\","]
#[doc = "    \"wave_collapse_function\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"competing_manifolds\": {"]
#[doc = "      \"title\": \"Competing Manifolds\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"number\","]
#[doc = "        \"maximum\": 1.0,"]
#[doc = "        \"minimum\": 0.0"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"residual_entropy_vectors\": {"]
#[doc = "      \"title\": \"Residual Entropy Vectors\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 100000"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"superposition_cid\": {"]
#[doc = "      \"title\": \"Superposition Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"wave_collapse_function\": {"]
#[doc = "      \"title\": \"Wave Collapse Function\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"plurality_vote\","]
#[doc = "        \"highest_confidence\","]
#[doc = "        \"deterministic_compiler\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct HypothesisSuperpositionState {
    pub competing_manifolds: ::std::collections::HashMap<::std::string::String, f64>,
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub residual_entropy_vectors: ::std::vec::Vec<ResidualEntropyVectorsItem>,
    pub superposition_cid: SuperpositionCid,
    pub wave_collapse_function: WaveCollapseFunction,
}
impl HypothesisSuperpositionState {
    pub fn builder() -> builder::HypothesisSuperpositionState {
        Default::default()
    }
}
#[doc = "Unique request identifier."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Id\","]
#[doc = "  \"description\": \"Unique request identifier.\","]
#[doc = "  \"anyOf\": ["]
#[doc = "    {"]
#[doc = "      \"type\": \"string\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"null\""]
#[doc = "    }"]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum Id {
    String(::std::string::String),
    Integer(u64),
    Null,
}
impl ::std::convert::From<u64> for Id {
    fn from(value: u64) -> Self {
        Self::Integer(value)
    }
}
#[doc = "AGENT INSTRUCTION: Categorizes the thermodynamic phase of the generative ensemble's exploration.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator on the execution status of the topology, governing state transitions.\n\nEPISTEMIC BOUNDS: Strictly bounded to the predefined string enumeration values.\n\nMCP ROUTING TRIGGERS: Phase Tracking, Thermodynamic Orchestration, State Machine"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"IdeationPhaseProfile\","]
#[doc = "  \"description\": \"AGENT INSTRUCTION: Categorizes the thermodynamic phase of the generative ensemble's exploration.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator on the execution status of the topology, governing state transitions.\\n\\nEPISTEMIC BOUNDS: Strictly bounded to the predefined string enumeration values.\\n\\nMCP ROUTING TRIGGERS: Phase Tracking, Thermodynamic Orchestration, State Machine\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"STOCHASTIC_DIFFUSION\","]
#[doc = "    \"ENTROPIC_EXPLORATION\","]
#[doc = "    \"TOPOLOGICAL_CRITIQUE\","]
#[doc = "    \"MANIFOLD_COLLAPSE\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum IdeationPhaseProfile {
    #[serde(rename = "STOCHASTIC_DIFFUSION")]
    StochasticDiffusion,
    #[serde(rename = "ENTROPIC_EXPLORATION")]
    EntropicExploration,
    #[serde(rename = "TOPOLOGICAL_CRITIQUE")]
    TopologicalCritique,
    #[serde(rename = "MANIFOLD_COLLAPSE")]
    ManifoldCollapse,
}
impl ::std::fmt::Display for IdeationPhaseProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::StochasticDiffusion => f.write_str("STOCHASTIC_DIFFUSION"),
            Self::EntropicExploration => f.write_str("ENTROPIC_EXPLORATION"),
            Self::TopologicalCritique => f.write_str("TOPOLOGICAL_CRITIQUE"),
            Self::ManifoldCollapse => f.write_str("MANIFOLD_COLLAPSE"),
        }
    }
}
impl ::std::str::FromStr for IdeationPhaseProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "STOCHASTIC_DIFFUSION" => Ok(Self::StochasticDiffusion),
            "ENTROPIC_EXPLORATION" => Ok(Self::EntropicExploration),
            "TOPOLOGICAL_CRITIQUE" => Ok(Self::TopologicalCritique),
            "MANIFOLD_COLLAPSE" => Ok(Self::ManifoldCollapse),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for IdeationPhaseProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for IdeationPhaseProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for IdeationPhaseProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`IdentifiedKnowledgeGapsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct IdentifiedKnowledgeGapsItem(::std::string::String);
impl ::std::ops::Deref for IdentifiedKnowledgeGapsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<IdentifiedKnowledgeGapsItem> for ::std::string::String {
    fn from(value: IdentifiedKnowledgeGapsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for IdentifiedKnowledgeGapsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for IdentifiedKnowledgeGapsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for IdentifiedKnowledgeGapsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for IdentifiedKnowledgeGapsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for IdentifiedKnowledgeGapsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "AGENT INSTRUCTION: Mathematically categorizes the structural intent of a proposition to prevent reasoning agents from hallucinating contextual truth values. Dictates whether the swarm evaluates the node as an empirical fact, a normative constraint, a guaranteed promise, or a simulation."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"IllocutionaryForceProfile\","]
#[doc = "  \"description\": \"AGENT INSTRUCTION: Mathematically categorizes the structural intent of a proposition to prevent reasoning agents from hallucinating contextual truth values. Dictates whether the swarm evaluates the node as an empirical fact, a normative constraint, a guaranteed promise, or a simulation.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"assertive\","]
#[doc = "    \"directive_normative\","]
#[doc = "    \"commissive\","]
#[doc = "    \"fictive_hypothetical\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum IllocutionaryForceProfile {
    #[serde(rename = "assertive")]
    Assertive,
    #[serde(rename = "directive_normative")]
    DirectiveNormative,
    #[serde(rename = "commissive")]
    Commissive,
    #[serde(rename = "fictive_hypothetical")]
    FictiveHypothetical,
}
impl ::std::fmt::Display for IllocutionaryForceProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Assertive => f.write_str("assertive"),
            Self::DirectiveNormative => f.write_str("directive_normative"),
            Self::Commissive => f.write_str("commissive"),
            Self::FictiveHypothetical => f.write_str("fictive_hypothetical"),
        }
    }
}
impl ::std::str::FromStr for IllocutionaryForceProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "assertive" => Ok(Self::Assertive),
            "directive_normative" => Ok(Self::DirectiveNormative),
            "commissive" => Ok(Self::Commissive),
            "fictive_hypothetical" => Ok(Self::FictiveHypothetical),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for IllocutionaryForceProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for IllocutionaryForceProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for IllocutionaryForceProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes a covariant Functor (Category Theory) mapping\nhigher-order topological state dimensions into an encapsulated subgraph's\nlocalized working memory. As a ...Contract suffix, this enforces rigid\nmathematical boundaries globally.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator's state projection engine to\nsafely inject parent variables into a CompositeNodeProfile without violating\nscope isolation or referential transparency.\n\nEPISTEMIC BOUNDS: The geometric projection vectors parent_key and child_key\nare strictly clamped to max_length=2000, mathematically severing the\ncapability for String Exhaustion Attacks and Path Traversal vulnerabilities\nduring AST resolution.\n\nMCP ROUTING TRIGGERS: Category Theory, Covariant Functor, Scope Isolation,\nState Projection, Bijective Mapping"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"InputMappingContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes a covariant Functor (Category Theory) mapping\\nhigher-order topological state dimensions into an encapsulated subgraph's\\nlocalized working memory. As a ...Contract suffix, this enforces rigid\\nmathematical boundaries globally.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator's state projection engine to\\nsafely inject parent variables into a CompositeNodeProfile without violating\\nscope isolation or referential transparency.\\n\\nEPISTEMIC BOUNDS: The geometric projection vectors parent_key and child_key\\nare strictly clamped to max_length=2000, mathematically severing the\\ncapability for String Exhaustion Attacks and Path Traversal vulnerabilities\\nduring AST resolution.\\n\\nMCP ROUTING TRIGGERS: Category Theory, Covariant Functor, Scope Isolation,\\nState Projection, Bijective Mapping\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"child_key\","]
#[doc = "    \"parent_key\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"child_key\": {"]
#[doc = "      \"title\": \"Child Key\","]
#[doc = "      \"description\": \"The mapped key in the nested topology's state contract.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"parent_key\": {"]
#[doc = "      \"title\": \"Parent Key\","]
#[doc = "      \"description\": \"The key in the parent's shared state contract.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct InputMappingContract {
    #[doc = "The mapped key in the nested topology's state contract."]
    pub child_key: ChildKey,
    #[doc = "The key in the parent's shared state contract."]
    pub parent_key: ParentKey,
}
impl InputMappingContract {
    pub fn builder() -> builder::InputMappingContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative bounding box for rendering condensed semantic summaries (Information Bottleneck compression) into human-readable 2D space.\n\nCAUSAL AFFORDANCE: Projects Markdown-formatted text onto the UI plane while serving as a structural honeypot against Polyglot XSS and Markdown execution injection attacks.\n\nEPISTEMIC BOUNDS: Physically restricts payload size to `max_length=100000` on `markdown_content`. Two distinct `@field_validator` hooks mathematically strip HTML event handlers and malicious URI schemes, ensuring zero-trust projection.\n\nMCP ROUTING TRIGGERS: Information Bottleneck, Semantic Compression, XSS Sanitization, Markdown Projection, Zero-Trust UI"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"InsightCardProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative bounding box for rendering condensed semantic summaries (Information Bottleneck compression) into human-readable 2D space.\\n\\nCAUSAL AFFORDANCE: Projects Markdown-formatted text onto the UI plane while serving as a structural honeypot against Polyglot XSS and Markdown execution injection attacks.\\n\\nEPISTEMIC BOUNDS: Physically restricts payload size to `max_length=100000` on `markdown_content`. Two distinct `@field_validator` hooks mathematically strip HTML event handlers and malicious URI schemes, ensuring zero-trust projection.\\n\\nMCP ROUTING TRIGGERS: Information Bottleneck, Semantic Compression, XSS Sanitization, Markdown Projection, Zero-Trust UI\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"markdown_content\","]
#[doc = "    \"panel_cid\","]
#[doc = "    \"title\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"billboard_physics\": {"]
#[doc = "      \"description\": \"The kinematic constraint anchoring this 2D card to the 3D topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SpatialBillboardContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"markdown_content\": {"]
#[doc = "      \"title\": \"Markdown Content\","]
#[doc = "      \"description\": \"The markdown formatted text content.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000"]
#[doc = "    },"]
#[doc = "    \"panel_cid\": {"]
#[doc = "      \"title\": \"Panel Cid\","]
#[doc = "      \"description\": \"The unique identifier for this UI panel.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"title\": {"]
#[doc = "      \"title\": \"Title\","]
#[doc = "      \"description\": \"The declarative semantic anchor summarizing the underlying matrix or markdown projection.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for markdown insight cards.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"insight_card\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct InsightCardProfile {
    #[doc = "The kinematic constraint anchoring this 2D card to the 3D topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub billboard_physics: ::std::option::Option<SpatialBillboardContract>,
    #[doc = "The markdown formatted text content."]
    pub markdown_content: MarkdownContent,
    #[doc = "The unique identifier for this UI panel."]
    pub panel_cid: PanelCid,
    #[doc = "The declarative semantic anchor summarizing the underlying matrix or markdown projection."]
    pub title: Title,
    #[doc = "Discriminator for markdown insight cards."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl InsightCardProfile {
    pub fn builder() -> builder::InsightCardProfile {
        Default::default()
    }
}
#[doc = "UUIDv7 mapping to the ledger."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Intent Cid\","]
#[doc = "  \"description\": \"UUIDv7 mapping to the ledger.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct IntentCid(::std::string::String);
impl ::std::ops::Deref for IntentCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<IntentCid> for ::std::string::String {
    fn from(value: IntentCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for IntentCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for IntentCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for IntentCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for IntentCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for IntentCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the non-monotonic\ncollapse of a high-entropy human natural language string into a discrete, mathematically\nbounded routing heuristic. As a ...Receipt suffix, this is an append-only Merkle-DAG coordinate.\n\nCAUSAL AFFORDANCE: Commits the LLM's Softmax classification verdict to the Epistemic Ledger,\nauthorizing the TaxonomicRoutingPolicy or router gate to physically execute the targeted\ntopology or sub-agent.\n\nEPISTEMIC BOUNDS: The raw_input_string is physically clamped (max_length=100000) to prevent\ncontext window buffer overflows. The classification confidence is strictly bound to a\nnormalized float (ge=0.0, le=1.0).\n\nMCP ROUTING TRIGGERS: Intent Classification, Softmax Gating, High-Entropy Parsing,\nRouting Heuristic, Semantic Wave Collapse"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"IntentClassificationReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the non-monotonic\\ncollapse of a high-entropy human natural language string into a discrete, mathematically\\nbounded routing heuristic. As a ...Receipt suffix, this is an append-only Merkle-DAG coordinate.\\n\\nCAUSAL AFFORDANCE: Commits the LLM's Softmax classification verdict to the Epistemic Ledger,\\nauthorizing the TaxonomicRoutingPolicy or router gate to physically execute the targeted\\ntopology or sub-agent.\\n\\nEPISTEMIC BOUNDS: The raw_input_string is physically clamped (max_length=100000) to prevent\\ncontext window buffer overflows. The classification confidence is strictly bound to a\\nnormalized float (ge=0.0, le=1.0).\\n\\nMCP ROUTING TRIGGERS: Intent Classification, Softmax Gating, High-Entropy Parsing,\\nRouting Heuristic, Semantic Wave Collapse\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"classified_intent\","]
#[doc = "    \"confidence_score\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"raw_input_string\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"classified_intent\": {"]
#[doc = "      \"title\": \"Classified Intent\","]
#[doc = "      \"description\": \"The discrete, structurally bounded capability or heuristic mapped by the LLM.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255"]
#[doc = "    },"]
#[doc = "    \"confidence_score\": {"]
#[doc = "      \"title\": \"Confidence Score\","]
#[doc = "      \"description\": \"The probabilistic certainty of the classification.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"raw_input_string\": {"]
#[doc = "      \"title\": \"Raw Input String\","]
#[doc = "      \"description\": \"The raw, unparsed human natural language instruction.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000"]
#[doc = "    },"]
#[doc = "    \"routing_policy_cid\": {"]
#[doc = "      \"title\": \"Routing Policy Cid\","]
#[doc = "      \"description\": \"The TaxonomicRoutingPolicy CID that governed this classification.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for an intent classification receipt.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"intent_classification\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct IntentClassificationReceipt {
    #[doc = "The discrete, structurally bounded capability or heuristic mapped by the LLM."]
    pub classified_intent: ClassifiedIntent,
    #[doc = "The probabilistic certainty of the classification."]
    pub confidence_score: f64,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The raw, unparsed human natural language instruction."]
    pub raw_input_string: RawInputString,
    #[doc = "The TaxonomicRoutingPolicy CID that governed this classification."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub routing_policy_cid: ::std::option::Option<::std::string::String>,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "Discriminator type for an intent classification receipt."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl IntentClassificationReceipt {
    pub fn builder() -> builder::IntentClassificationReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Zero-Cost Macro-Topology that translates unstructured, high-entropy human multimodal input into a mathematically verified, zero-entropy HumanDirectiveIntent.\n\nCAUSAL AFFORDANCE: Unrolls a cyclic Directed Graph that orchestrates Multimodal Transmutation, Metacognitive Scanning (Shannon Entropy measurement), and Schema-on-Write Drafting (Human Interrogation) before yielding to the Agentic Forge.\n\nEPISTEMIC BOUNDS: The max_clarification_loops physical Halting Problem guillotine is mathematically clamped between 1 and 18446744073709551615. Physical execution safety is delegated to runtime Admission Controllers.\n\nMCP ROUTING TRIGGERS: Intent Elicitation, Zero-Entropy Distillation, Cyclical Routing, Human Interrogation, Multimodal Transmutation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"IntentElicitationTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Zero-Cost Macro-Topology that translates unstructured, high-entropy human multimodal input into a mathematically verified, zero-entropy HumanDirectiveIntent.\\n\\nCAUSAL AFFORDANCE: Unrolls a cyclic Directed Graph that orchestrates Multimodal Transmutation, Metacognitive Scanning (Shannon Entropy measurement), and Schema-on-Write Drafting (Human Interrogation) before yielding to the Agentic Forge.\\n\\nEPISTEMIC BOUNDS: The max_clarification_loops physical Halting Problem guillotine is mathematically clamped between 1 and 18446744073709551615. Physical execution safety is delegated to runtime Admission Controllers.\\n\\nMCP ROUTING TRIGGERS: Intent Elicitation, Zero-Entropy Distillation, Cyclical Routing, Human Interrogation, Multimodal Transmutation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"human_oracle_cid\","]
#[doc = "    \"nodes\","]
#[doc = "    \"raw_human_artifact_cid\","]
#[doc = "    \"scanner_node_cid\","]
#[doc = "    \"transmuter_node_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"epistemic_enforcement\": {"]
#[doc = "      \"description\": \"Ties the topology to the Truth Maintenance layer.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TruthMaintenancePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"human_oracle_cid\": {"]
#[doc = "      \"description\": \"The human UI node receiving the DraftingIntent.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this topology's configuration.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"lifecycle_phase\": {"]
#[doc = "      \"title\": \"Lifecycle Phase\","]
#[doc = "      \"description\": \"The execution phase of the graph. 'draft' allows incomplete structural state.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"draft\","]
#[doc = "        \"live\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_clarification_loops\": {"]
#[doc = "      \"title\": \"Max Clarification Loops\","]
#[doc = "      \"description\": \"A physical Halting Problem guillotine preventing infinite clarification loops.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"nodes\": {"]
#[doc = "      \"title\": \"Nodes\","]
#[doc = "      \"description\": \"Flat registry of all nodes in this topology.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyNodeProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"observability\": {"]
#[doc = "      \"description\": \"The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ObservabilityLODPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"raw_human_artifact_cid\": {"]
#[doc = "      \"title\": \"Raw Human Artifact Cid\","]
#[doc = "      \"description\": \"The anchor to the initial, unstructured MultimodalArtifactReceipt uploaded by the human.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"scanner_node_cid\": {"]
#[doc = "      \"description\": \"The agent node actively running the EpistemicScanningPolicy.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"semantic_flow\": {"]
#[doc = "      \"description\": \"The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticFlowPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"shared_state_contract\": {"]
#[doc = "      \"description\": \"The schema-on-write contract governing the internal state of this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StateContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for the elicitation macro.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"macro_elicitation\""]
#[doc = "    },"]
#[doc = "    \"transmuter_node_cid\": {"]
#[doc = "      \"description\": \"The system node responsible for executing the EpistemicTransmutationTask.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct IntentElicitationTopologyManifest {
    #[doc = "The AI's declarative rationale for selecting this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "Ties the topology to the Truth Maintenance layer."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_enforcement: ::std::option::Option<TruthMaintenancePolicy>,
    #[doc = "The human UI node receiving the DraftingIntent."]
    pub human_oracle_cid: NodeCidState,
    #[doc = "Cryptographic/audit justification for this topology's configuration."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The execution phase of the graph. 'draft' allows incomplete structural state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub lifecycle_phase: ::std::option::Option<LifecyclePhase>,
    #[doc = "A physical Halting Problem guillotine preventing infinite clarification loops."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_clarification_loops: ::std::option::Option<::std::num::NonZeroU64>,
    #[doc = "Flat registry of all nodes in this topology."]
    pub nodes: ::std::collections::HashMap<::std::string::String, AnyNodeProfile>,
    #[doc = "The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub observability: ::std::option::Option<ObservabilityLodPolicy>,
    #[doc = "The anchor to the initial, unstructured MultimodalArtifactReceipt uploaded by the human."]
    pub raw_human_artifact_cid: RawHumanArtifactCid,
    #[doc = "The agent node actively running the EpistemicScanningPolicy."]
    pub scanner_node_cid: NodeCidState,
    #[doc = "The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_flow: ::std::option::Option<SemanticFlowPolicy>,
    #[doc = "The schema-on-write contract governing the internal state of this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub shared_state_contract: ::std::option::Option<StateContract>,
    #[doc = "Discriminator for the elicitation macro."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The system node responsible for executing the EpistemicTransmutationTask."]
    pub transmuter_node_cid: NodeCidState,
}
impl IntentElicitationTopologyManifest {
    pub fn builder() -> builder::IntentElicitationTopologyManifest {
        Default::default()
    }
}
#[doc = "Pointer to the originating EpistemicZeroTrustContract."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Intent Reference Cid\","]
#[doc = "  \"description\": \"Pointer to the originating EpistemicZeroTrustContract.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct IntentReferenceCid(::std::string::String);
impl ::std::ops::Deref for IntentReferenceCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<IntentReferenceCid> for ::std::string::String {
    fn from(value: IntentReferenceCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for IntentReferenceCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for IntentReferenceCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for IntentReferenceCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for IntentReferenceCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for IntentReferenceCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The exact topological action the human operator performed on the projected manifold."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Interaction Modality\","]
#[doc = "  \"description\": \"The exact topological action the human operator performed on the projected manifold.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"expansion\","]
#[doc = "    \"collapse\","]
#[doc = "    \"dwell_focus\","]
#[doc = "    \"heuristic_rejection\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum InteractionModality {
    #[serde(rename = "expansion")]
    Expansion,
    #[serde(rename = "collapse")]
    Collapse,
    #[serde(rename = "dwell_focus")]
    DwellFocus,
    #[serde(rename = "heuristic_rejection")]
    HeuristicRejection,
}
impl ::std::fmt::Display for InteractionModality {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Expansion => f.write_str("expansion"),
            Self::Collapse => f.write_str("collapse"),
            Self::DwellFocus => f.write_str("dwell_focus"),
            Self::HeuristicRejection => f.write_str("heuristic_rejection"),
        }
    }
}
impl ::std::str::FromStr for InteractionModality {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "expansion" => Ok(Self::Expansion),
            "collapse" => Ok(Self::Collapse),
            "dwell_focus" => Ok(Self::DwellFocus),
            "heuristic_rejection" => Ok(Self::HeuristicRejection),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for InteractionModality {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for InteractionModality {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for InteractionModality {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Supervisory Control Theory (Ramadge & Wonham) for Discrete-Event Systems, acting as a formal Mixed-Initiative Control mechanism.\n\nCAUSAL AFFORDANCE: Physically halts the active Directed Acyclic Graph (DAG) traversal or Petri Net reachability loop, preventing the swarm from committing a state transition until an explicit, authorized Pearlian intervention is negotiated by the human supervisor.\n\nEPISTEMIC BOUNDS: Execution suspension is rigorously bounded by the temporal logic of the `adjudication_deadline` (a float representing a UNIX timestamp) and the attached FallbackSLA. The `proposed_action` schema is clamped against deep recursion constraints.\n\nMCP ROUTING TRIGGERS: Supervisory Control Theory, Mixed-Initiative System, Discrete-Event System, Bounded Delay, Pearlian Intervention"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"InterventionIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Supervisory Control Theory (Ramadge & Wonham) for Discrete-Event Systems, acting as a formal Mixed-Initiative Control mechanism.\\n\\nCAUSAL AFFORDANCE: Physically halts the active Directed Acyclic Graph (DAG) traversal or Petri Net reachability loop, preventing the swarm from committing a state transition until an explicit, authorized Pearlian intervention is negotiated by the human supervisor.\\n\\nEPISTEMIC BOUNDS: Execution suspension is rigorously bounded by the temporal logic of the `adjudication_deadline` (a float representing a UNIX timestamp) and the attached FallbackSLA. The `proposed_action` schema is clamped against deep recursion constraints.\\n\\nMCP ROUTING TRIGGERS: Supervisory Control Theory, Mixed-Initiative System, Discrete-Event System, Bounded Delay, Pearlian Intervention\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"adjudication_deadline\","]
#[doc = "    \"context_summary\","]
#[doc = "    \"proposed_action\","]
#[doc = "    \"target_node_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"adjudication_deadline\": {"]
#[doc = "      \"title\": \"Adjudication Deadline\","]
#[doc = "      \"description\": \"The deadline for adjudication, represented as a UNIX timestamp.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"context_summary\": {"]
#[doc = "      \"title\": \"Context Summary\","]
#[doc = "      \"description\": \"A summary of the context requiring intervention.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"failure_context\": {"]
#[doc = "      \"description\": \"Packages the exact contextual state at the moment of computational failure.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TerminalCognitiveEvent\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"fallback_sla\": {"]
#[doc = "      \"description\": \"The SLA constraints on the intervention delay.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/FallbackSLA\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"intervention_scope\": {"]
#[doc = "      \"description\": \"The scope constraints bounding the intervention.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/BoundedInterventionScopePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"proposed_action\": {"]
#[doc = "      \"title\": \"Proposed Action\","]
#[doc = "      \"description\": \"The action proposed by the agent that requires approval.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"description\": \"The deterministic capability pointer representing the target node.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The type of the intervention payload.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"request\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct InterventionIntent {
    #[doc = "The deadline for adjudication, represented as a UNIX timestamp."]
    pub adjudication_deadline: f64,
    #[doc = "A summary of the context requiring intervention."]
    pub context_summary: ContextSummary,
    #[doc = "Packages the exact contextual state at the moment of computational failure."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub failure_context: ::std::option::Option<TerminalCognitiveEvent>,
    #[doc = "The SLA constraints on the intervention delay."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub fallback_sla: ::std::option::Option<FallbackSla>,
    #[doc = "The scope constraints bounding the intervention."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub intervention_scope: ::std::option::Option<BoundedInterventionScopePolicy>,
    #[doc = "The action proposed by the agent that requires approval."]
    pub proposed_action: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "The deterministic capability pointer representing the target node."]
    pub target_node_cid: NodeCidState,
    #[doc = "The type of the intervention payload."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl InterventionIntent {
    pub fn builder() -> builder::InterventionIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Executes Supervisory Control Theory by embedding\ndeterministic execution hooks (transitions) into the swarm's Petri Net\nlifecycle graph. As a ...Policy suffix, this defines rigid mathematical\nboundaries.\n\nCAUSAL AFFORDANCE: Physically halts the autonomous execution loop (if blocking\nis True, default=True) at the exact topological trigger coordinate\n(LifecycleTriggerEvent), forcing the orchestrator to await an external\nInterventionReceipt before proceeding.\n\nEPISTEMIC BOUNDS: The interruption locus is rigidly confined to the\nLifecycleTriggerEvent literal automaton. The structural mutation permissions\nduring the pause are strictly governed by the optional scope\n(BoundedInterventionScopePolicy | None, default=None).\n\nMCP ROUTING TRIGGERS: Supervisory Control Theory, Petri Net Transition,\nLifecycle Hook, Execution Halting, Mixed-Initiative Interaction"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"InterventionPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Executes Supervisory Control Theory by embedding\\ndeterministic execution hooks (transitions) into the swarm's Petri Net\\nlifecycle graph. As a ...Policy suffix, this defines rigid mathematical\\nboundaries.\\n\\nCAUSAL AFFORDANCE: Physically halts the autonomous execution loop (if blocking\\nis True, default=True) at the exact topological trigger coordinate\\n(LifecycleTriggerEvent), forcing the orchestrator to await an external\\nInterventionReceipt before proceeding.\\n\\nEPISTEMIC BOUNDS: The interruption locus is rigidly confined to the\\nLifecycleTriggerEvent literal automaton. The structural mutation permissions\\nduring the pause are strictly governed by the optional scope\\n(BoundedInterventionScopePolicy | None, default=None).\\n\\nMCP ROUTING TRIGGERS: Supervisory Control Theory, Petri Net Transition,\\nLifecycle Hook, Execution Halting, Mixed-Initiative Interaction\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"trigger\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"async_observation_port\": {"]
#[doc = "      \"title\": \"Async Observation Port\","]
#[doc = "      \"description\": \"The endpoint for emitting non-blocking shadow telemetry.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\","]
#[doc = "          \"format\": \"uri\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"blocking\": {"]
#[doc = "      \"title\": \"Blocking\","]
#[doc = "      \"description\": \"If True, the graph execution halts until a verdict is rendered. If False, it is an async observation.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"emit_telemetry_on_revision\": {"]
#[doc = "      \"title\": \"Emit Telemetry On Revision\","]
#[doc = "      \"description\": \"The toggle to enable shadow monitoring on revision loops.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"scope\": {"]
#[doc = "      \"description\": \"The strictly typed boundaries for what the human/oversight system is allowed to mutate during this pause.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/BoundedInterventionScopePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"trigger\": {"]
#[doc = "      \"description\": \"The exact topological lifecycle event that triggers this intervention.\","]
#[doc = "      \"$ref\": \"#/$defs/LifecycleTriggerEvent\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct InterventionPolicy {
    #[doc = "The endpoint for emitting non-blocking shadow telemetry."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub async_observation_port: ::std::option::Option<::std::string::String>,
    #[doc = "If True, the graph execution halts until a verdict is rendered. If False, it is an async observation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub blocking: ::std::option::Option<bool>,
    #[doc = "The toggle to enable shadow monitoring on revision loops."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub emit_telemetry_on_revision: ::std::option::Option<bool>,
    #[doc = "The strictly typed boundaries for what the human/oversight system is allowed to mutate during this pause."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub scope: ::std::option::Option<BoundedInterventionScopePolicy>,
    #[doc = "The exact topological lifecycle event that triggers this intervention."]
    pub trigger: LifecycleTriggerEvent,
}
impl InterventionPolicy {
    pub fn builder() -> builder::InterventionPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: InterventionReceipt is a cryptographically frozen historical fact representing\nthe resolution of a Mixed-Initiative pause. It acts as the mathematical key that unlocks a suspended\nstate partition.\n\nCAUSAL AFFORDANCE: Collapses the halted superposition of the DAG, physically re-activating the\nexecution thread and authorizing the orchestrator to commit the human-approved state mutation to\nthe Epistemic Ledger.\n\nEPISTEMIC BOUNDS: Mathematically locked against Replay Attacks via the intervention_request_cid\n(a UUID cryptographic nonce). The @model_validator physically guarantees that if a WetwareAttestationContract\nis present, its internal DAG node nonce must perfectly match the request ID, preventing signature laundering,\nand mathematically linking the human's signature to the liveness_challenge_hash challenge.\n\nMCP ROUTING TRIGGERS: Cryptographic Nonce, State Resumption, Replay Attack Prevention, Wetware Attestation, Liveness Resolution"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"InterventionReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: InterventionReceipt is a cryptographically frozen historical fact representing\\nthe resolution of a Mixed-Initiative pause. It acts as the mathematical key that unlocks a suspended\\nstate partition.\\n\\nCAUSAL AFFORDANCE: Collapses the halted superposition of the DAG, physically re-activating the\\nexecution thread and authorizing the orchestrator to commit the human-approved state mutation to\\nthe Epistemic Ledger.\\n\\nEPISTEMIC BOUNDS: Mathematically locked against Replay Attacks via the intervention_request_cid\\n(a UUID cryptographic nonce). The @model_validator physically guarantees that if a WetwareAttestationContract\\nis present, its internal DAG node nonce must perfectly match the request ID, preventing signature laundering,\\nand mathematically linking the human's signature to the liveness_challenge_hash challenge.\\n\\nMCP ROUTING TRIGGERS: Cryptographic Nonce, State Resumption, Replay Attack Prevention, Wetware Attestation, Liveness Resolution\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"approved\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"feedback\","]
#[doc = "    \"intervention_request_cid\","]
#[doc = "    \"target_node_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"approved\": {"]
#[doc = "      \"title\": \"Approved\","]
#[doc = "      \"description\": \"Indicates whether the proposed action was approved.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"attestation\": {"]
#[doc = "      \"description\": \"The cryptographic proof provided by the human operator, if required.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/WetwareAttestationContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"feedback\": {"]
#[doc = "      \"title\": \"Feedback\","]
#[doc = "      \"description\": \"Optional feedback provided along with the verdict.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"intervention_request_cid\": {"]
#[doc = "      \"title\": \"Intervention Request Cid\","]
#[doc = "      \"description\": \"The cryptographic nonce uniquely identifying the intervention request.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"description\": \"The deterministic capability pointer representing the target node.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The type of the intervention payload.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"verdict\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct InterventionReceipt {
    #[doc = "Indicates whether the proposed action was approved."]
    pub approved: bool,
    #[doc = "The cryptographic proof provided by the human operator, if required."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub attestation: ::std::option::Option<WetwareAttestationContract>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "Optional feedback provided along with the verdict."]
    pub feedback: ::std::option::Option<::std::string::String>,
    #[doc = "The cryptographic nonce uniquely identifying the intervention request."]
    pub intervention_request_cid: InterventionRequestCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The deterministic capability pointer representing the target node."]
    pub target_node_cid: NodeCidState,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "The type of the intervention payload."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl InterventionReceipt {
    pub fn builder() -> builder::InterventionReceipt {
        Default::default()
    }
}
#[doc = "The cryptographic nonce uniquely identifying the intervention request."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Intervention Request Cid\","]
#[doc = "  \"description\": \"The cryptographic nonce uniquely identifying the intervention request.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct InterventionRequestCid(::std::string::String);
impl ::std::ops::Deref for InterventionRequestCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<InterventionRequestCid> for ::std::string::String {
    fn from(value: InterventionRequestCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for InterventionRequestCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for InterventionRequestCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for InterventionRequestCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for InterventionRequestCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for InterventionRequestCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The specific node $X$ in the SCM the agent is forcing to a specific state."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Intervention Variable\","]
#[doc = "  \"description\": \"The specific node $X$ in the SCM the agent is forcing to a specific state.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct InterventionVariable(::std::string::String);
impl ::std::ops::Deref for InterventionVariable {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<InterventionVariable> for ::std::string::String {
    fn from(value: InterventionVariable) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for InterventionVariable {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for InterventionVariable {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for InterventionVariable {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for InterventionVariable {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for InterventionVariable {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"InterventionalCausalTask\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"do_operator_state\","]
#[doc = "    \"execution_cost_budget_magnitude\","]
#[doc = "    \"expected_causal_information_gain\","]
#[doc = "    \"intervention_variable\","]
#[doc = "    \"target_hypothesis_cid\","]
#[doc = "    \"task_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"do_operator_state\": {"]
#[doc = "      \"title\": \"Do Operator State\","]
#[doc = "      \"description\": \"The exact value or condition forced upon the intervention_variable, isolating it from its historical causes.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"execution_cost_budget_magnitude\": {"]
#[doc = "      \"title\": \"Execution Cost Budget Magnitude\","]
#[doc = "      \"description\": \"The maximum economic expenditure authorized to run this specific causal intervention.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"expected_causal_information_gain\": {"]
#[doc = "      \"title\": \"Expected Causal Information Gain\","]
#[doc = "      \"description\": \"The mathematical proof of entropy reduction yielded specifically by breaking the confounding back-doors.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"intervention_variable\": {"]
#[doc = "      \"title\": \"Intervention Variable\","]
#[doc = "      \"description\": \"The specific node $X$ in the SCM the agent is forcing to a specific state.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"target_hypothesis_cid\": {"]
#[doc = "      \"title\": \"Target Hypothesis Cid\","]
#[doc = "      \"description\": \"The hypothesis containing the SCM being tested.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"task_cid\": {"]
#[doc = "      \"title\": \"Task Cid\","]
#[doc = "      \"description\": \"Unique identifier for this causal intervention.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"interventional_causal_task\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct InterventionalCausalTask {
    #[doc = "The exact value or condition forced upon the intervention_variable, isolating it from its historical causes."]
    pub do_operator_state: DoOperatorState,
    #[doc = "The maximum economic expenditure authorized to run this specific causal intervention."]
    pub execution_cost_budget_magnitude: u64,
    #[doc = "The mathematical proof of entropy reduction yielded specifically by breaking the confounding back-doors."]
    pub expected_causal_information_gain: f64,
    #[doc = "The specific node $X$ in the SCM the agent is forcing to a specific state."]
    pub intervention_variable: InterventionVariable,
    #[doc = "The hypothesis containing the SCM being tested."]
    pub target_hypothesis_cid: TargetHypothesisCid,
    #[doc = "Unique identifier for this causal intervention."]
    pub task_cid: TaskCid,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl InterventionalCausalTask {
    pub fn builder() -> builder::InterventionalCausalTask {
        Default::default()
    }
}
#[doc = "`InvalidatedNodeCidsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct InvalidatedNodeCidsItem(::std::string::String);
impl ::std::ops::Deref for InvalidatedNodeCidsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<InvalidatedNodeCidsItem> for ::std::string::String {
    fn from(value: InvalidatedNodeCidsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for InvalidatedNodeCidsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for InvalidatedNodeCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for InvalidatedNodeCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for InvalidatedNodeCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for InvalidatedNodeCidsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The cryptographic Merkle-DAG anchor for the invariant block."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Invariant Cid\","]
#[doc = "  \"description\": \"The cryptographic Merkle-DAG anchor for the invariant block.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct InvariantCid(::std::string::String);
impl ::std::ops::Deref for InvariantCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<InvariantCid> for ::std::string::String {
    fn from(value: InvariantCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for InvariantCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for InvariantCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for InvariantCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for InvariantCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for InvariantCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The exact mathematical assertion or safety invariant being proven (e.g., 'No data classified as CONFIDENTIAL routes externally')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Invariant Theorem\","]
#[doc = "  \"description\": \"The exact mathematical assertion or safety invariant being proven (e.g., 'No data classified as CONFIDENTIAL routes externally').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct InvariantTheorem(::std::string::String);
impl ::std::ops::Deref for InvariantTheorem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<InvariantTheorem> for ::std::string::String {
    fn from(value: InvariantTheorem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for InvariantTheorem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for InvariantTheorem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for InvariantTheorem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for InvariantTheorem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for InvariantTheorem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`IsomorphismHash`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Isomorphism Hash\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct IsomorphismHash(::std::string::String);
impl ::std::ops::Deref for IsomorphismHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<IsomorphismHash> for ::std::string::String {
    fn from(value: IsomorphismHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for IsomorphismHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for IsomorphismHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for IsomorphismHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for IsomorphismHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for IsomorphismHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The URI or hash pointing to the exact math circuit or polynomial function the ring will collaboratively compute."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Joint Function Uri\","]
#[doc = "  \"description\": \"The URI or hash pointing to the exact math circuit or polynomial function the ring will collaboratively compute.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct JointFunctionUri(::std::string::String);
impl ::std::ops::Deref for JointFunctionUri {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<JointFunctionUri> for ::std::string::String {
    fn from(value: JointFunctionUri) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for JointFunctionUri {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for JointFunctionUri {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for JointFunctionUri {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for JointFunctionUri {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for JointFunctionUri {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`JsonPrimitiveState`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"anyOf\": ["]
#[doc = "    {"]
#[doc = "      \"type\": \"string\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"integer\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"number\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/EpistemicProxyState_Any_\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"null\""]
#[doc = "    }"]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
pub struct JsonPrimitiveState {
    #[serde(
        flatten,
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub subtype_0: ::std::option::Option<::std::string::String>,
    #[serde(
        flatten,
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub subtype_1: ::std::option::Option<i64>,
    #[serde(
        flatten,
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub subtype_2: ::std::option::Option<f64>,
    #[serde(
        flatten,
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub subtype_3: ::std::option::Option<bool>,
    #[serde(
        flatten,
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub subtype_4: ::std::option::Option<::std::vec::Vec<JsonPrimitiveState>>,
    #[serde(
        flatten,
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub subtype_5: ::std::option::Option<
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    >,
    #[serde(
        flatten,
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub subtype_6: ::std::option::Option<EpistemicProxyStateAny>,
    #[serde(
        flatten,
        default,
        skip_serializing_if = "::std::option::Option::is_none"
    )]
    pub subtype_7: ::std::option::Option<()>,
}
impl ::std::default::Default for JsonPrimitiveState {
    fn default() -> Self {
        Self {
            subtype_0: Default::default(),
            subtype_1: Default::default(),
            subtype_2: Default::default(),
            subtype_3: Default::default(),
            subtype_4: Default::default(),
            subtype_5: Default::default(),
            subtype_6: Default::default(),
            subtype_7: Default::default(),
        }
    }
}
impl JsonPrimitiveState {
    pub fn builder() -> builder::JsonPrimitiveState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: The definitive top-level envelope for transmitting a\nJSONRPCErrorState across a Zero-Trust Architecture boundary. As a ...State suffix,\nthis is a frozen N-dimensional coordinate.\n\nCAUSAL AFFORDANCE: Concludes a failed Distributed RPC call via the error\n(JSONRPCErrorState) typed reference, forcing the orchestrator to sever the current\nexecution tree and apply necessary truth maintenance.\n\nEPISTEMIC BOUNDS: The jsonrpc field is a rigid Literal[\"2.0\"] automaton. The id is\ntopologically locked to a 128-char CID regex or an integer (le=18446744073709551615) or None.\n\nMCP ROUTING TRIGGERS: Zero-Trust Architecture, Distributed RPC, Execution Severing,\nTruth Maintenance, Fault Envelope"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"JSONRPCErrorResponseState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: The definitive top-level envelope for transmitting a\\nJSONRPCErrorState across a Zero-Trust Architecture boundary. As a ...State suffix,\\nthis is a frozen N-dimensional coordinate.\\n\\nCAUSAL AFFORDANCE: Concludes a failed Distributed RPC call via the error\\n(JSONRPCErrorState) typed reference, forcing the orchestrator to sever the current\\nexecution tree and apply necessary truth maintenance.\\n\\nEPISTEMIC BOUNDS: The jsonrpc field is a rigid Literal[\\\"2.0\\\"] automaton. The id is\\ntopologically locked to a 128-char CID regex or an integer (le=18446744073709551615) or None.\\n\\nMCP ROUTING TRIGGERS: Zero-Trust Architecture, Distributed RPC, Execution Severing,\\nTruth Maintenance, Fault Envelope\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"error\","]
#[doc = "    \"jsonrpc\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"error\": {"]
#[doc = "      \"description\": \"The error object.\","]
#[doc = "      \"$ref\": \"#/$defs/JSONRPCErrorState\""]
#[doc = "    },"]
#[doc = "    \"id\": {"]
#[doc = "      \"title\": \"Id\","]
#[doc = "      \"description\": \"The request ID that this error corresponds to.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"anyOf\": ["]
#[doc = "            {"]
#[doc = "              \"type\": \"string\","]
#[doc = "              \"maxLength\": 128,"]
#[doc = "              \"minLength\": 1,"]
#[doc = "              \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"integer\""]
#[doc = "            }"]
#[doc = "          ],"]
#[doc = "          \"le\": 18446744073709551615"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"jsonrpc\": {"]
#[doc = "      \"title\": \"Jsonrpc\","]
#[doc = "      \"description\": \"JSON-RPC version.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"2.0\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct JsonrpcErrorResponseState {
    #[doc = "The error object."]
    pub error: JsonrpcErrorState,
    #[doc = "The request ID that this error corresponds to."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub id: ::std::option::Option<JsonrpcErrorResponseStateId>,
    #[doc = "JSON-RPC version."]
    pub jsonrpc: ::std::string::String,
}
impl JsonrpcErrorResponseState {
    pub fn builder() -> builder::JsonrpcErrorResponseState {
        Default::default()
    }
}
#[doc = "`JsonrpcErrorResponseStateId`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"anyOf\": ["]
#[doc = "    {"]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"integer\""]
#[doc = "    }"]
#[doc = "  ],"]
#[doc = "  \"le\": 18446744073709551615"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum JsonrpcErrorResponseStateId {
    String(JsonrpcErrorResponseStateIdString),
    Integer(i64),
}
impl ::std::str::FromStr for JsonrpcErrorResponseStateId {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if let Ok(v) = value.parse() {
            Ok(Self::String(v))
        } else if let Ok(v) = value.parse() {
            Ok(Self::Integer(v))
        } else {
            Err("string conversion failed for all variants".into())
        }
    }
}
impl ::std::convert::TryFrom<&str> for JsonrpcErrorResponseStateId {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for JsonrpcErrorResponseStateId {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for JsonrpcErrorResponseStateId {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::fmt::Display for JsonrpcErrorResponseStateId {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match self {
            Self::String(x) => x.fmt(f),
            Self::Integer(x) => x.fmt(f),
        }
    }
}
impl ::std::convert::From<JsonrpcErrorResponseStateIdString> for JsonrpcErrorResponseStateId {
    fn from(value: JsonrpcErrorResponseStateIdString) -> Self {
        Self::String(value)
    }
}
impl ::std::convert::From<i64> for JsonrpcErrorResponseStateId {
    fn from(value: i64) -> Self {
        Self::Integer(value)
    }
}
#[doc = "`JsonrpcErrorResponseStateIdString`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct JsonrpcErrorResponseStateIdString(::std::string::String);
impl ::std::ops::Deref for JsonrpcErrorResponseStateIdString {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<JsonrpcErrorResponseStateIdString> for ::std::string::String {
    fn from(value: JsonrpcErrorResponseStateIdString) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for JsonrpcErrorResponseStateIdString {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for JsonrpcErrorResponseStateIdString {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for JsonrpcErrorResponseStateIdString {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for JsonrpcErrorResponseStateIdString {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for JsonrpcErrorResponseStateIdString {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A mathematically constrained error vector reflecting execution\ncollapse within the JSON-RPC 2.0 specification. As a ...State suffix, this is a\nfrozen N-dimensional coordinate.\n\nCAUSAL AFFORDANCE: Projects execution faults back across the network boundary\nwithout risking secondary buffer overflow attacks during serialization. The\nerror_payload (alias=\"data\") carries optional structured diagnostic data.\n\nEPISTEMIC BOUNDS: The `error_payload` is strictly routed through the volumetric\nhardware guillotine (`enforce_payload_topology`) to mathematically prevent infinite\nrecursive depth from triggering C-stack overflows during fault serialization. The\ncode integer is rigidly capped (le=18446744073709551615) and the semantic message is restricted\nto max_length=2000.\n\nMCP ROUTING TRIGGERS: Fault Projection, Buffer Overflow Prevention, Error Vector,\nLog Poisoning, Stateful Rollback"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"JSONRPCErrorState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A mathematically constrained error vector reflecting execution\\ncollapse within the JSON-RPC 2.0 specification. As a ...State suffix, this is a\\nfrozen N-dimensional coordinate.\\n\\nCAUSAL AFFORDANCE: Projects execution faults back across the network boundary\\nwithout risking secondary buffer overflow attacks during serialization. The\\nerror_payload (alias=\\\"data\\\") carries optional structured diagnostic data.\\n\\nEPISTEMIC BOUNDS: The `error_payload` is strictly routed through the volumetric\\nhardware guillotine (`enforce_payload_topology`) to mathematically prevent infinite\\nrecursive depth from triggering C-stack overflows during fault serialization. The\\ncode integer is rigidly capped (le=18446744073709551615) and the semantic message is restricted\\nto max_length=2000.\\n\\nMCP ROUTING TRIGGERS: Fault Projection, Buffer Overflow Prevention, Error Vector,\\nLog Poisoning, Stateful Rollback\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"code\","]
#[doc = "    \"message\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"code\": {"]
#[doc = "      \"title\": \"Code\","]
#[doc = "      \"description\": \"The strict integer identifier classifying the specific topological or execution collapse.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"data\": {"]
#[doc = "      \"description\": \"A Primitive or Structured value that contains additional information about the error. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"message\": {"]
#[doc = "      \"title\": \"Message\","]
#[doc = "      \"description\": \"The strict semantic fault boundary explaining the structural or execution collapse.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct JsonrpcErrorState {
    #[doc = "The strict integer identifier classifying the specific topological or execution collapse."]
    pub code: u64,
    #[doc = "A Primitive or Structured value that contains additional information about the error. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub data: ::std::option::Option<JsonPrimitiveState>,
    #[doc = "The strict semantic fault boundary explaining the structural or execution collapse."]
    pub message: Message,
}
impl JsonrpcErrorState {
    pub fn builder() -> builder::JsonrpcErrorState {
        Default::default()
    }
}
#[doc = "The deterministic reason the orchestrator severed this execution branch."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Justification\","]
#[doc = "  \"description\": \"The deterministic reason the orchestrator severed this execution branch.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"modality_mismatch\","]
#[doc = "    \"budget_exhaustion\","]
#[doc = "    \"sla_timeout\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum Justification {
    #[serde(rename = "modality_mismatch")]
    ModalityMismatch,
    #[serde(rename = "budget_exhaustion")]
    BudgetExhaustion,
    #[serde(rename = "sla_timeout")]
    SlaTimeout,
}
impl ::std::fmt::Display for Justification {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::ModalityMismatch => f.write_str("modality_mismatch"),
            Self::BudgetExhaustion => f.write_str("budget_exhaustion"),
            Self::SlaTimeout => f.write_str("sla_timeout"),
        }
    }
}
impl ::std::str::FromStr for Justification {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "modality_mismatch" => Ok(Self::ModalityMismatch),
            "budget_exhaustion" => Ok(Self::BudgetExhaustion),
            "sla_timeout" => Ok(Self::SlaTimeout),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for Justification {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Justification {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Justification {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`JustificationVectorsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct JustificationVectorsItem(::std::string::String);
impl ::std::ops::Deref for JustificationVectorsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<JustificationVectorsItem> for ::std::string::String {
    fn from(value: JustificationVectorsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for JustificationVectorsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for JustificationVectorsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for JustificationVectorsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for JustificationVectorsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for JustificationVectorsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes a zero-allocation, high-velocity telemetry manifold designed exclusively for continuous thermodynamic state updates across the Markov Blanket.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator to transmit continuous SE(3) coordinates and optic states as flattened contiguous memory blocks (Struct of Arrays), mechanically bypassing recursive Garbage Collection (GC) pauses in external clients.\n\nEPISTEMIC BOUNDS: The state differential is mathematically restricted to a strict 16-element tuple mapping (position, rotation, scale, opacity, velocity). The `deltas` array is deterministically sorted by `node_cid` to preserve RFC 8785 canonical hashing.\n\nMCP ROUTING TRIGGERS: Zero-Allocation Telemetry, Struct of Arrays, High-Velocity Buffer, SE3 Delta, Kinematic Stream"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"KinematicDeltaManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes a zero-allocation, high-velocity telemetry manifold designed exclusively for continuous thermodynamic state updates across the Markov Blanket.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator to transmit continuous SE(3) coordinates and optic states as flattened contiguous memory blocks (Struct of Arrays), mechanically bypassing recursive Garbage Collection (GC) pauses in external clients.\\n\\nEPISTEMIC BOUNDS: The state differential is mathematically restricted to a strict 16-element tuple mapping (position, rotation, scale, opacity, velocity). The `deltas` array is deterministically sorted by `node_cid` to preserve RFC 8785 canonical hashing.\\n\\nMCP ROUTING TRIGGERS: Zero-Allocation Telemetry, Struct of Arrays, High-Velocity Buffer, SE3 Delta, Kinematic Stream\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"deltas\","]
#[doc = "    \"stream_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"deltas\": {"]
#[doc = "      \"title\": \"Deltas\","]
#[doc = "      \"description\": \"The strictly typed contiguous memory block of 16-element kinematic tuples, embedding first-order temporal derivatives for continuous Hermite Spline interpolation.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"array\","]
#[doc = "        \"maxItems\": 16,"]
#[doc = "        \"minItems\": 16,"]
#[doc = "        \"prefixItems\": ["]
#[doc = "          {"]
#[doc = "            \"maxLength\": 128,"]
#[doc = "            \"type\": \"string\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          },"]
#[doc = "          {"]
#[doc = "            \"type\": \"number\""]
#[doc = "          }"]
#[doc = "        ]"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"stream_cid\": {"]
#[doc = "      \"title\": \"Stream Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) anchoring the continuous telemetry stream.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct KinematicDeltaManifest {
    #[doc = "The strictly typed contiguous memory block of 16-element kinematic tuples, embedding first-order temporal derivatives for continuous Hermite Spline interpolation."]
    pub deltas: ::std::vec::Vec<[::serde_json::Value; 16usize]>,
    #[doc = "A Content Identifier (CID) anchoring the continuous telemetry stream."]
    pub stream_cid: StreamCid,
}
impl KinematicDeltaManifest {
    pub fn builder() -> builder::KinematicDeltaManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements continuous Newtonian Mechanics by defining first and second order derivatives (velocity and acceleration) for both linear and angular motion.\n\nCAUSAL AFFORDANCE: Instructs the spatial rendering engine to extrapolate future positions and rotations using Hermite Spline Extrapolation for continuous collision detection and smooth kinematics.\n\nEPISTEMIC BOUNDS: The physics are defined via `linear_velocity`, `angular_velocity`, `linear_acceleration`, and `angular_acceleration` arrays. These utilize a Topological Exemption preventing array sorting to mathematically preserve Euclidean vectors.\n\nMCP ROUTING TRIGGERS: Kinematic Derivatives, Hermite Spline Extrapolation, Continuous Collision Detection, Newtonian Mechanics"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"KinematicDerivativeProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements continuous Newtonian Mechanics by defining first and second order derivatives (velocity and acceleration) for both linear and angular motion.\\n\\nCAUSAL AFFORDANCE: Instructs the spatial rendering engine to extrapolate future positions and rotations using Hermite Spline Extrapolation for continuous collision detection and smooth kinematics.\\n\\nEPISTEMIC BOUNDS: The physics are defined via `linear_velocity`, `angular_velocity`, `linear_acceleration`, and `angular_acceleration` arrays. These utilize a Topological Exemption preventing array sorting to mathematically preserve Euclidean vectors.\\n\\nMCP ROUTING TRIGGERS: Kinematic Derivatives, Hermite Spline Extrapolation, Continuous Collision Detection, Newtonian Mechanics\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"angular_acceleration\","]
#[doc = "    \"angular_velocity\","]
#[doc = "    \"linear_acceleration\","]
#[doc = "    \"linear_velocity\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"angular_acceleration\": {"]
#[doc = "      \"title\": \"Angular Acceleration\","]
#[doc = "      \"description\": \"The 3D rotational acceleration vector.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"maxItems\": 3,"]
#[doc = "      \"minItems\": 3,"]
#[doc = "      \"coreason_topological_exemption\": true,"]
#[doc = "      \"prefixItems\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"angular_velocity\": {"]
#[doc = "      \"title\": \"Angular Velocity\","]
#[doc = "      \"description\": \"The 3D rotational velocity vector.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"maxItems\": 3,"]
#[doc = "      \"minItems\": 3,"]
#[doc = "      \"coreason_topological_exemption\": true,"]
#[doc = "      \"prefixItems\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"linear_acceleration\": {"]
#[doc = "      \"title\": \"Linear Acceleration\","]
#[doc = "      \"description\": \"The 3D Euclidean acceleration vector.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"maxItems\": 3,"]
#[doc = "      \"minItems\": 3,"]
#[doc = "      \"coreason_topological_exemption\": true,"]
#[doc = "      \"prefixItems\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"linear_velocity\": {"]
#[doc = "      \"title\": \"Linear Velocity\","]
#[doc = "      \"description\": \"The 3D Euclidean velocity vector.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"maxItems\": 3,"]
#[doc = "      \"minItems\": 3,"]
#[doc = "      \"coreason_topological_exemption\": true,"]
#[doc = "      \"prefixItems\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"number\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct KinematicDerivativeProfile {
    #[doc = "The 3D rotational acceleration vector."]
    pub angular_acceleration: [::serde_json::Value; 3usize],
    #[doc = "The 3D rotational velocity vector."]
    pub angular_velocity: [::serde_json::Value; 3usize],
    #[doc = "The 3D Euclidean acceleration vector."]
    pub linear_acceleration: [::serde_json::Value; 3usize],
    #[doc = "The 3D Euclidean velocity vector."]
    pub linear_velocity: [::serde_json::Value; 3usize],
}
impl KinematicDerivativeProfile {
    pub fn builder() -> builder::KinematicDerivativeProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Optimal Stopping Theory and Simulated Annealing to mechanistically manage the Exploration-Exploitation dilemma during Test-Time Compute.\n\nCAUSAL AFFORDANCE: Forces probability wave collapse by dynamically throttling the sampling temperature toward the `dynamic_temperature_asymptote` and physically halting lateral ThoughtBranch generation when the `forced_exploitation_threshold_ms` is breached.\n\nEPISTEMIC BOUNDS: The `dynamic_temperature_asymptote` is physically clamped to `le=2.0`. In Softmax thermodynamics, T -> 0 forces argmax exploitation; exceeding this boundary induces uniform noise, mathematically defeating exploitation. The decay geometry is strictly confined to the `exploration_decay_curve` Literal.\n\nMCP ROUTING TRIGGERS: Optimal Stopping Theory, Simulated Annealing, Probability Wave Collapse, Exploration-Exploitation Dilemma, Kinetic Thermodynamics"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"KineticBudgetPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Optimal Stopping Theory and Simulated Annealing to mechanistically manage the Exploration-Exploitation dilemma during Test-Time Compute.\\n\\nCAUSAL AFFORDANCE: Forces probability wave collapse by dynamically throttling the sampling temperature toward the `dynamic_temperature_asymptote` and physically halting lateral ThoughtBranch generation when the `forced_exploitation_threshold_ms` is breached.\\n\\nEPISTEMIC BOUNDS: The `dynamic_temperature_asymptote` is physically clamped to `le=2.0`. In Softmax thermodynamics, T -> 0 forces argmax exploitation; exceeding this boundary induces uniform noise, mathematically defeating exploitation. The decay geometry is strictly confined to the `exploration_decay_curve` Literal.\\n\\nMCP ROUTING TRIGGERS: Optimal Stopping Theory, Simulated Annealing, Probability Wave Collapse, Exploration-Exploitation Dilemma, Kinetic Thermodynamics\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"dynamic_temperature_asymptote\","]
#[doc = "    \"exploration_decay_curve\","]
#[doc = "    \"forced_exploitation_threshold_ms\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"dynamic_temperature_asymptote\": {"]
#[doc = "      \"title\": \"Dynamic Temperature Asymptote\","]
#[doc = "      \"description\": \"The absolute minimum sampling temperature the system must converge to during the final exploitation phase.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 2.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"exploration_decay_curve\": {"]
#[doc = "      \"title\": \"Exploration Decay Curve\","]
#[doc = "      \"description\": \"The mathematical function dictating how rapidly lateral ThoughtBranches are restricted over time.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"linear\","]
#[doc = "        \"exponential\","]
#[doc = "        \"step\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"forced_exploitation_threshold_ms\": {"]
#[doc = "      \"title\": \"Forced Exploitation Threshold Ms\","]
#[doc = "      \"description\": \"The physical wall-clock time remaining at which the orchestrator is mathematically forbidden from opening new lateral branches.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct KineticBudgetPolicy {
    #[doc = "The absolute minimum sampling temperature the system must converge to during the final exploitation phase."]
    pub dynamic_temperature_asymptote: f64,
    #[doc = "The mathematical function dictating how rapidly lateral ThoughtBranches are restricted over time."]
    pub exploration_decay_curve: ExplorationDecayCurve,
    #[doc = "The physical wall-clock time remaining at which the orchestrator is mathematically forbidden from opening new lateral branches."]
    pub forced_exploitation_threshold_ms: ::std::num::NonZeroU64,
}
impl KineticBudgetPolicy {
    pub fn builder() -> builder::KineticBudgetPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements strict Bipartite Graph Separation (Conflict Graphs) to mathematically prevent toxic capability combinations from co-existing within the same causal execution chain.\n\nCAUSAL AFFORDANCE: Forces the orchestrator to perform an intersection check across `mutually_exclusive_clusters`; if an overlap occurs, it mechanically triggers the `enforcement_action` (e.g., `halt_and_quarantine`) to sever the chain.\n\nEPISTEMIC BOUNDS: The 2D matrix of string constraints (`max_length=2000`) is rigidly sorted both internally and externally by `@model_validator` `_enforce_canonical_sort_clusters`, ensuring deterministic RFC 8785 hashing. The `enforcement_action` is clamped to a strict Literal.\n\nMCP ROUTING TRIGGERS: Bipartite Graph Separation, Toxic Capability Quarantine, Finite State Machine, Structural Interlock, Conflict Graph"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"KineticSeparationPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements strict Bipartite Graph Separation (Conflict Graphs) to mathematically prevent toxic capability combinations from co-existing within the same causal execution chain.\\n\\nCAUSAL AFFORDANCE: Forces the orchestrator to perform an intersection check across `mutually_exclusive_clusters`; if an overlap occurs, it mechanically triggers the `enforcement_action` (e.g., `halt_and_quarantine`) to sever the chain.\\n\\nEPISTEMIC BOUNDS: The 2D matrix of string constraints (`max_length=2000`) is rigidly sorted both internally and externally by `@model_validator` `_enforce_canonical_sort_clusters`, ensuring deterministic RFC 8785 hashing. The `enforcement_action` is clamped to a strict Literal.\\n\\nMCP ROUTING TRIGGERS: Bipartite Graph Separation, Toxic Capability Quarantine, Finite State Machine, Structural Interlock, Conflict Graph\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"enforcement_action\","]
#[doc = "    \"mutually_exclusive_clusters\","]
#[doc = "    \"policy_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"enforcement_action\": {"]
#[doc = "      \"title\": \"Enforcement Action\","]
#[doc = "      \"description\": \"The deterministic action the orchestrator must take if a bipartite cycle is detected.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"halt_and_quarantine\","]
#[doc = "        \"sever_causal_chain\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"mutually_exclusive_clusters\": {"]
#[doc = "      \"title\": \"Mutually Exclusive Clusters\","]
#[doc = "      \"description\": \"A topological matrix of tool names or MCP URIs. If an agent mounts one capability in a cluster, all other capabilities in that cluster are mathematically quarantined.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"array\","]
#[doc = "        \"items\": {"]
#[doc = "          \"type\": \"string\","]
#[doc = "          \"maxLength\": 2000"]
#[doc = "        }"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"policy_cid\": {"]
#[doc = "      \"title\": \"Policy Cid\","]
#[doc = "      \"description\": \"Unique identifier for this specific separation boundary.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct KineticSeparationPolicy {
    #[doc = "The deterministic action the orchestrator must take if a bipartite cycle is detected."]
    pub enforcement_action: EnforcementAction,
    #[doc = "A topological matrix of tool names or MCP URIs. If an agent mounts one capability in a cluster, all other capabilities in that cluster are mathematically quarantined."]
    pub mutually_exclusive_clusters:
        ::std::vec::Vec<::std::vec::Vec<MutuallyExclusiveClustersItemItem>>,
    #[doc = "Unique identifier for this specific separation boundary."]
    pub policy_cid: PolicyCid,
}
impl KineticSeparationPolicy {
    pub fn builder() -> builder::KineticSeparationPolicy {
        Default::default()
    }
}
#[doc = "The categorical label of the node (e.g., 'Person', 'Concept')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Label\","]
#[doc = "  \"description\": \"The categorical label of the node (e.g., 'Person', 'Concept').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000,"]
#[doc = "  \"rdf_predicate\": \"rdfs:label\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Label(::std::string::String);
impl ::std::ops::Deref for Label {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Label> for ::std::string::String {
    fn from(value: Label) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Label {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Label {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Label {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Label {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Label {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The external cryptographic receipt generated by Iceberg/Delta."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Lakehouse Snapshot Cid\","]
#[doc = "  \"description\": \"The external cryptographic receipt generated by Iceberg/Delta.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LakehouseSnapshotCid(::std::string::String);
impl ::std::ops::Deref for LakehouseSnapshotCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LakehouseSnapshotCid> for ::std::string::String {
    fn from(value: LakehouseSnapshotCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LakehouseSnapshotCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LakehouseSnapshotCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LakehouseSnapshotCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LakehouseSnapshotCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LakehouseSnapshotCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A pointer to the final abductive guess generated by the Proposer."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Last Rejected Hypothesis Hash\","]
#[doc = "  \"description\": \"A pointer to the final abductive guess generated by the Proposer.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 64"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LastRejectedHypothesisHash(::std::string::String);
impl ::std::ops::Deref for LastRejectedHypothesisHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LastRejectedHypothesisHash> for ::std::string::String {
    fn from(value: LastRejectedHypothesisHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LastRejectedHypothesisHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 64usize {
            return Err("longer than 64 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LastRejectedHypothesisHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LastRejectedHypothesisHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LastRejectedHypothesisHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LastRejectedHypothesisHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SHA-256 hash of the raw latent dimensions explored in this branch."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Latent Content Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the raw latent dimensions explored in this branch.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LatentContentHash(::std::string::String);
impl ::std::ops::Deref for LatentContentHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LatentContentHash> for ::std::string::String {
    fn from(value: LatentContentHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LatentContentHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LatentContentHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LatentContentHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LatentContentHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LatentContentHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Acts as the kinetic trigger for Maximum Inner Product Search (MIPS) and k-Nearest Neighbors (k-NN) retrieval across high-dimensional semantic manifolds.\n\nCAUSAL AFFORDANCE: Forces the orchestrator's embedding engine to dynamically hydrate the working context by fetching the `top_k_candidates` nearest to the `synthetic_target_vector`.\n\nEPISTEMIC BOUNDS: Mathematically boundary-enforced by `min_isometry_score` (`ge=-1.0, le=1.0`) to automatically prune low-relevance hallucinations before they consume context window tokens. `top_k_candidates` is strictly positive (`gt=0`).\n\nMCP ROUTING TRIGGERS: Maximum Inner Product Search, k-Nearest Neighbors, Latent Manifold Projection, Retrieval-Augmented Generation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"LatentProjectionIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Acts as the kinetic trigger for Maximum Inner Product Search (MIPS) and k-Nearest Neighbors (k-NN) retrieval across high-dimensional semantic manifolds.\\n\\nCAUSAL AFFORDANCE: Forces the orchestrator's embedding engine to dynamically hydrate the working context by fetching the `top_k_candidates` nearest to the `synthetic_target_vector`.\\n\\nEPISTEMIC BOUNDS: Mathematically boundary-enforced by `min_isometry_score` (`ge=-1.0, le=1.0`) to automatically prune low-relevance hallucinations before they consume context window tokens. `top_k_candidates` is strictly positive (`gt=0`).\\n\\nMCP ROUTING TRIGGERS: Maximum Inner Product Search, k-Nearest Neighbors, Latent Manifold Projection, Retrieval-Augmented Generation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"min_isometry_score\","]
#[doc = "    \"synthetic_target_vector\","]
#[doc = "    \"top_k_candidates\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"context_expansion\": {"]
#[doc = "      \"description\": \"The structural rules governing context hydration.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ContextExpansionPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"min_isometry_score\": {"]
#[doc = "      \"title\": \"Min Isometry Score\","]
#[doc = "      \"description\": \"The minimum cosine similarity bounds for accepting a vector match.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": -1.0"]
#[doc = "    },"]
#[doc = "    \"synthetic_target_vector\": {"]
#[doc = "      \"description\": \"The strictly typed embedding tensor directing the query.\","]
#[doc = "      \"$ref\": \"#/$defs/VectorEmbeddingState\""]
#[doc = "    },"]
#[doc = "    \"top_k_candidates\": {"]
#[doc = "      \"title\": \"Top K Candidates\","]
#[doc = "      \"description\": \"The maximum number of nodes to extract from the index.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topological_bounds\": {"]
#[doc = "      \"description\": \"The explicit graph traversal contract.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TopologicalRetrievalContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for RAG projection intent.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"latent_projection\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct LatentProjectionIntent {
    #[doc = "The structural rules governing context hydration."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub context_expansion: ::std::option::Option<ContextExpansionPolicy>,
    #[doc = "The minimum cosine similarity bounds for accepting a vector match."]
    pub min_isometry_score: f64,
    #[doc = "The strictly typed embedding tensor directing the query."]
    pub synthetic_target_vector: VectorEmbeddingState,
    #[doc = "The maximum number of nodes to extract from the index."]
    pub top_k_candidates: ::std::num::NonZeroU64,
    #[doc = "The explicit graph traversal contract."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topological_bounds: ::std::option::Option<TopologicalRetrievalContract>,
    #[doc = "Discriminator for RAG projection intent."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl LatentProjectionIntent {
    pub fn builder() -> builder::LatentProjectionIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Authorizes Abductive Reasoning on intercepted unstructured byte streams or memory heaps to probabilistically derive a deterministic StateContract.\n\nCAUSAL AFFORDANCE: Triggers the LLM's representation engineering engine to process a chaotic `target_buffer_cid` and output a rigid JSON schema, bridging the gap between exogenous data and the structural Hollow Data Plane.\n\nEPISTEMIC BOUNDS: State-Space explosion is prevented by bounding `max_schema_depth` (`le=18446744073709551615, ge=1`) and `max_properties` (`le=1000, ge=1`) to mathematically prevent recursive JSON-bombing during schema generation. The `target_buffer_cid` is locked to a 128-char CID.\n\nMCP ROUTING TRIGGERS: Schema Inference, Memory Heap Parsing, Abductive Reasoning, XHR Interception, Unstructured Transmutation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"LatentSchemaInferenceIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Authorizes Abductive Reasoning on intercepted unstructured byte streams or memory heaps to probabilistically derive a deterministic StateContract.\\n\\nCAUSAL AFFORDANCE: Triggers the LLM's representation engineering engine to process a chaotic `target_buffer_cid` and output a rigid JSON schema, bridging the gap between exogenous data and the structural Hollow Data Plane.\\n\\nEPISTEMIC BOUNDS: State-Space explosion is prevented by bounding `max_schema_depth` (`le=18446744073709551615, ge=1`) and `max_properties` (`le=1000, ge=1`) to mathematically prevent recursive JSON-bombing during schema generation. The `target_buffer_cid` is locked to a 128-char CID.\\n\\nMCP ROUTING TRIGGERS: Schema Inference, Memory Heap Parsing, Abductive Reasoning, XHR Interception, Unstructured Transmutation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_properties\","]
#[doc = "    \"max_schema_depth\","]
#[doc = "    \"target_buffer_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_properties\": {"]
#[doc = "      \"title\": \"Max Properties\","]
#[doc = "      \"description\": \"The maximum allowed keys in the deduced JSON dictionary.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1000.0,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"max_schema_depth\": {"]
#[doc = "      \"title\": \"Max Schema Depth\","]
#[doc = "      \"description\": \"The maximum recursive depth of the probabilistically generated schema.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"require_strict_validation\": {"]
#[doc = "      \"title\": \"Require Strict Validation\","]
#[doc = "      \"description\": \"If True, forces the resulting schema to set additionalProperties=False.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"target_buffer_cid\": {"]
#[doc = "      \"title\": \"Target Buffer Cid\","]
#[doc = "      \"description\": \"The CID pointing to the TerminalBufferState or raw intercepted byte stream.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for unstructured payload schema deduction.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"latent_schema_inference\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct LatentSchemaInferenceIntent {
    #[doc = "The maximum allowed keys in the deduced JSON dictionary."]
    pub max_properties: ::std::num::NonZeroU64,
    #[doc = "The maximum recursive depth of the probabilistically generated schema."]
    pub max_schema_depth: ::std::num::NonZeroU64,
    #[doc = "If True, forces the resulting schema to set additionalProperties=False."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub require_strict_validation: ::std::option::Option<bool>,
    #[doc = "The CID pointing to the TerminalBufferState or raw intercepted byte stream."]
    pub target_buffer_cid: TargetBufferCid,
    #[doc = "Discriminator for unstructured payload schema deduction."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl LatentSchemaInferenceIntent {
    pub fn builder() -> builder::LatentSchemaInferenceIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: An append-only, cryptographically frozen coordinate representing an\nEphemeral Epistemic Quarantine used for Monte Carlo Tree Search (MCTS) or Beam Search.\nAs a ...Receipt suffix, this is an append-only coordinate on the Merkle-DAG.\n\nCAUSAL AFFORDANCE: Isolates exploratory trajectories (ThoughtBranchState) from the\nimmutable EpistemicLedgerState, allowing the orchestrator to collapse probability waves\n(via resolution_branch_cid) and prune dead-ends without causal contamination.\n\nEPISTEMIC BOUNDS: Two @model_validators enforce integrity: (1) verify_referential_\nintegrity confirms resolution_branch_cid and all discarded_branches exist within\nexplored_branches; (2) sort_arrays deterministically sorts both explored_branches\n(by branch_cid) and discarded_branches for RFC 8785 Canonical Hashing.\ntotal_latent_tokens is hard-capped (ge=0, le=18446744073709551615).\n\nMCP ROUTING TRIGGERS: Monte Carlo Tree Search, Beam Search, Epistemic Quarantine,\nProbability Wave Collapse, State-Space Exploration"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"LatentScratchpadReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: An append-only, cryptographically frozen coordinate representing an\\nEphemeral Epistemic Quarantine used for Monte Carlo Tree Search (MCTS) or Beam Search.\\nAs a ...Receipt suffix, this is an append-only coordinate on the Merkle-DAG.\\n\\nCAUSAL AFFORDANCE: Isolates exploratory trajectories (ThoughtBranchState) from the\\nimmutable EpistemicLedgerState, allowing the orchestrator to collapse probability waves\\n(via resolution_branch_cid) and prune dead-ends without causal contamination.\\n\\nEPISTEMIC BOUNDS: Two @model_validators enforce integrity: (1) verify_referential_\\nintegrity confirms resolution_branch_cid and all discarded_branches exist within\\nexplored_branches; (2) sort_arrays deterministically sorts both explored_branches\\n(by branch_cid) and discarded_branches for RFC 8785 Canonical Hashing.\\ntotal_latent_tokens is hard-capped (ge=0, le=18446744073709551615).\\n\\nMCP ROUTING TRIGGERS: Monte Carlo Tree Search, Beam Search, Epistemic Quarantine,\\nProbability Wave Collapse, State-Space Exploration\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"discarded_branches\","]
#[doc = "    \"explored_branches\","]
#[doc = "    \"total_latent_tokens\","]
#[doc = "    \"trace_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"discarded_branches\": {"]
#[doc = "      \"title\": \"Discarded Branches\","]
#[doc = "      \"description\": \"The strict array of Content Identifiers (CIDs) that were explicitly pruned due to logical dead-ends.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"explored_branches\": {"]
#[doc = "      \"title\": \"Explored Branches\","]
#[doc = "      \"description\": \"All logical paths the agent attempted within this Ephemeral Epistemic Quarantine—a volatile workspace where probability waves collapse before being committed to the immutable ledger.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyExplorationBranch\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"resolution_branch_cid\": {"]
#[doc = "      \"title\": \"Resolution Branch Cid\","]
#[doc = "      \"description\": \"The Content Identifier (CID) that successfully resolved the uncertainty and led to the final output.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"total_latent_tokens\": {"]
#[doc = "      \"title\": \"Total Latent Tokens\","]
#[doc = "      \"description\": \"The total expenditure (in tokens) spent purely on internal reasoning.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"trace_cid\": {"]
#[doc = "      \"title\": \"Trace Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) bounding this ephemeral test-time execution tree.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct LatentScratchpadReceipt {
    #[doc = "The strict array of Content Identifiers (CIDs) that were explicitly pruned due to logical dead-ends."]
    pub discarded_branches: ::std::vec::Vec<DiscardedBranchesItem>,
    #[doc = "All logical paths the agent attempted within this Ephemeral Epistemic Quarantine—a volatile workspace where probability waves collapse before being committed to the immutable ledger."]
    pub explored_branches: ::std::vec::Vec<AnyExplorationBranch>,
    #[doc = "The Content Identifier (CID) that successfully resolved the uncertainty and led to the final output."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub resolution_branch_cid: ::std::option::Option<::std::string::String>,
    #[doc = "The total expenditure (in tokens) spent purely on internal reasoning."]
    pub total_latent_tokens: u64,
    #[doc = "A Content Identifier (CID) bounding this ephemeral test-time execution tree."]
    pub trace_cid: TraceCid,
}
impl LatentScratchpadReceipt {
    pub fn builder() -> builder::LatentScratchpadReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines a differentiable attenuation curve to mitigate adversarial activation spikes during forward-pass token generation.\n\nCAUSAL AFFORDANCE: Instructs the tensor execution engine to apply trigonometric or algebraic decay functions to specific latent circuits, smoothly steering the probability wave without causing logit collapse.\n\nEPISTEMIC BOUNDS: The decay geometry is strictly typed to the `decay_function` Literal `[\"linear\", \"exponential\", \"cosine_annealing\"]`. The temporal horizon is physically bounded by `transition_window_tokens` (`gt=0, le=18446744073709551615`). The optional `decay_rate_param` is bounded `le=1.0`.\n\nMCP ROUTING TRIGGERS: Mechanistic Interpretability, Tensor Attenuation, Cosine Annealing, Logit Collapse Prevention, Activation Smoothing"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"LatentSmoothingProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines a differentiable attenuation curve to mitigate adversarial activation spikes during forward-pass token generation.\\n\\nCAUSAL AFFORDANCE: Instructs the tensor execution engine to apply trigonometric or algebraic decay functions to specific latent circuits, smoothly steering the probability wave without causing logit collapse.\\n\\nEPISTEMIC BOUNDS: The decay geometry is strictly typed to the `decay_function` Literal `[\\\"linear\\\", \\\"exponential\\\", \\\"cosine_annealing\\\"]`. The temporal horizon is physically bounded by `transition_window_tokens` (`gt=0, le=18446744073709551615`). The optional `decay_rate_param` is bounded `le=1.0`.\\n\\nMCP ROUTING TRIGGERS: Mechanistic Interpretability, Tensor Attenuation, Cosine Annealing, Logit Collapse Prevention, Activation Smoothing\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"decay_function\","]
#[doc = "    \"transition_window_tokens\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"decay_function\": {"]
#[doc = "      \"title\": \"Decay Function\","]
#[doc = "      \"description\": \"The trigonometric or algebraic function governing the attenuation curve.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"linear\","]
#[doc = "        \"exponential\","]
#[doc = "        \"cosine_annealing\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"decay_rate_param\": {"]
#[doc = "      \"title\": \"Decay Rate Param\","]
#[doc = "      \"description\": \"The optional tuning parameter (e.g., half-life lambda for exponential decay).\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"transition_window_tokens\": {"]
#[doc = "      \"title\": \"Transition Window Tokens\","]
#[doc = "      \"description\": \"The exact number of forward-pass generation steps over which the decay is applied.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct LatentSmoothingProfile {
    #[doc = "The trigonometric or algebraic function governing the attenuation curve."]
    pub decay_function: DecayFunction,
    #[doc = "The optional tuning parameter (e.g., half-life lambda for exponential decay)."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub decay_rate_param: ::std::option::Option<f64>,
    #[doc = "The exact number of forward-pass generation steps over which the decay is applied."]
    pub transition_window_tokens: ::std::num::NonZeroU64,
}
impl LatentSmoothingProfile {
    pub fn builder() -> builder::LatentSmoothingProfile {
        Default::default()
    }
}
#[doc = "`LatentVariablesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LatentVariablesItem(::std::string::String);
impl ::std::ops::Deref for LatentVariablesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LatentVariablesItem> for ::std::string::String {
    fn from(value: LatentVariablesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LatentVariablesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LatentVariablesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LatentVariablesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LatentVariablesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LatentVariablesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`LayoutMatrixItemItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LayoutMatrixItemItem(::std::string::String);
impl ::std::ops::Deref for LayoutMatrixItemItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LayoutMatrixItemItem> for ::std::string::String {
    fn from(value: LayoutMatrixItemItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LayoutMatrixItemItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LayoutMatrixItemItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LayoutMatrixItemItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LayoutMatrixItemItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LayoutMatrixItemItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Python 3.14 t-string template definition for dynamic UI grid evaluation."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Layout Tstring\","]
#[doc = "  \"description\": \"A Python 3.14 t-string template definition for dynamic UI grid evaluation.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LayoutTstring(::std::string::String);
impl ::std::ops::Deref for LayoutTstring {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LayoutTstring> for ::std::string::String {
    fn from(value: LayoutTstring) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LayoutTstring {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LayoutTstring {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LayoutTstring {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LayoutTstring {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LayoutTstring {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The cryptographic pointer to the semantic series in the EpistemicLedgerState."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Ledger Source Cid\","]
#[doc = "  \"description\": \"The cryptographic pointer to the semantic series in the EpistemicLedgerState.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LedgerSourceCid(::std::string::String);
impl ::std::ops::Deref for LedgerSourceCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LedgerSourceCid> for ::std::string::String {
    fn from(value: LedgerSourceCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LedgerSourceCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LedgerSourceCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LedgerSourceCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LedgerSourceCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LedgerSourceCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "RFC 6902 JSON Pointer extracting exogenous data."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Lens Source Pointer\","]
#[doc = "  \"description\": \"RFC 6902 JSON Pointer extracting exogenous data.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LensSourcePointer(::std::string::String);
impl ::std::ops::Deref for LensSourcePointer {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LensSourcePointer> for ::std::string::String {
    fn from(value: LensSourcePointer) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LensSourcePointer {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LensSourcePointer {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LensSourcePointer {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LensSourcePointer {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LensSourcePointer {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The severity level of the log event."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Level\","]
#[doc = "  \"description\": \"The severity level of the log event.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"DEBUG\","]
#[doc = "    \"INFO\","]
#[doc = "    \"WARNING\","]
#[doc = "    \"ERROR\","]
#[doc = "    \"CRITICAL\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum Level {
    #[serde(rename = "DEBUG")]
    Debug,
    #[serde(rename = "INFO")]
    Info,
    #[serde(rename = "WARNING")]
    Warning,
    #[serde(rename = "ERROR")]
    Error,
    #[serde(rename = "CRITICAL")]
    Critical,
}
impl ::std::fmt::Display for Level {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Debug => f.write_str("DEBUG"),
            Self::Info => f.write_str("INFO"),
            Self::Warning => f.write_str("WARNING"),
            Self::Error => f.write_str("ERROR"),
            Self::Critical => f.write_str("CRITICAL"),
        }
    }
}
impl ::std::str::FromStr for Level {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "DEBUG" => Ok(Self::Debug),
            "INFO" => Ok(Self::Info),
            "WARNING" => Ok(Self::Warning),
            "ERROR" => Ok(Self::Error),
            "CRITICAL" => Ok(Self::Critical),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for Level {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Level {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Level {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The execution phase of the graph. 'draft' allows incomplete structural state."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Lifecycle Phase\","]
#[doc = "  \"description\": \"The execution phase of the graph. 'draft' allows incomplete structural state.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"draft\","]
#[doc = "    \"live\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum LifecyclePhase {
    #[serde(rename = "draft")]
    Draft,
    #[serde(rename = "live")]
    Live,
}
impl ::std::fmt::Display for LifecyclePhase {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Draft => f.write_str("draft"),
            Self::Live => f.write_str("live"),
        }
    }
}
impl ::std::str::FromStr for LifecyclePhase {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "draft" => Ok(Self::Draft),
            "live" => Ok(Self::Live),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for LifecyclePhase {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LifecyclePhase {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LifecyclePhase {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`LifecycleTriggerEvent`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"on_start\","]
#[doc = "    \"on_node_transition\","]
#[doc = "    \"before_tool_execution\","]
#[doc = "    \"on_failure\","]
#[doc = "    \"on_consensus_reached\","]
#[doc = "    \"on_max_loops_reached\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum LifecycleTriggerEvent {
    #[serde(rename = "on_start")]
    OnStart,
    #[serde(rename = "on_node_transition")]
    OnNodeTransition,
    #[serde(rename = "before_tool_execution")]
    BeforeToolExecution,
    #[serde(rename = "on_failure")]
    OnFailure,
    #[serde(rename = "on_consensus_reached")]
    OnConsensusReached,
    #[serde(rename = "on_max_loops_reached")]
    OnMaxLoopsReached,
}
impl ::std::fmt::Display for LifecycleTriggerEvent {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::OnStart => f.write_str("on_start"),
            Self::OnNodeTransition => f.write_str("on_node_transition"),
            Self::BeforeToolExecution => f.write_str("before_tool_execution"),
            Self::OnFailure => f.write_str("on_failure"),
            Self::OnConsensusReached => f.write_str("on_consensus_reached"),
            Self::OnMaxLoopsReached => f.write_str("on_max_loops_reached"),
        }
    }
}
impl ::std::str::FromStr for LifecycleTriggerEvent {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "on_start" => Ok(Self::OnStart),
            "on_node_transition" => Ok(Self::OnNodeTransition),
            "before_tool_execution" => Ok(Self::BeforeToolExecution),
            "on_failure" => Ok(Self::OnFailure),
            "on_consensus_reached" => Ok(Self::OnConsensusReached),
            "on_max_loops_reached" => Ok(Self::OnMaxLoopsReached),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for LifecycleTriggerEvent {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LifecycleTriggerEvent {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LifecycleTriggerEvent {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Cryptographic Watermarking and Homomorphic MAC frameworks to mathematically seal the chain of custody against laundering, obfuscation, or Byzantine tampering on the Merkle-DAG.\n\nCAUSAL AFFORDANCE: Enforces a zero-trust execution perimeter by forcing participating agents to append their deterministic execution signatures to the `hop_signatures` matrix, verifying non-repudiation before advancing the graph.\n\nEPISTEMIC BOUNDS: The mathematical sealing mechanism is strictly constrained by the `watermark_protocol` Literal automaton `[\"merkle_dag\", \"statistical_token\", \"homomorphic_mac\"]`. The `hop_signatures` dictionary keys/values are physically bounded by StringConstraints (`max_length=255/2000`, dict `le=18446744073709551615`) to prevent memory exhaustion during serialization.\n\nMCP ROUTING TRIGGERS: Cryptographic Watermarking, Homomorphic MAC, Byzantine Fault Detection, Zero-Trust Lineage, Chain of Custody"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"LineageWatermarkReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Cryptographic Watermarking and Homomorphic MAC frameworks to mathematically seal the chain of custody against laundering, obfuscation, or Byzantine tampering on the Merkle-DAG.\\n\\nCAUSAL AFFORDANCE: Enforces a zero-trust execution perimeter by forcing participating agents to append their deterministic execution signatures to the `hop_signatures` matrix, verifying non-repudiation before advancing the graph.\\n\\nEPISTEMIC BOUNDS: The mathematical sealing mechanism is strictly constrained by the `watermark_protocol` Literal automaton `[\\\"merkle_dag\\\", \\\"statistical_token\\\", \\\"homomorphic_mac\\\"]`. The `hop_signatures` dictionary keys/values are physically bounded by StringConstraints (`max_length=255/2000`, dict `le=18446744073709551615`) to prevent memory exhaustion during serialization.\\n\\nMCP ROUTING TRIGGERS: Cryptographic Watermarking, Homomorphic MAC, Byzantine Fault Detection, Zero-Trust Lineage, Chain of Custody\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"hop_signatures\","]
#[doc = "    \"tamper_evident_root\","]
#[doc = "    \"watermark_protocol\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"hop_signatures\": {"]
#[doc = "      \"title\": \"Hop Signatures\","]
#[doc = "      \"description\": \"A dictionary mapping intermediate participant NodeIdentifierStates to their deterministic execution signatures.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      },"]
#[doc = "      \"le\": 18446744073709551615"]
#[doc = "    },"]
#[doc = "    \"tamper_evident_root\": {"]
#[doc = "      \"title\": \"Tamper Evident Root\","]
#[doc = "      \"description\": \"The overarching cryptographic hash (e.g., Merkle Root) proving the structural payload has not been laundered or structurally modified.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"watermark_protocol\": {"]
#[doc = "      \"title\": \"Watermark Protocol\","]
#[doc = "      \"description\": \"The mathematical methodology used to embed the chain of custody.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"merkle_dag\","]
#[doc = "        \"statistical_token\","]
#[doc = "        \"homomorphic_mac\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct LineageWatermarkReceipt {
    #[doc = "A dictionary mapping intermediate participant NodeIdentifierStates to their deterministic execution signatures."]
    pub hop_signatures: ::std::collections::HashMap<
        ::std::string::String,
        LineageWatermarkReceiptHopSignaturesValue,
    >,
    #[doc = "The overarching cryptographic hash (e.g., Merkle Root) proving the structural payload has not been laundered or structurally modified."]
    pub tamper_evident_root: TamperEvidentRoot,
    #[doc = "The mathematical methodology used to embed the chain of custody."]
    pub watermark_protocol: WatermarkProtocol,
}
impl LineageWatermarkReceipt {
    pub fn builder() -> builder::LineageWatermarkReceipt {
        Default::default()
    }
}
#[doc = "`LineageWatermarkReceiptHopSignaturesValue`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LineageWatermarkReceiptHopSignaturesValue(::std::string::String);
impl ::std::ops::Deref for LineageWatermarkReceiptHopSignaturesValue {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LineageWatermarkReceiptHopSignaturesValue> for ::std::string::String {
    fn from(value: LineageWatermarkReceiptHopSignaturesValue) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LineageWatermarkReceiptHopSignaturesValue {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LineageWatermarkReceiptHopSignaturesValue {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LineageWatermarkReceiptHopSignaturesValue {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LineageWatermarkReceiptHopSignaturesValue {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LineageWatermarkReceiptHopSignaturesValue {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Instructs the Ontological Grounding Specialist to enforce bipartite crosswalks against academic schemas.\n\nCAUSAL AFFORDANCE: Forces the structural validation of all causal edges through LinkML.\n\nEPISTEMIC BOUNDS: The linkml_schema_uri strictly clamps the topological ruleset to a remote YAML definition.\n\nMCP ROUTING TRIGGERS: LinkML, Graph-Shape Governance, Structural Isomorphism, SHACL, Domain and Range Enforcement"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"LinkMLValidationSLA\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Instructs the Ontological Grounding Specialist to enforce bipartite crosswalks against academic schemas.\\n\\nCAUSAL AFFORDANCE: Forces the structural validation of all causal edges through LinkML.\\n\\nEPISTEMIC BOUNDS: The linkml_schema_uri strictly clamps the topological ruleset to a remote YAML definition.\\n\\nMCP ROUTING TRIGGERS: LinkML, Graph-Shape Governance, Structural Isomorphism, SHACL, Domain and Range Enforcement\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"linkml_schema_uri\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"linkml_schema_uri\": {"]
#[doc = "      \"title\": \"Linkml Schema Uri\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"format\": \"uri\","]
#[doc = "      \"minLength\": 1"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct LinkMlValidationSla {
    pub linkml_schema_uri: ::std::string::String,
}
impl LinkMlValidationSla {
    pub fn builder() -> builder::LinkMlValidationSla {
        Default::default()
    }
}
#[doc = "The SHA-256 hash of the dynamic, temporally bound challenge emitted by the orchestrator to guarantee real-time human presence."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Liveness Challenge Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the dynamic, temporally bound challenge emitted by the orchestrator to guarantee real-time human presence.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LivenessChallengeHash(::std::string::String);
impl ::std::ops::Deref for LivenessChallengeHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LivenessChallengeHash> for ::std::string::String {
    fn from(value: LivenessChallengeHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LivenessChallengeHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LivenessChallengeHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LivenessChallengeHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LivenessChallengeHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LivenessChallengeHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "RFC 8785 hash of the proxy-only structural logic generated by the LLM."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Llm Blind Plan Hash\","]
#[doc = "  \"description\": \"RFC 8785 hash of the proxy-only structural logic generated by the LLM.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LlmBlindPlanHash(::std::string::String);
impl ::std::ops::Deref for LlmBlindPlanHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LlmBlindPlanHash> for ::std::string::String {
    fn from(value: LlmBlindPlanHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LlmBlindPlanHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LlmBlindPlanHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LlmBlindPlanHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LlmBlindPlanHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LlmBlindPlanHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The stringified decimal representing the liquidity parameter defining the market depth and max loss for the AMM."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Lmsr B Parameter\","]
#[doc = "  \"description\": \"The stringified decimal representing the liquidity parameter defining the market depth and max loss for the AMM.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255,"]
#[doc = "  \"pattern\": \"^\\\\d+\\\\.\\\\d+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LmsrBParameter(::std::string::String);
impl ::std::ops::Deref for LmsrBParameter {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LmsrBParameter> for ::std::string::String {
    fn from(value: LmsrBParameter) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LmsrBParameter {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^\\d+\\.\\d+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^\\d+\\.\\d+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LmsrBParameter {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LmsrBParameter {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LmsrBParameter {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LmsrBParameter {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SHA-256 hash of the exact prompt, weights, and constraints evaluated by the prover."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Logical Circuit Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the exact prompt, weights, and constraints evaluated by the prover.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LogicalCircuitHash(::std::string::String);
impl ::std::ops::Deref for LogicalCircuitHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LogicalCircuitHash> for ::std::string::String {
    fn from(value: LogicalCircuitHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LogicalCircuitHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LogicalCircuitHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LogicalCircuitHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LogicalCircuitHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LogicalCircuitHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A cryptographic mandate for neural watermarking. Uses a Pseudo-Random Function (PRF) seeded by previous token context to deterministically split the vocabulary during Gumbel-Softmax sampling.\n\nCAUSAL AFFORDANCE: Physically manipulates the LLM's residual stream logit distribution just before the final softmax activation, embedding an undeniable, high-entropy Shannon information signature directly into the generated text without degrading model perplexity.\n\nEPISTEMIC BOUNDS: Injection is mathematically clamped by `watermark_strength_delta` (`gt=0.0, le=1.0`). Resistance to cropping attacks is geometrically enforced by `context_history_window` (`ge=0, le=18446744073709551615`). Information density is bounded by `target_bits_per_token` (`gt=0.0, le=18446744073709551615.0`). Locked by `prf_seed_hash` (SHA-256).\n\nMCP ROUTING TRIGGERS: Logit Steganography, Gumbel-Softmax Watermarking, Pseudo-Random Function, Shannon Entropy, Provenance Tracking"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"LogitSteganographyContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A cryptographic mandate for neural watermarking. Uses a Pseudo-Random Function (PRF) seeded by previous token context to deterministically split the vocabulary during Gumbel-Softmax sampling.\\n\\nCAUSAL AFFORDANCE: Physically manipulates the LLM's residual stream logit distribution just before the final softmax activation, embedding an undeniable, high-entropy Shannon information signature directly into the generated text without degrading model perplexity.\\n\\nEPISTEMIC BOUNDS: Injection is mathematically clamped by `watermark_strength_delta` (`gt=0.0, le=1.0`). Resistance to cropping attacks is geometrically enforced by `context_history_window` (`ge=0, le=18446744073709551615`). Information density is bounded by `target_bits_per_token` (`gt=0.0, le=18446744073709551615.0`). Locked by `prf_seed_hash` (SHA-256).\\n\\nMCP ROUTING TRIGGERS: Logit Steganography, Gumbel-Softmax Watermarking, Pseudo-Random Function, Shannon Entropy, Provenance Tracking\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"context_history_window\","]
#[doc = "    \"prf_seed_hash\","]
#[doc = "    \"target_bits_per_token\","]
#[doc = "    \"verification_public_key_cid\","]
#[doc = "    \"watermark_strength_delta\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"context_history_window\": {"]
#[doc = "      \"title\": \"Context History Window\","]
#[doc = "      \"description\": \"The k-gram rolling window size of preceding tokens hashed into the PRF state to ensure robustness against text cropping.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"prf_seed_hash\": {"]
#[doc = "      \"title\": \"Prf Seed Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the cryptographic seed used to initialize the pseudo-random function (PRF).\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"target_bits_per_token\": {"]
#[doc = "      \"title\": \"Target Bits Per Token\","]
#[doc = "      \"description\": \"The information-theoretic density of the payload being embedded into the generative stream.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"verification_public_key_cid\": {"]
#[doc = "      \"title\": \"Verification Public Key Cid\","]
#[doc = "      \"description\": \"The DID or public key identifier required by an auditor to reconstruct the PRF and verify the watermark.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"watermark_strength_delta\": {"]
#[doc = "      \"title\": \"Watermark Strength Delta\","]
#[doc = "      \"description\": \"The exact logit scalar (bias) injected into the 'green list' vocabulary partition before Gumbel-Softmax sampling.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct LogitSteganographyContract {
    #[doc = "The k-gram rolling window size of preceding tokens hashed into the PRF state to ensure robustness against text cropping."]
    pub context_history_window: u64,
    #[doc = "The SHA-256 hash of the cryptographic seed used to initialize the pseudo-random function (PRF)."]
    pub prf_seed_hash: PrfSeedHash,
    #[doc = "The information-theoretic density of the payload being embedded into the generative stream."]
    pub target_bits_per_token: f64,
    #[doc = "The DID or public key identifier required by an auditor to reconstruct the PRF and verify the watermark."]
    pub verification_public_key_cid: VerificationPublicKeyCid,
    #[doc = "The exact logit scalar (bias) injected into the 'green list' vocabulary partition before Gumbel-Softmax sampling."]
    pub watermark_strength_delta: f64,
}
impl LogitSteganographyContract {
    pub fn builder() -> builder::LogitSteganographyContract {
        Default::default()
    }
}
#[doc = "`LossyTranslationDivergenceItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct LossyTranslationDivergenceItem(::std::string::String);
impl ::std::ops::Deref for LossyTranslationDivergenceItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<LossyTranslationDivergenceItem> for ::std::string::String {
    fn from(value: LossyTranslationDivergenceItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for LossyTranslationDivergenceItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for LossyTranslationDivergenceItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for LossyTranslationDivergenceItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for LossyTranslationDivergenceItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for LossyTranslationDivergenceItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Acts as a Cartesian topological coordinator based on Edward Tufte's Small Multiples, organizing multiple discrete visual artifacts into a unified grid configuration.\n\nCAUSAL AFFORDANCE: Translates abstract UI panels into fixed 2D matrices (`layout_matrix`), forcing spatial determinism on the frontend rendering engine.\n\nEPISTEMIC BOUNDS: A strictly bounded `@model_validator` executes a referential integrity sweep, mathematically guaranteeing that every panel ID referenced in the `layout_matrix` (`max_length=1000`) corresponds to a verified object in the `panels` array, physically severing Ghost Panel hallucinations. The `@model_validator` `verify_matrix_dimensions` mathematically forces `column_fractional_weights` and `row_fractional_weights` to perfectly match the Cartesian topology.\n\nMCP ROUTING TRIGGERS: Cartesian Coordinate System, Small Multiples, Spatial Topology, Referential Integrity, Layout Matrix"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MacroGridProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Acts as a Cartesian topological coordinator based on Edward Tufte's Small Multiples, organizing multiple discrete visual artifacts into a unified grid configuration.\\n\\nCAUSAL AFFORDANCE: Translates abstract UI panels into fixed 2D matrices (`layout_matrix`), forcing spatial determinism on the frontend rendering engine.\\n\\nEPISTEMIC BOUNDS: A strictly bounded `@model_validator` executes a referential integrity sweep, mathematically guaranteeing that every panel ID referenced in the `layout_matrix` (`max_length=1000`) corresponds to a verified object in the `panels` array, physically severing Ghost Panel hallucinations. The `@model_validator` `verify_matrix_dimensions` mathematically forces `column_fractional_weights` and `row_fractional_weights` to perfectly match the Cartesian topology.\\n\\nMCP ROUTING TRIGGERS: Cartesian Coordinate System, Small Multiples, Spatial Topology, Referential Integrity, Layout Matrix\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"layout_matrix\","]
#[doc = "    \"panels\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"column_fractional_weights\": {"]
#[doc = "      \"title\": \"Column Fractional Weights\","]
#[doc = "      \"description\": \"Euclidean fractional weights for column partitioning.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"number\""]
#[doc = "      },"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"layout_matrix\": {"]
#[doc = "      \"title\": \"Layout Matrix\","]
#[doc = "      \"description\": \"A matrix defining the layout structure, using panel IDs.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"array\","]
#[doc = "        \"items\": {"]
#[doc = "          \"type\": \"string\","]
#[doc = "          \"maxLength\": 255"]
#[doc = "        }"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000,"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"panels\": {"]
#[doc = "      \"title\": \"Panels\","]
#[doc = "      \"description\": \"The ordered array of topological UI panels physically rendered in the grid.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyPanelProfile\""]
#[doc = "      },"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"row_fractional_weights\": {"]
#[doc = "      \"title\": \"Row Fractional Weights\","]
#[doc = "      \"description\": \"Euclidean fractional weights for row partitioning.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"number\""]
#[doc = "      },"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct MacroGridProfile {
    #[doc = "Euclidean fractional weights for column partitioning."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub column_fractional_weights: ::std::vec::Vec<f64>,
    #[doc = "A matrix defining the layout structure, using panel IDs."]
    pub layout_matrix: ::std::vec::Vec<::std::vec::Vec<LayoutMatrixItemItem>>,
    #[doc = "The ordered array of topological UI panels physically rendered in the grid."]
    pub panels: ::std::vec::Vec<AnyPanelProfile>,
    #[doc = "Euclidean fractional weights for row partitioning."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub row_fractional_weights: ::std::vec::Vec<f64>,
}
impl MacroGridProfile {
    pub fn builder() -> builder::MacroGridProfile {
        Default::default()
    }
}
#[doc = "The magnitude unit of the associated costs."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Magnitude Unit\","]
#[doc = "  \"description\": \"The magnitude unit of the associated costs.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct MagnitudeUnit(::std::string::String);
impl ::std::ops::Deref for MagnitudeUnit {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<MagnitudeUnit> for ::std::string::String {
    fn from(value: MagnitudeUnit) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for MagnitudeUnit {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for MagnitudeUnit {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for MagnitudeUnit {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for MagnitudeUnit {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for MagnitudeUnit {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Cryptographic identifier for this topology."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Manifest Cid\","]
#[doc = "  \"description\": \"Cryptographic identifier for this topology.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ManifestCid(::std::string::String);
impl ::std::ops::Deref for ManifestCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ManifestCid> for ::std::string::String {
    fn from(value: ManifestCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ManifestCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ManifestCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ManifestCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ManifestCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ManifestCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A machine-readable, deterministic JSON receipt of an exact topological failure, replacing unstructured stack traces.\n\nCAUSAL AFFORDANCE: Enables the agent to execute $O(1)$ surgical patches via StateMutationIntent rather than hallucinating fixes.\n\nEPISTEMIC BOUNDS: `failing_pointer` mathematically maps exactly to RFC 6902 JSON Pointers (`max_length=2000`). `violation_category` capped at `255`.\n\nMCP ROUTING TRIGGERS: Fault Receipt, RFC 6902, Epistemic Loss Prevention, Surgical Patching, Traceback Serialization"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ManifestViolationReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A machine-readable, deterministic JSON receipt of an exact topological failure, replacing unstructured stack traces.\\n\\nCAUSAL AFFORDANCE: Enables the agent to execute $O(1)$ surgical patches via StateMutationIntent rather than hallucinating fixes.\\n\\nEPISTEMIC BOUNDS: `failing_pointer` mathematically maps exactly to RFC 6902 JSON Pointers (`max_length=2000`). `violation_category` capped at `255`.\\n\\nMCP ROUTING TRIGGERS: Fault Receipt, RFC 6902, Epistemic Loss Prevention, Surgical Patching, Traceback Serialization\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"diagnostic_message\","]
#[doc = "    \"failing_pointer\","]
#[doc = "    \"violation_category\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"diagnostic_message\": {"]
#[doc = "      \"title\": \"Diagnostic Message\","]
#[doc = "      \"description\": \"The specific constraint breached.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"failing_pointer\": {"]
#[doc = "      \"title\": \"Failing Pointer\","]
#[doc = "      \"description\": \"The exact RFC 6902 JSON pointer isolating the topological failure.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"violation_category\": {"]
#[doc = "      \"title\": \"Violation Category\","]
#[doc = "      \"description\": \"Categorical descriptor of the failure, e.g., missing, type_error.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ManifestViolationReceipt {
    #[doc = "The specific constraint breached."]
    pub diagnostic_message: DiagnosticMessage,
    #[doc = "The exact RFC 6902 JSON pointer isolating the topological failure."]
    pub failing_pointer: FailingPointer,
    #[doc = "Categorical descriptor of the failure, e.g., missing, type_error."]
    pub violation_category: ViolationCategory,
}
impl ManifestViolationReceipt {
    pub fn builder() -> builder::ManifestViolationReceipt {
        Default::default()
    }
}
#[doc = "AGENT INSTRUCTION: Defines the linear algebraic or optimal transport function used to mathematically measure the geometric distance between the telemetry vector and the standard ontology index."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ManifoldAlignmentMetricProfile\","]
#[doc = "  \"description\": \"AGENT INSTRUCTION: Defines the linear algebraic or optimal transport function used to mathematically measure the geometric distance between the telemetry vector and the standard ontology index.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"gromov_wasserstein\","]
#[doc = "    \"earth_movers_distance\","]
#[doc = "    \"cosine_similarity\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ManifoldAlignmentMetricProfile {
    #[serde(rename = "gromov_wasserstein")]
    GromovWasserstein,
    #[serde(rename = "earth_movers_distance")]
    EarthMoversDistance,
    #[serde(rename = "cosine_similarity")]
    CosineSimilarity,
}
impl ::std::fmt::Display for ManifoldAlignmentMetricProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::GromovWasserstein => f.write_str("gromov_wasserstein"),
            Self::EarthMoversDistance => f.write_str("earth_movers_distance"),
            Self::CosineSimilarity => f.write_str("cosine_similarity"),
        }
    }
}
impl ::std::str::FromStr for ManifoldAlignmentMetricProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "gromov_wasserstein" => Ok(Self::GromovWasserstein),
            "earth_movers_distance" => Ok(Self::EarthMoversDistance),
            "cosine_similarity" => Ok(Self::CosineSimilarity),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ManifoldAlignmentMetricProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ManifoldAlignmentMetricProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ManifoldAlignmentMetricProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The geometric shape used to represent the matrix."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Mark\","]
#[doc = "  \"description\": \"The geometric shape used to represent the matrix.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"point\","]
#[doc = "    \"line\","]
#[doc = "    \"area\","]
#[doc = "    \"bar\","]
#[doc = "    \"rect\","]
#[doc = "    \"arc\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum Mark {
    #[serde(rename = "point")]
    Point,
    #[serde(rename = "line")]
    Line,
    #[serde(rename = "area")]
    Area,
    #[serde(rename = "bar")]
    Bar,
    #[serde(rename = "rect")]
    Rect,
    #[serde(rename = "arc")]
    Arc,
}
impl ::std::fmt::Display for Mark {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Point => f.write_str("point"),
            Self::Line => f.write_str("line"),
            Self::Area => f.write_str("area"),
            Self::Bar => f.write_str("bar"),
            Self::Rect => f.write_str("rect"),
            Self::Arc => f.write_str("arc"),
        }
    }
}
impl ::std::str::FromStr for Mark {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "point" => Ok(Self::Point),
            "line" => Ok(Self::Line),
            "area" => Ok(Self::Area),
            "bar" => Ok(Self::Bar),
            "rect" => Ok(Self::Rect),
            "arc" => Ok(Self::Arc),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for Mark {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Mark {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Mark {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The markdown formatted text content."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Markdown Content\","]
#[doc = "  \"description\": \"The markdown formatted text content.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct MarkdownContent(::std::string::String);
impl ::std::ops::Deref for MarkdownContent {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<MarkdownContent> for ::std::string::String {
    fn from(value: MarkdownContent) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for MarkdownContent {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for MarkdownContent {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for MarkdownContent {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for MarkdownContent {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for MarkdownContent {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The deterministic capability pointer representing the prediction market."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Market Cid\","]
#[doc = "  \"description\": \"The deterministic capability pointer representing the prediction market.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"le\": 18446744073709551615"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct MarketCid(::std::string::String);
impl ::std::ops::Deref for MarketCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<MarketCid> for ::std::string::String {
    fn from(value: MarketCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for MarketCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for MarketCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for MarketCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for MarketCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for MarketCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Enforces Algorithmic Mechanism Design and Proof-of-Stake (PoS) economic collateralization required for an agent to participate in the epistemic market.\n\nCAUSAL AFFORDANCE: Unlocks the ability for the orchestrator to computationally slash Byzantine or hallucinating nodes, ensuring a strict thermodynamic cost to semantic drift.\n\nEPISTEMIC BOUNDS: Physically restricts the mathematical invariant where `slashing_penalty <= minimum_collateral` via an `@model_validator`. Both bounds are strictly enforced as atomic integer magnitudes (`ge=0, le=18446744073709551615`).\n\nMCP ROUTING TRIGGERS: Proof-of-Stake, Slashing Condition, Byzantine Fault Tolerance, Economic Escrow"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MarketContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Enforces Algorithmic Mechanism Design and Proof-of-Stake (PoS) economic collateralization required for an agent to participate in the epistemic market.\\n\\nCAUSAL AFFORDANCE: Unlocks the ability for the orchestrator to computationally slash Byzantine or hallucinating nodes, ensuring a strict thermodynamic cost to semantic drift.\\n\\nEPISTEMIC BOUNDS: Physically restricts the mathematical invariant where `slashing_penalty <= minimum_collateral` via an `@model_validator`. Both bounds are strictly enforced as atomic integer magnitudes (`ge=0, le=18446744073709551615`).\\n\\nMCP ROUTING TRIGGERS: Proof-of-Stake, Slashing Condition, Byzantine Fault Tolerance, Economic Escrow\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"minimum_collateral\","]
#[doc = "    \"slashing_penalty\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"minimum_collateral\": {"]
#[doc = "      \"title\": \"Minimum Collateral\","]
#[doc = "      \"description\": \"The minimum atomic token collateral held in escrow.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"slashing_penalty\": {"]
#[doc = "      \"title\": \"Slashing Penalty\","]
#[doc = "      \"description\": \"The exact atomic token amount slashed for Byzantine faults.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct MarketContract {
    #[doc = "The minimum atomic token collateral held in escrow."]
    pub minimum_collateral: u64,
    #[doc = "The exact atomic token amount slashed for Byzantine faults."]
    pub slashing_penalty: u64,
}
impl MarketContract {
    pub fn builder() -> builder::MarketContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents the definitive collapse of the LMSR market superposition into a crystallized `payout_distribution` using Strictly Proper Scoring Rules (e.g., Brier scores).\n\nCAUSAL AFFORDANCE: Instructs the orchestrator to definitively allocate compute magnitudes to the `winning_hypothesis_cid` and flush `falsified_hypothesis_cids` from the active context via a Defeasible Cascade.\n\nEPISTEMIC BOUNDS: Enforces a strictly bounded `payout_distribution` dictionary mapping W3C DIDs to non-negative integers (`ge=0`), with deterministic RFC 8785 array sorting applied to the falsified hypotheses.\n\nMCP ROUTING TRIGGERS: Brier Scoring, Market Settlement, Probability Wave Collapse, Truth Crystallization"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MarketResolutionState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents the definitive collapse of the LMSR market superposition into a crystallized `payout_distribution` using Strictly Proper Scoring Rules (e.g., Brier scores).\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator to definitively allocate compute magnitudes to the `winning_hypothesis_cid` and flush `falsified_hypothesis_cids` from the active context via a Defeasible Cascade.\\n\\nEPISTEMIC BOUNDS: Enforces a strictly bounded `payout_distribution` dictionary mapping W3C DIDs to non-negative integers (`ge=0`), with deterministic RFC 8785 array sorting applied to the falsified hypotheses.\\n\\nMCP ROUTING TRIGGERS: Brier Scoring, Market Settlement, Probability Wave Collapse, Truth Crystallization\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"falsified_hypothesis_cids\","]
#[doc = "    \"market_cid\","]
#[doc = "    \"payout_distribution\","]
#[doc = "    \"winning_hypothesis_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"falsified_hypothesis_cids\": {"]
#[doc = "      \"title\": \"Falsified Hypothesis Cids\","]
#[doc = "      \"description\": \"The hypothesis IDs that were falsified.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000"]
#[doc = "    },"]
#[doc = "    \"market_cid\": {"]
#[doc = "      \"title\": \"Market Cid\","]
#[doc = "      \"description\": \"The deterministic capability pointer representing the prediction market.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"le\": 18446744073709551615"]
#[doc = "    },"]
#[doc = "    \"payout_distribution\": {"]
#[doc = "      \"title\": \"Payout Distribution\","]
#[doc = "      \"description\": \"The deterministic mapping of agent IDs to their earned compute budget/magnitude based on Brier scoring.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"integer\","]
#[doc = "        \"minimum\": 0.0"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"winning_hypothesis_cid\": {"]
#[doc = "      \"title\": \"Winning Hypothesis Cid\","]
#[doc = "      \"description\": \"The hypothesis ID that was verified.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct MarketResolutionState {
    #[doc = "The hypothesis IDs that were falsified."]
    pub falsified_hypothesis_cids: ::std::vec::Vec<FalsifiedHypothesisCidsItem>,
    #[doc = "The deterministic capability pointer representing the prediction market."]
    pub market_cid: MarketCid,
    #[doc = "The deterministic mapping of agent IDs to their earned compute budget/magnitude based on Brier scoring."]
    pub payout_distribution: ::std::collections::HashMap<::std::string::String, u64>,
    #[doc = "The hypothesis ID that was verified."]
    pub winning_hypothesis_cid: WinningHypothesisCid,
}
impl MarketResolutionState {
    pub fn builder() -> builder::MarketResolutionState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Translates Fristonian Active Inference boundaries into rigid physical optics.\nIt defines the exact geometric perimeter where an agent's internal generative states become\nconditionally independent of (and thus occluded from) the external macroscopic swarm topology.\n\nCAUSAL AFFORDANCE: Mathematically forces the opacity of internal mechanistics (e.g., SAE\nactivations, scratchpad trees) to absolute zero, until the observer's SE(3) coordinate\nphysically pierces the agent's volumetric bounding cage.\n\nEPISTEMIC BOUNDS: The physical penetration depth is strictly bounded by pierce_distance_meters\n(ge=0.0). Exogenous interfaces (sensory and active states) are governed by strict boolean gates.\n\nMCP ROUTING TRIGGERS: Fristonian Active Inference, Markov Blanket, Epistemic Isolation, Volumetric Penetration, Conditional Independence"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MarkovBlanketRenderingPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Translates Fristonian Active Inference boundaries into rigid physical optics.\\nIt defines the exact geometric perimeter where an agent's internal generative states become\\nconditionally independent of (and thus occluded from) the external macroscopic swarm topology.\\n\\nCAUSAL AFFORDANCE: Mathematically forces the opacity of internal mechanistics (e.g., SAE\\nactivations, scratchpad trees) to absolute zero, until the observer's SE(3) coordinate\\nphysically pierces the agent's volumetric bounding cage.\\n\\nEPISTEMIC BOUNDS: The physical penetration depth is strictly bounded by pierce_distance_meters\\n(ge=0.0). Exogenous interfaces (sensory and active states) are governed by strict boolean gates.\\n\\nMCP ROUTING TRIGGERS: Fristonian Active Inference, Markov Blanket, Epistemic Isolation, Volumetric Penetration, Conditional Independence\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"pierce_distance_meters\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"expose_sensory_active_states\": {"]
#[doc = "      \"title\": \"Expose Sensory Active States\","]
#[doc = "      \"description\": \"Authorizes the continuous projection of the agent's exogenous API interactions and structural tool commitments to the macroscopic layer.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"occlude_internal_mechanistics\": {"]
#[doc = "      \"title\": \"Occlude Internal Mechanistics\","]
#[doc = "      \"description\": \"Forces absolute rendering occlusion of internal non-monotonic reasoning loops unless the pierce distance is breached.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"pierce_distance_meters\": {"]
#[doc = "      \"title\": \"Pierce Distance Meters\","]
#[doc = "      \"description\": \"The precise Euclidean distance at which an observer's coordinate successfully breaches the agent's internal state partition.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct MarkovBlanketRenderingPolicy {
    #[doc = "Authorizes the continuous projection of the agent's exogenous API interactions and structural tool commitments to the macroscopic layer."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub expose_sensory_active_states: ::std::option::Option<bool>,
    #[doc = "Forces absolute rendering occlusion of internal non-monotonic reasoning loops unless the pierce distance is breached."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub occlude_internal_mechanistics: ::std::option::Option<bool>,
    #[doc = "The precise Euclidean distance at which an observer's coordinate successfully breaches the agent's internal state partition."]
    pub pierce_distance_meters: f64,
}
impl MarkovBlanketRenderingPolicy {
    pub fn builder() -> builder::MarkovBlanketRenderingPolicy {
        Default::default()
    }
}
#[doc = "The formal algebraic representation vector utilized to define physical bounds (e.g., x > 0 and x < 100)."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Mathematical Predicate\","]
#[doc = "  \"description\": \"The formal algebraic representation vector utilized to define physical bounds (e.g., x > 0 and x < 100).\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct MathematicalPredicate(::std::string::String);
impl ::std::ops::Deref for MathematicalPredicate {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<MathematicalPredicate> for ::std::string::String {
    fn from(value: MathematicalPredicate) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for MathematicalPredicate {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for MathematicalPredicate {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for MathematicalPredicate {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for MathematicalPredicate {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for MathematicalPredicate {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`MatrixCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Matrix Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct MatrixCid(::std::string::String);
impl ::std::ops::Deref for MatrixCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<MatrixCid> for ::std::string::String {
    fn from(value: MatrixCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for MatrixCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for MatrixCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for MatrixCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for MatrixCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for MatrixCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes a SPIFFE/SPIRE Service Mesh and Zero-Trust Architecture perimeter, restricting JSON-RPC capability mounts from foreign subgraphs.\n\nCAUSAL AFFORDANCE: Acts as a structural firewall that physically prevents the orchestrator from binding unauthorized external tools, resources, or prompts into the active agent's CognitiveActionSpaceManifest via mTLS delegation.\n\nEPISTEMIC BOUNDS: The boundary is geometrically enforced via `StringConstraints` (`max_length=2000` for `authorized_capability_array`, `allowed_resources`, `allowed_prompts`). The `@model_validator` strictly sorts all arrays alphabetically to mathematically guarantee RFC 8785 Canonical Hashing.\n\nMCP ROUTING TRIGGERS: Zero-Trust Architecture, SPIFFE/SPIRE, Envoy Service Mesh, Least Privilege, RPC Firewall"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MCPCapabilityWhitelistPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes a SPIFFE/SPIRE Service Mesh and Zero-Trust Architecture perimeter, restricting JSON-RPC capability mounts from foreign subgraphs.\\n\\nCAUSAL AFFORDANCE: Acts as a structural firewall that physically prevents the orchestrator from binding unauthorized external tools, resources, or prompts into the active agent's CognitiveActionSpaceManifest via mTLS delegation.\\n\\nEPISTEMIC BOUNDS: The boundary is geometrically enforced via `StringConstraints` (`max_length=2000` for `authorized_capability_array`, `allowed_resources`, `allowed_prompts`). The `@model_validator` strictly sorts all arrays alphabetically to mathematically guarantee RFC 8785 Canonical Hashing.\\n\\nMCP ROUTING TRIGGERS: Zero-Trust Architecture, SPIFFE/SPIRE, Envoy Service Mesh, Least Privilege, RPC Firewall\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"properties\": {"]
#[doc = "    \"allowed_prompts\": {"]
#[doc = "      \"title\": \"Allowed Prompts\","]
#[doc = "      \"description\": \"The explicit whitelist of workflow templates the node is allowed to trigger.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"allowed_resources\": {"]
#[doc = "      \"title\": \"Allowed Resources\","]
#[doc = "      \"description\": \"The explicit whitelist of resource URIs the node is allowed to passively perceive.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"authorized_capability_array\": {"]
#[doc = "      \"title\": \"Authorized Capability Array\","]
#[doc = "      \"description\": \"The explicit whitelist of function names the node is allowed to call.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"required_licenses\": {"]
#[doc = "      \"title\": \"Required Licenses\","]
#[doc = "      \"description\": \"Explicit array of DUA/RBAC enterprise licenses mathematically required to perceive and mount this capability.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct McpCapabilityWhitelistPolicy {
    #[doc = "The explicit whitelist of workflow templates the node is allowed to trigger."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub allowed_prompts: ::std::vec::Vec<AllowedPromptsItem>,
    #[doc = "The explicit whitelist of resource URIs the node is allowed to passively perceive."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub allowed_resources: ::std::vec::Vec<AllowedResourcesItem>,
    #[doc = "The explicit whitelist of function names the node is allowed to call."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub authorized_capability_array: ::std::vec::Vec<AuthorizedCapabilityArrayItem>,
    #[doc = "Explicit array of DUA/RBAC enterprise licenses mathematically required to perceive and mount this capability."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub required_licenses: ::std::vec::Vec<RequiredLicensesItem>,
}
impl ::std::default::Default for McpCapabilityWhitelistPolicy {
    fn default() -> Self {
        Self {
            allowed_prompts: Default::default(),
            allowed_resources: Default::default(),
            authorized_capability_array: Default::default(),
            required_licenses: Default::default(),
        }
    }
}
impl McpCapabilityWhitelistPolicy {
    pub fn builder() -> builder::McpCapabilityWhitelistPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MCPClientIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"holographic_projection\","]
#[doc = "    \"jsonrpc\","]
#[doc = "    \"method\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"holographic_projection\": {"]
#[doc = "      \"description\": \"The mathematically pre-calculated view manifold tailored to the observer's frustum.\","]
#[doc = "      \"$ref\": \"#/$defs/DynamicManifoldProjectionManifest\""]
#[doc = "    },"]
#[doc = "    \"id\": {"]
#[doc = "      \"title\": \"Id\","]
#[doc = "      \"description\": \"Unique request identifier.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"jsonrpc\": {"]
#[doc = "      \"title\": \"Jsonrpc\","]
#[doc = "      \"description\": \"JSON-RPC version.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"2.0\""]
#[doc = "    },"]
#[doc = "    \"method\": {"]
#[doc = "      \"title\": \"Method\","]
#[doc = "      \"description\": \"Method for intent bubbling.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"mcp.ui.emit_intent\""]
#[doc = "    },"]
#[doc = "    \"params\": {"]
#[doc = "      \"title\": \"Params\","]
#[doc = "      \"description\": \"Payload parameters. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"object\","]
#[doc = "          \"maxProperties\": 86400000,"]
#[doc = "          \"additionalProperties\": {"]
#[doc = "            \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"mcp_client_intent\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct McpClientIntent {
    #[doc = "The mathematically pre-calculated view manifold tailored to the observer's frustum."]
    pub holographic_projection: DynamicManifoldProjectionManifest,
    #[doc = "Unique request identifier."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub id: ::std::option::Option<Id>,
    #[doc = "JSON-RPC version."]
    pub jsonrpc: ::std::string::String,
    #[doc = "Method for intent bubbling."]
    pub method: ::std::string::String,
    #[doc = "Payload parameters. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub params: ::std::option::Option<
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    >,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl McpClientIntent {
    pub fn builder() -> builder::McpClientIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents a Higher-Order Function within the Model Context Protocol, mapping a dynamic Latent Prompt Manifold into the agent's execution context.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator to fetch and interpolate an exogenous prompt template from a remote server, using the `arguments` dictionary to inject localized state into the template.\n\nEPISTEMIC BOUNDS: The `arguments` matrix is aggressively routed through the volumetric hardware guillotine (`enforce_payload_topology`) to mathematically prevent Manifold Interpolation Complexity crashes from poisoned external servers. Supply-chain attacks are mitigated by the optional `prompt_hash`.\n\nMCP ROUTING TRIGGERS: Higher-Order Function, Latent Prompt Manifold, Template Interpolation, Supply-Chain Verification, Stateless RPC"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MCPPromptReferenceState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents a Higher-Order Function within the Model Context Protocol, mapping a dynamic Latent Prompt Manifold into the agent's execution context.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator to fetch and interpolate an exogenous prompt template from a remote server, using the `arguments` dictionary to inject localized state into the template.\\n\\nEPISTEMIC BOUNDS: The `arguments` matrix is aggressively routed through the volumetric hardware guillotine (`enforce_payload_topology`) to mathematically prevent Manifold Interpolation Complexity crashes from poisoned external servers. Supply-chain attacks are mitigated by the optional `prompt_hash`.\\n\\nMCP ROUTING TRIGGERS: Higher-Order Function, Latent Prompt Manifold, Template Interpolation, Supply-Chain Verification, Stateless RPC\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"prompt_name\","]
#[doc = "    \"server_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"arguments\": {"]
#[doc = "      \"title\": \"Arguments\","]
#[doc = "      \"description\": \"Arguments to fill the prompt template. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"fallback_persona\": {"]
#[doc = "      \"title\": \"Fallback Persona\","]
#[doc = "      \"description\": \"A fallback persona if the prompt fails to load.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"prompt_hash\": {"]
#[doc = "      \"title\": \"Prompt Hash\","]
#[doc = "      \"description\": \"Cryptographic hash for prompt integrity verification.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"prompt_name\": {"]
#[doc = "      \"title\": \"Prompt Name\","]
#[doc = "      \"description\": \"The name of the prompt template.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"server_cid\": {"]
#[doc = "      \"title\": \"Server Cid\","]
#[doc = "      \"description\": \"The deterministic capability pointer representing the MCP server providing this prompt.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct McpPromptReferenceState {
    #[doc = "Arguments to fill the prompt template. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub arguments: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "A fallback persona if the prompt fails to load."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub fallback_persona: ::std::option::Option<::std::string::String>,
    #[doc = "Cryptographic hash for prompt integrity verification."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prompt_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The name of the prompt template."]
    pub prompt_name: PromptName,
    #[doc = "The deterministic capability pointer representing the MCP server providing this prompt."]
    pub server_cid: ServerCid,
}
impl McpPromptReferenceState {
    pub fn builder() -> builder::McpPromptReferenceState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Exposes a zero-trust Resource Description Framework (RDF) URI mapping, passively projecting external data geometries into the swarm's accessible environment.\n\nCAUSAL AFFORDANCE: Unlocks the agent's ability to perceive specific remote or local files, databases, or API endpoints without granting them kinetic execution privileges over those endpoints.\n\nEPISTEMIC BOUNDS: The URI namespace is physically bounded by the `uris` array, where each string is clamped to `max_length=2000`. The `server_cid` is restricted to a 128-character CID. The `@model_validator` deterministically alphabetizes the URIs to preserve Merkle-DAG integrity.\n\nMCP ROUTING TRIGGERS: Resource Description Framework, Zero-Trust Perception, Epistemic Projection, Passive URI Mapping, Data Topography"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MCPResourceManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Exposes a zero-trust Resource Description Framework (RDF) URI mapping, passively projecting external data geometries into the swarm's accessible environment.\\n\\nCAUSAL AFFORDANCE: Unlocks the agent's ability to perceive specific remote or local files, databases, or API endpoints without granting them kinetic execution privileges over those endpoints.\\n\\nEPISTEMIC BOUNDS: The URI namespace is physically bounded by the `uris` array, where each string is clamped to `max_length=2000`. The `server_cid` is restricted to a 128-character CID. The `@model_validator` deterministically alphabetizes the URIs to preserve Merkle-DAG integrity.\\n\\nMCP ROUTING TRIGGERS: Resource Description Framework, Zero-Trust Perception, Epistemic Projection, Passive URI Mapping, Data Topography\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"server_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"server_cid\": {"]
#[doc = "      \"title\": \"Server Cid\","]
#[doc = "      \"description\": \"The deterministic capability pointer representing the MCP server providing these resources.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"uris\": {"]
#[doc = "      \"title\": \"Uris\","]
#[doc = "      \"description\": \"The explicit array of resource URIs mathematically bound to the agent.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct McpResourceManifest {
    #[doc = "The deterministic capability pointer representing the MCP server providing these resources."]
    pub server_cid: ServerCid,
    #[doc = "The explicit array of resource URIs mathematically bound to the agent."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub uris: ::std::vec::Vec<UrisItem>,
}
impl McpResourceManifest {
    pub fn builder() -> builder::McpResourceManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents a cryptographically verifiable Distributed RPC substrate mapping within the Actor Model, binding an external Model Context Protocol (MCP) manifold into the swarm's local topology under strict Object-Capability (OCap) rules.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator to physically bridge a zero-trust network boundary, establishing a polymorphic communication channel (stdio, sse, or http) to perceive external resources and actuate remote functions.\n\nEPISTEMIC BOUNDS: The `server_cid` is locked to a 128-char CID regex (`^[a-zA-Z0-9_.:-]+$`). The `@model_validator` `enforce_stdio_supply_chain_lock` strictly mandates a `binary_hash` (SHA-256) for local process generation, sealing the execution envelope against supply-chain poisoning.\n\nMCP ROUTING TRIGGERS: Actor Model, Object Capability Model, Zero-Trust Architecture, Distributed RPC, Supply-Chain Isolation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MCPServerManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents a cryptographically verifiable Distributed RPC substrate mapping within the Actor Model, binding an external Model Context Protocol (MCP) manifold into the swarm's local topology under strict Object-Capability (OCap) rules.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator to physically bridge a zero-trust network boundary, establishing a polymorphic communication channel (stdio, sse, or http) to perceive external resources and actuate remote functions.\\n\\nEPISTEMIC BOUNDS: The `server_cid` is locked to a 128-char CID regex (`^[a-zA-Z0-9_.:-]+$`). The `@model_validator` `enforce_stdio_supply_chain_lock` strictly mandates a `binary_hash` (SHA-256) for local process generation, sealing the execution envelope against supply-chain poisoning.\\n\\nMCP ROUTING TRIGGERS: Actor Model, Object Capability Model, Zero-Trust Architecture, Distributed RPC, Supply-Chain Isolation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"attestation_receipt\","]
#[doc = "    \"capability_whitelist\","]
#[doc = "    \"server_cid\","]
#[doc = "    \"transport\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"attestation_receipt\": {"]
#[doc = "      \"description\": \"Cryptographic proof of identity and authorization for the external server.\","]
#[doc = "      \"$ref\": \"#/$defs/VerifiableCredentialPresentationReceipt\""]
#[doc = "    },"]
#[doc = "    \"binary_hash\": {"]
#[doc = "      \"title\": \"Binary Hash\","]
#[doc = "      \"description\": \"Optional SHA-256 hash of the local binary to prevent supply-chain execution attacks over stdio.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"capability_whitelist\": {"]
#[doc = "      \"description\": \"The strict capability bounds (tools, resources, prompts) enforced by the orchestrator prior to connection.\","]
#[doc = "      \"$ref\": \"#/$defs/MCPCapabilityWhitelistPolicy\""]
#[doc = "    },"]
#[doc = "    \"server_cid\": {"]
#[doc = "      \"title\": \"Server Cid\","]
#[doc = "      \"description\": \"A unique cryptographic identifier (CID) for this server instance.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"state_synchronization_optics\": {"]
#[doc = "      \"title\": \"State Synchronization Optics\","]
#[doc = "      \"description\": \"Profunctor mappings for side-effect-free state synchronization.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/OpticalMappingContract\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for an MCP server.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"mcp_server\""]
#[doc = "    },"]
#[doc = "    \"transport\": {"]
#[doc = "      \"title\": \"Transport\","]
#[doc = "      \"description\": \"Polymorphic transport configuration (stdio, sse, or http) including env_vars, args, and headers.\","]
#[doc = "      \"oneOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StdioTransportProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SSETransportProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/HTTPTransportProfile\""]
#[doc = "        }"]
#[doc = "      ],"]
#[doc = "      \"discriminator\": {"]
#[doc = "        \"mapping\": {"]
#[doc = "          \"http\": \"#/$defs/HTTPTransportProfile\","]
#[doc = "          \"sse\": \"#/$defs/SSETransportProfile\","]
#[doc = "          \"stdio\": \"#/$defs/StdioTransportProfile\""]
#[doc = "        },"]
#[doc = "        \"propertyName\": \"topology_class\""]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct McpServerManifest {
    #[doc = "Cryptographic proof of identity and authorization for the external server."]
    pub attestation_receipt: VerifiableCredentialPresentationReceipt,
    #[doc = "Optional SHA-256 hash of the local binary to prevent supply-chain execution attacks over stdio."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub binary_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The strict capability bounds (tools, resources, prompts) enforced by the orchestrator prior to connection."]
    pub capability_whitelist: McpCapabilityWhitelistPolicy,
    #[doc = "A unique cryptographic identifier (CID) for this server instance."]
    pub server_cid: ServerCid,
    #[doc = "Profunctor mappings for side-effect-free state synchronization."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub state_synchronization_optics: ::std::vec::Vec<OpticalMappingContract>,
    #[doc = "Discriminator type for an MCP server."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "Polymorphic transport configuration (stdio, sse, or http) including env_vars, args, and headers."]
    pub transport: Transport,
}
impl McpServerManifest {
    pub fn builder() -> builder::McpServerManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A formal Substrate Projection representing an executable Model Context Protocol (MCP) tool."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MCPToolDefinition\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A formal Substrate Projection representing an executable Model Context Protocol (MCP) tool.\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"description\","]
#[doc = "    \"inputSchema\","]
#[doc = "    \"name\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"description\": {"]
#[doc = "      \"title\": \"Description\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2048"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"inputSchema\": {"]
#[doc = "      \"title\": \"Inputschema\","]
#[doc = "      \"description\": \"The JSON Schema payload mirroring our Pydantic limits.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"name\": {"]
#[doc = "      \"title\": \"Name\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 64,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The RFC 8785 Canonical hash of the immediate causal ancestor event. Null for genesis nodes.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"type\": \"number\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"mcp_tool_definition\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct McpToolDefinition {
    pub description: Description,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub event_cid: ::std::option::Option<EventCid>,
    #[doc = "The JSON Schema payload mirroring our Pydantic limits."]
    #[serde(rename = "inputSchema")]
    pub input_schema: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    pub name: Name,
    #[doc = "The RFC 8785 Canonical hash of the immediate causal ancestor event. Null for genesis nodes."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub timestamp: ::std::option::Option<f64>,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl McpToolDefinition {
    pub fn builder() -> builder::McpToolDefinition {
        Default::default()
    }
}
#[doc = "The SOTA cryptographic mechanism URN used to generate the proof."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Mechanism\","]
#[doc = "  \"description\": \"The SOTA cryptographic mechanism URN used to generate the proof.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Mechanism(::std::string::String);
impl ::std::ops::Deref for Mechanism {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Mechanism> for ::std::string::String {
    fn from(value: Mechanism) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Mechanism {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^urn:coreason:.*$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^urn:coreason:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Mechanism {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Mechanism {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Mechanism {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Mechanism {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes a rigorous Mechanistic Interpretability brain-scan protocol, executing real-time latent state extraction across targeted neural circuits. Execution of this policy is strictly delegated to the external `TransformerLens` substrate to preserve the Hollow Data Plane constraints.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator to halt token generation upon specific `trigger_conditions` to physically slice, quantify, and export the top-k SAE features from the designated `target_hook_points`.\n\nEPISTEMIC BOUNDS: GPU VRAM exhaustion is mathematically prevented by capping `max_features_per_layer` (`gt=0, le=18446744073709551615`). The `@model_validator` deterministically sorts conditions and hook points for RFC 8785 hashing. System integrity enforced via `require_zk_commitments`.\n\nMCP ROUTING TRIGGERS: Latent State Extraction, Mechanistic Interpretability, Sparse Autoencoder, Zero-Knowledge Commitments, VRAM Optimization, TransformerLens, SAELens"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MechanisticAuditContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes a rigorous Mechanistic Interpretability brain-scan protocol, executing real-time latent state extraction across targeted neural circuits. Execution of this policy is strictly delegated to the external `TransformerLens` substrate to preserve the Hollow Data Plane constraints.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator to halt token generation upon specific `trigger_conditions` to physically slice, quantify, and export the top-k SAE features from the designated `target_hook_points`.\\n\\nEPISTEMIC BOUNDS: GPU VRAM exhaustion is mathematically prevented by capping `max_features_per_layer` (`gt=0, le=18446744073709551615`). The `@model_validator` deterministically sorts conditions and hook points for RFC 8785 hashing. System integrity enforced via `require_zk_commitments`.\\n\\nMCP ROUTING TRIGGERS: Latent State Extraction, Mechanistic Interpretability, Sparse Autoencoder, Zero-Knowledge Commitments, VRAM Optimization, TransformerLens, SAELens\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_features_per_layer\","]
#[doc = "    \"target_hook_points\","]
#[doc = "    \"trigger_conditions\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_features_per_layer\": {"]
#[doc = "      \"title\": \"Max Features Per Layer\","]
#[doc = "      \"description\": \"The top-k features to extract, preventing VRAM exhaustion.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"require_zk_commitments\": {"]
#[doc = "      \"title\": \"Require Zk Commitments\","]
#[doc = "      \"description\": \"If True, the orchestrator MUST generate cryptographic latent state proofs alongside the activation extractions.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"target_hook_points\": {"]
#[doc = "      \"title\": \"Target Hook Points\","]
#[doc = "      \"description\": \"The specific TransformerLens hook points the execution engine must extract from.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 256,"]
#[doc = "        \"minLength\": 1,"]
#[doc = "        \"pattern\": \"^[a-zA-Z0-9_.]+$\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"trigger_conditions\": {"]
#[doc = "      \"title\": \"Trigger Conditions\","]
#[doc = "      \"description\": \"The specific architectural events that authorize the orchestrator to halt generation and extract internal activations.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"enum\": ["]
#[doc = "          \"on_tool_call\","]
#[doc = "          \"on_belief_mutation\","]
#[doc = "          \"on_quarantine\","]
#[doc = "          \"on_falsification\""]
#[doc = "        ]"]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct MechanisticAuditContract {
    #[doc = "The top-k features to extract, preventing VRAM exhaustion."]
    pub max_features_per_layer: ::std::num::NonZeroU64,
    #[doc = "If True, the orchestrator MUST generate cryptographic latent state proofs alongside the activation extractions."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub require_zk_commitments: ::std::option::Option<bool>,
    #[doc = "The specific TransformerLens hook points the execution engine must extract from."]
    pub target_hook_points: ::std::vec::Vec<TargetHookPointsItem>,
    #[doc = "The specific architectural events that authorize the orchestrator to halt generation and extract internal activations."]
    pub trigger_conditions: ::std::vec::Vec<TriggerConditionsItem>,
}
impl MechanisticAuditContract {
    pub fn builder() -> builder::MechanisticAuditContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Employs Dynamic Programming principles to create a passive, cryptographic structural interlock pointing to a historically executed and verified graph branch.\n\nCAUSAL AFFORDANCE: Bypasses redundant thermodynamic compute expenditure by collapsing an entire sub-DAG execution into a single, O(1) state retrieval keyed by the `target_topology_hash`.\n\nEPISTEMIC BOUNDS: The cache-hit is mathematically locked to the exact `target_topology_hash` (`TopologyHashReceipt`), guaranteeing perfect graph isomorphism. The retrieved payload is physically constrained by `expected_output_schema` (`max_length=1000`). The type discriminator is locked to `Literal[\"memoized\"]`.\n\nMCP ROUTING TRIGGERS: Dynamic Programming, O(1) Retrieval, Cryptographic Cache, Graph Isomorphism, Compute Conservation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MemoizedNodeProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Employs Dynamic Programming principles to create a passive, cryptographic structural interlock pointing to a historically executed and verified graph branch.\\n\\nCAUSAL AFFORDANCE: Bypasses redundant thermodynamic compute expenditure by collapsing an entire sub-DAG execution into a single, O(1) state retrieval keyed by the `target_topology_hash`.\\n\\nEPISTEMIC BOUNDS: The cache-hit is mathematically locked to the exact `target_topology_hash` (`TopologyHashReceipt`), guaranteeing perfect graph isomorphism. The retrieved payload is physically constrained by `expected_output_schema` (`max_length=1000`). The type discriminator is locked to `Literal[\\\"memoized\\\"]`.\\n\\nMCP ROUTING TRIGGERS: Dynamic Programming, O(1) Retrieval, Cryptographic Cache, Graph Isomorphism, Compute Conservation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"description\","]
#[doc = "    \"expected_output_schema\","]
#[doc = "    \"target_topology_hash\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"description\": {"]
#[doc = "      \"title\": \"Description\","]
#[doc = "      \"description\": \"The semantic boundary defining the objective function or computational perimeter of the execution node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"domain_extensions\": {"]
#[doc = "      \"title\": \"Domain Extensions\","]
#[doc = "      \"description\": \"Passive, untyped extension point for vertical domain context. Strictly bounded to prevent JSON-bomb memory leaks. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"object\","]
#[doc = "          \"additionalProperties\": {"]
#[doc = "            \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"expected_output_schema\": {"]
#[doc = "      \"title\": \"Expected Output Schema\","]
#[doc = "      \"description\": \"The strictly typed JSON Schema expected from the cached payload.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"intervention_policies\": {"]
#[doc = "      \"title\": \"Intervention Policies\","]
#[doc = "      \"description\": \"The declarative array of proactive oversight hooks bound to this node's lifecycle.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/InterventionPolicy\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this node's existence in the graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"markov_blanket\": {"]
#[doc = "      \"description\": \"The epistemic isolation boundary guarding this agent's internal generative states.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/MarkovBlanketRenderingPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"render_material\": {"]
#[doc = "      \"description\": \"The physics-agnostic visual identity or shader governing the spatial rendering of this node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SpatialRenderMaterial\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"semantic_zoom\": {"]
#[doc = "      \"description\": \"The mathematical Information Bottleneck thresholds dictating the semantic degradation of this specific node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticZoomProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_topology_hash\": {"]
#[doc = "      \"description\": \"The exact SHA-256 fingerprint of the executed topology.\","]
#[doc = "      \"$ref\": \"#/$defs/TopologyHashReceipt\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a Memoized node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"memoized\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct MemoizedNodeProfile {
    #[doc = "The AI's declarative rationale for selecting this node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "The semantic boundary defining the objective function or computational perimeter of the execution node."]
    pub description: Description,
    #[doc = "Passive, untyped extension point for vertical domain context. Strictly bounded to prevent JSON-bomb memory leaks. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub domain_extensions: ::std::option::Option<
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    >,
    #[doc = "The strictly typed JSON Schema expected from the cached payload."]
    pub expected_output_schema:
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "The declarative array of proactive oversight hooks bound to this node's lifecycle."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub intervention_policies: ::std::vec::Vec<InterventionPolicy>,
    #[doc = "Cryptographic/audit justification for this node's existence in the graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The epistemic isolation boundary guarding this agent's internal generative states."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub markov_blanket: ::std::option::Option<MarkovBlanketRenderingPolicy>,
    #[doc = "The physics-agnostic visual identity or shader governing the spatial rendering of this node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub render_material: ::std::option::Option<SpatialRenderMaterial>,
    #[doc = "The mathematical Information Bottleneck thresholds dictating the semantic degradation of this specific node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_zoom: ::std::option::Option<SemanticZoomProfile>,
    #[doc = "The exact SHA-256 fingerprint of the executed topology."]
    pub target_topology_hash: TopologyHashReceipt,
    #[doc = "Discriminator for a Memoized node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl MemoizedNodeProfile {
    pub fn builder() -> builder::MemoizedNodeProfile {
        Default::default()
    }
}
#[doc = "The formal mathematical operation used to resolve topological forks."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Merge Algebra\","]
#[doc = "  \"description\": \"The formal mathematical operation used to resolve topological forks.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"set_union\","]
#[doc = "    \"lamport_dominance\","]
#[doc = "    \"vector_clock_dominance\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum MergeAlgebra {
    #[serde(rename = "set_union")]
    SetUnion,
    #[serde(rename = "lamport_dominance")]
    LamportDominance,
    #[serde(rename = "vector_clock_dominance")]
    VectorClockDominance,
}
impl ::std::fmt::Display for MergeAlgebra {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::SetUnion => f.write_str("set_union"),
            Self::LamportDominance => f.write_str("lamport_dominance"),
            Self::VectorClockDominance => f.write_str("vector_clock_dominance"),
        }
    }
}
impl ::std::str::FromStr for MergeAlgebra {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "set_union" => Ok(Self::SetUnion),
            "lamport_dominance" => Ok(Self::LamportDominance),
            "vector_clock_dominance" => Ok(Self::VectorClockDominance),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for MergeAlgebra {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for MergeAlgebra {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for MergeAlgebra {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "SHA-256 Merkle root of the payload chunks."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Merkle Root\","]
#[doc = "  \"description\": \"SHA-256 Merkle root of the payload chunks.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-fA-F0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct MerkleRoot(::std::string::String);
impl ::std::ops::Deref for MerkleRoot {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<MerkleRoot> for ::std::string::String {
    fn from(value: MerkleRoot) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for MerkleRoot {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-fA-F0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-fA-F0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for MerkleRoot {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for MerkleRoot {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for MerkleRoot {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for MerkleRoot {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The primary log message."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Message\","]
#[doc = "  \"description\": \"The primary log message.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Message(::std::string::String);
impl ::std::ops::Deref for Message {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Message> for ::std::string::String {
    fn from(value: Message) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Message {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Message {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Message {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Message {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Message {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A strict cryptographic string identifier for this L1 procedural pointer."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Metadata Cid\","]
#[doc = "  \"description\": \"A strict cryptographic string identifier for this L1 procedural pointer.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct MetadataCid(::std::string::String);
impl ::std::ops::Deref for MetadataCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<MetadataCid> for ::std::string::String {
    fn from(value: MetadataCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for MetadataCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for MetadataCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for MetadataCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for MetadataCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for MetadataCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Method to be invoked."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Method\","]
#[doc = "  \"description\": \"Method to be invoked.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 1000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Method(::std::string::String);
impl ::std::ops::Deref for Method {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Method> for ::std::string::String {
    fn from(value: Method) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Method {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 1000usize {
            return Err("longer than 1000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Method {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Method {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Method {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Method {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Strict MIME typing of the source artifact (e.g., 'application/pdf')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Mime Type\","]
#[doc = "  \"description\": \"Strict MIME typing of the source artifact (e.g., 'application/pdf').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct MimeType(::std::string::String);
impl ::std::ops::Deref for MimeType {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<MimeType> for ::std::string::String {
    fn from(value: MimeType) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for MimeType {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for MimeType {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for MimeType {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for MimeType {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for MimeType {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`MonitoredHookPointsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 256,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct MonitoredHookPointsItem(::std::string::String);
impl ::std::ops::Deref for MonitoredHookPointsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<MonitoredHookPointsItem> for ::std::string::String {
    fn from(value: MonitoredHookPointsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for MonitoredHookPointsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 256usize {
            return Err("longer than 256 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for MonitoredHookPointsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for MonitoredHookPointsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for MonitoredHookPointsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for MonitoredHookPointsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes the formal Genesis Block within the Merkle-DAG for unstructured data ingestion, acting as the absolute origin vector for downstream knowledge extraction.\n\nCAUSAL AFFORDANCE: Triggers the neurosymbolic ingestion pipeline, mechanically anchoring the raw byte stream to a verified temporal coordinate so subsequent transmutations can deterministically prove chain of custody.\n\nEPISTEMIC BOUNDS: Enforces a physical boundary on causality via `temporal_ingest_timestamp`. Data integrity mathematically locked by `byte_stream_hash`, mandating a strict SHA-256 regex (`^[a-f0-9]{64}$`).\n\nMCP ROUTING TRIGGERS: Genesis Block, Merkle-DAG, Content Addressable Storage, Cryptographic Anchoring, Unstructured Ingestion"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MultimodalArtifactReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes the formal Genesis Block within the Merkle-DAG for unstructured data ingestion, acting as the absolute origin vector for downstream knowledge extraction.\\n\\nCAUSAL AFFORDANCE: Triggers the neurosymbolic ingestion pipeline, mechanically anchoring the raw byte stream to a verified temporal coordinate so subsequent transmutations can deterministically prove chain of custody.\\n\\nEPISTEMIC BOUNDS: Enforces a physical boundary on causality via `temporal_ingest_timestamp`. Data integrity mathematically locked by `byte_stream_hash`, mandating a strict SHA-256 regex (`^[a-f0-9]{64}$`).\\n\\nMCP ROUTING TRIGGERS: Genesis Block, Merkle-DAG, Content Addressable Storage, Cryptographic Anchoring, Unstructured Ingestion\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"artifact_cid\","]
#[doc = "    \"byte_stream_hash\","]
#[doc = "    \"mime_type\","]
#[doc = "    \"temporal_ingest_timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"artifact_cid\": {"]
#[doc = "      \"title\": \"Artifact Cid\","]
#[doc = "      \"description\": \"The definitive Content Identifier (CID) bounding the raw file.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"byte_stream_hash\": {"]
#[doc = "      \"title\": \"Byte Stream Hash\","]
#[doc = "      \"description\": \"The undeniable SHA-256 hash of the pre-transmutation byte stream.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"global_invariants\": {"]
#[doc = "      \"description\": \"The overarching protocol-level invariants shielding downstream propositions from context collapse.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/GlobalSemanticInvariantProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"mime_type\": {"]
#[doc = "      \"title\": \"Mime Type\","]
#[doc = "      \"description\": \"Strict MIME typing of the source artifact (e.g., 'application/pdf').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"temporal_ingest_timestamp\": {"]
#[doc = "      \"title\": \"Temporal Ingest Timestamp\","]
#[doc = "      \"description\": \"The UNIX timestamp anchoring the genesis block.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct MultimodalArtifactReceipt {
    #[doc = "The definitive Content Identifier (CID) bounding the raw file."]
    pub artifact_cid: ArtifactCid,
    #[doc = "The undeniable SHA-256 hash of the pre-transmutation byte stream."]
    pub byte_stream_hash: ByteStreamHash,
    #[doc = "The overarching protocol-level invariants shielding downstream propositions from context collapse."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub global_invariants: ::std::option::Option<GlobalSemanticInvariantProfile>,
    #[doc = "Strict MIME typing of the source artifact (e.g., 'application/pdf')."]
    pub mime_type: MimeType,
    #[doc = "The UNIX timestamp anchoring the genesis block."]
    pub temporal_ingest_timestamp: f64,
}
impl MultimodalArtifactReceipt {
    pub fn builder() -> builder::MultimodalArtifactReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Orchestrates cross-modal coordinate geometry by mapping 1D\nsequential token spaces (LLMs) to 2D continuous spatial patches\n(Vision-Language Models). As a ...State suffix, this is a declarative, frozen\nsnapshot.\n\nCAUSAL AFFORDANCE: Physically anchors extracted neurosymbolic concepts directly\nto verifiable visual and textual evidence, locking them via block_class\nclassification and visual_patch_hashes arrays.\n\nEPISTEMIC BOUNDS: Token sequences (token_span_start, token_span_end) are\nmathematically bounded 1D limits (ge=0, le=18446744073709551615) constrained by\n@model_validator validate_token_spans to be monotonically increasing. Spatial\ngeometries (bounding_box) enforce normalized Cartesian invariants via\nvalidate_spatial_geometry. Arrays are sorted via sort_arrays.\n\nMCP ROUTING TRIGGERS: Vision-Language Alignment, 1D-2D Projection, VQ-VAE\nSpatial Tracking, Geometric Affine Transforms, Coordinate Bounding"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MultimodalTokenAnchorState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Orchestrates cross-modal coordinate geometry by mapping 1D\\nsequential token spaces (LLMs) to 2D continuous spatial patches\\n(Vision-Language Models). As a ...State suffix, this is a declarative, frozen\\nsnapshot.\\n\\nCAUSAL AFFORDANCE: Physically anchors extracted neurosymbolic concepts directly\\nto verifiable visual and textual evidence, locking them via block_class\\nclassification and visual_patch_hashes arrays.\\n\\nEPISTEMIC BOUNDS: Token sequences (token_span_start, token_span_end) are\\nmathematically bounded 1D limits (ge=0, le=18446744073709551615) constrained by\\n@model_validator validate_token_spans to be monotonically increasing. Spatial\\ngeometries (bounding_box) enforce normalized Cartesian invariants via\\nvalidate_spatial_geometry. Arrays are sorted via sort_arrays.\\n\\nMCP ROUTING TRIGGERS: Vision-Language Alignment, 1D-2D Projection, VQ-VAE\\nSpatial Tracking, Geometric Affine Transforms, Coordinate Bounding\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"properties\": {"]
#[doc = "    \"block_class\": {"]
#[doc = "      \"title\": \"Block Class\","]
#[doc = "      \"description\": \"The structural classification of the source region.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\","]
#[doc = "          \"enum\": ["]
#[doc = "            \"paragraph\","]
#[doc = "            \"table\","]
#[doc = "            \"figure\","]
#[doc = "            \"footnote\","]
#[doc = "            \"header\","]
#[doc = "            \"equation\""]
#[doc = "          ]"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"bounding_box\": {"]
#[doc = "      \"title\": \"Bounding Box\","]
#[doc = "      \"description\": \"The strictly typed [x_min, y_min, x_max, y_max] normalized coordinate matrix.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"array\","]
#[doc = "          \"maxItems\": 1000,"]
#[doc = "          \"minItems\": 4,"]
#[doc = "          \"prefixItems\": ["]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            }"]
#[doc = "          ]"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"temporal_frame_end_ms\": {"]
#[doc = "      \"title\": \"Temporal Frame End Ms\","]
#[doc = "      \"description\": \"The ending millisecond coordinate in a continuous video or audio stream.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"temporal_frame_start_ms\": {"]
#[doc = "      \"title\": \"Temporal Frame Start Ms\","]
#[doc = "      \"description\": \"The starting millisecond coordinate in a continuous video or audio stream.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"token_span_end\": {"]
#[doc = "      \"title\": \"Token Span End\","]
#[doc = "      \"description\": \"The ending index in the discrete VLM context window.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"token_span_start\": {"]
#[doc = "      \"title\": \"Token Span Start\","]
#[doc = "      \"description\": \"The starting index in the discrete VLM context window.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"visual_patch_hashes\": {"]
#[doc = "      \"title\": \"Visual Patch Hashes\","]
#[doc = "      \"description\": \"The explicit array of SHA-256 hashes corresponding to specific VQ-VAE visual patches attended to.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1"]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct MultimodalTokenAnchorState {
    #[doc = "The structural classification of the source region."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub block_class: ::std::option::Option<MultimodalTokenAnchorStateBlockClass>,
    #[doc = "The strictly typed [x_min, y_min, x_max, y_max] normalized coordinate matrix."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub bounding_box: ::std::option::Option<::std::vec::Vec<::serde_json::Value>>,
    #[doc = "The ending millisecond coordinate in a continuous video or audio stream."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub temporal_frame_end_ms: ::std::option::Option<u64>,
    #[doc = "The starting millisecond coordinate in a continuous video or audio stream."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub temporal_frame_start_ms: ::std::option::Option<u64>,
    #[doc = "The ending index in the discrete VLM context window."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub token_span_end: ::std::option::Option<u64>,
    #[doc = "The starting index in the discrete VLM context window."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub token_span_start: ::std::option::Option<u64>,
    #[doc = "The explicit array of SHA-256 hashes corresponding to specific VQ-VAE visual patches attended to."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub visual_patch_hashes: ::std::vec::Vec<VisualPatchHashesItem>,
}
impl ::std::default::Default for MultimodalTokenAnchorState {
    fn default() -> Self {
        Self {
            block_class: Default::default(),
            bounding_box: Default::default(),
            temporal_frame_end_ms: Default::default(),
            temporal_frame_start_ms: Default::default(),
            token_span_end: Default::default(),
            token_span_start: Default::default(),
            visual_patch_hashes: Default::default(),
        }
    }
}
impl MultimodalTokenAnchorState {
    pub fn builder() -> builder::MultimodalTokenAnchorState {
        Default::default()
    }
}
#[doc = "`MultimodalTokenAnchorStateBlockClass`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"paragraph\","]
#[doc = "    \"table\","]
#[doc = "    \"figure\","]
#[doc = "    \"footnote\","]
#[doc = "    \"header\","]
#[doc = "    \"equation\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum MultimodalTokenAnchorStateBlockClass {
    #[serde(rename = "paragraph")]
    Paragraph,
    #[serde(rename = "table")]
    Table,
    #[serde(rename = "figure")]
    Figure,
    #[serde(rename = "footnote")]
    Footnote,
    #[serde(rename = "header")]
    Header,
    #[serde(rename = "equation")]
    Equation,
}
impl ::std::fmt::Display for MultimodalTokenAnchorStateBlockClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Paragraph => f.write_str("paragraph"),
            Self::Table => f.write_str("table"),
            Self::Figure => f.write_str("figure"),
            Self::Footnote => f.write_str("footnote"),
            Self::Header => f.write_str("header"),
            Self::Equation => f.write_str("equation"),
        }
    }
}
impl ::std::str::FromStr for MultimodalTokenAnchorStateBlockClass {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "paragraph" => Ok(Self::Paragraph),
            "table" => Ok(Self::Table),
            "figure" => Ok(Self::Figure),
            "footnote" => Ok(Self::Footnote),
            "header" => Ok(Self::Header),
            "equation" => Ok(Self::Equation),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for MultimodalTokenAnchorStateBlockClass {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for MultimodalTokenAnchorStateBlockClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for MultimodalTokenAnchorStateBlockClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "Forces non-destructive graph mutations."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Mutation Paradigm\","]
#[doc = "  \"description\": \"Forces non-destructive graph mutations.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"append_only\","]
#[doc = "    \"merge_on_resolve\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum MutationParadigm {
    #[serde(rename = "append_only")]
    AppendOnly,
    #[serde(rename = "merge_on_resolve")]
    MergeOnResolve,
}
impl ::std::fmt::Display for MutationParadigm {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::AppendOnly => f.write_str("append_only"),
            Self::MergeOnResolve => f.write_str("merge_on_resolve"),
        }
    }
}
impl ::std::str::FromStr for MutationParadigm {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "append_only" => Ok(Self::AppendOnly),
            "merge_on_resolve" => Ok(Self::MergeOnResolve),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for MutationParadigm {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for MutationParadigm {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for MutationParadigm {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements stochastic perturbation and genetic drift constraints for\nagent variations between generations. As a ...Policy suffix, this object defines rigid\nmathematical boundaries that the orchestrator must enforce globally.\n\nCAUSAL AFFORDANCE: Authorizes the execution engine to inject mathematically bounded\nrandom variance (temperature_shift_variance) into an agent's topological parameters,\nforcing the exploration of novel manifolds in the fitness landscape.\n\nEPISTEMIC BOUNDS: The mutation_rate is clamped strictly to a probability distribution\n(ge=0.0, le=1.0). The temperature_shift_variance is bounded (le=18446744073709551615.0). To\nprevent Byzantine Hash Poisoning, the variance can require a VerifiableEntropyReceipt\n(VRF) via the optional verifiable_entropy field to prove stochastic fairness.\n\nMCP ROUTING TRIGGERS: Stochastic Perturbation, Genetic Drift, Simulated Annealing,\nParameter Variance, Verifiable Random Function"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"MutationPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements stochastic perturbation and genetic drift constraints for\\nagent variations between generations. As a ...Policy suffix, this object defines rigid\\nmathematical boundaries that the orchestrator must enforce globally.\\n\\nCAUSAL AFFORDANCE: Authorizes the execution engine to inject mathematically bounded\\nrandom variance (temperature_shift_variance) into an agent's topological parameters,\\nforcing the exploration of novel manifolds in the fitness landscape.\\n\\nEPISTEMIC BOUNDS: The mutation_rate is clamped strictly to a probability distribution\\n(ge=0.0, le=1.0). The temperature_shift_variance is bounded (le=18446744073709551615.0). To\\nprevent Byzantine Hash Poisoning, the variance can require a VerifiableEntropyReceipt\\n(VRF) via the optional verifiable_entropy field to prove stochastic fairness.\\n\\nMCP ROUTING TRIGGERS: Stochastic Perturbation, Genetic Drift, Simulated Annealing,\\nParameter Variance, Verifiable Random Function\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"mutation_rate\","]
#[doc = "    \"temperature_shift_variance\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"mutation_rate\": {"]
#[doc = "      \"title\": \"Mutation Rate\","]
#[doc = "      \"description\": \"The probability that a given agent parameter will randomly mutate between generations.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"temperature_shift_variance\": {"]
#[doc = "      \"title\": \"Temperature Shift Variance\","]
#[doc = "      \"description\": \"The maximum allowed delta for an agent's temperature during mutation.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"verifiable_entropy\": {"]
#[doc = "      \"description\": \"The cryptographic envelope proving the fairness of the applied mutation rate.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/VerifiableEntropyReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct MutationPolicy {
    #[doc = "The probability that a given agent parameter will randomly mutate between generations."]
    pub mutation_rate: f64,
    #[doc = "The maximum allowed delta for an agent's temperature during mutation."]
    pub temperature_shift_variance: f64,
    #[doc = "The cryptographic envelope proving the fairness of the applied mutation rate."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub verifiable_entropy: ::std::option::Option<VerifiableEntropyReceipt>,
}
impl MutationPolicy {
    pub fn builder() -> builder::MutationPolicy {
        Default::default()
    }
}
#[doc = "`MutuallyExclusiveClustersItemItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct MutuallyExclusiveClustersItemItem(::std::string::String);
impl ::std::ops::Deref for MutuallyExclusiveClustersItemItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<MutuallyExclusiveClustersItemItem> for ::std::string::String {
    fn from(value: MutuallyExclusiveClustersItemItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for MutuallyExclusiveClustersItemItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for MutuallyExclusiveClustersItemItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for MutuallyExclusiveClustersItemItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for MutuallyExclusiveClustersItemItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for MutuallyExclusiveClustersItemItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Tensor Calculus and Differential Geometry representations\nto safely proxy high-dimensional latent structures across zero-trust network boundaries\nwithout transmitting raw, uncompressed bytes. As a ...Manifest suffix, this defines a\nfrozen, declarative coordinate.\n\nCAUSAL AFFORDANCE: Allows the orchestrator to route traffic and reserve exact physical\nGPU memory for massive tensors prior to downloading them via the storage_uri,\npreventing runtime out-of-memory (OOM) execution faults.\n\nEPISTEMIC BOUNDS: The @model_validator _enforce_physics_engine mathematically proves\nthat the topological shape exactly matches the declared vram_footprint_bytes limit\n(le=18446744073709551615) based on the scalar structural_type byte density. Supply-chain\ntampering is physically prevented via the merkle_root SHA-256 requirement.\n\nMCP ROUTING TRIGGERS: Tensor Calculus, Differential Geometry, Merkle Tree Verification, Zero-Trust Computing, Memory Allocation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"NDimensionalTensorManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Tensor Calculus and Differential Geometry representations\\nto safely proxy high-dimensional latent structures across zero-trust network boundaries\\nwithout transmitting raw, uncompressed bytes. As a ...Manifest suffix, this defines a\\nfrozen, declarative coordinate.\\n\\nCAUSAL AFFORDANCE: Allows the orchestrator to route traffic and reserve exact physical\\nGPU memory for massive tensors prior to downloading them via the storage_uri,\\npreventing runtime out-of-memory (OOM) execution faults.\\n\\nEPISTEMIC BOUNDS: The @model_validator _enforce_physics_engine mathematically proves\\nthat the topological shape exactly matches the declared vram_footprint_bytes limit\\n(le=18446744073709551615) based on the scalar structural_type byte density. Supply-chain\\ntampering is physically prevented via the merkle_root SHA-256 requirement.\\n\\nMCP ROUTING TRIGGERS: Tensor Calculus, Differential Geometry, Merkle Tree Verification, Zero-Trust Computing, Memory Allocation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"merkle_root\","]
#[doc = "    \"shape\","]
#[doc = "    \"storage_uri\","]
#[doc = "    \"structural_format\","]
#[doc = "    \"vram_footprint_bytes\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"merkle_root\": {"]
#[doc = "      \"title\": \"Merkle Root\","]
#[doc = "      \"description\": \"SHA-256 Merkle root of the payload chunks.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-fA-F0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"shape\": {"]
#[doc = "      \"title\": \"Shape\","]
#[doc = "      \"description\": \"N-Dimensional shape tuple.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"integer\""]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000"]
#[doc = "    },"]
#[doc = "    \"storage_uri\": {"]
#[doc = "      \"title\": \"Storage Uri\","]
#[doc = "      \"description\": \"Strict URI pointer to the physical bytes.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1"]
#[doc = "    },"]
#[doc = "    \"structural_format\": {"]
#[doc = "      \"description\": \"Structural type of the tensor elements.\","]
#[doc = "      \"$ref\": \"#/$defs/TensorStructuralFormatProfile\""]
#[doc = "    },"]
#[doc = "    \"vram_footprint_bytes\": {"]
#[doc = "      \"title\": \"Vram Footprint Bytes\","]
#[doc = "      \"description\": \"Exact byte size of the uncompressed tensor.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct NDimensionalTensorManifest {
    #[doc = "SHA-256 Merkle root of the payload chunks."]
    pub merkle_root: MerkleRoot,
    #[doc = "N-Dimensional shape tuple."]
    pub shape: ::std::vec::Vec<i64>,
    #[doc = "Strict URI pointer to the physical bytes."]
    pub storage_uri: StorageUri,
    #[doc = "Structural type of the tensor elements."]
    pub structural_format: TensorStructuralFormatProfile,
    #[doc = "Exact byte size of the uncompressed tensor."]
    pub vram_footprint_bytes: u64,
}
impl NDimensionalTensorManifest {
    pub fn builder() -> builder::NDimensionalTensorManifest {
        Default::default()
    }
}
#[doc = "`Name`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Name\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 64,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Name(::std::string::String);
impl ::std::ops::Deref for Name {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Name> for ::std::string::String {
    fn from(value: Name) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Name {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 64usize {
            return Err("longer than 64 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Name {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Name {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Name {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Name {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The raw, unstructured human objective."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Natural Language Goal\","]
#[doc = "  \"description\": \"The raw, unstructured human objective.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 5000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct NaturalLanguageGoal(::std::string::String);
impl ::std::ops::Deref for NaturalLanguageGoal {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<NaturalLanguageGoal> for ::std::string::String {
    fn from(value: NaturalLanguageGoal) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for NaturalLanguageGoal {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 5000usize {
            return Err("longer than 5000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for NaturalLanguageGoal {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for NaturalLanguageGoal {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for NaturalLanguageGoal {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for NaturalLanguageGoal {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The maximum allowed physical network egress boundary for the data."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Network Boundary\","]
#[doc = "  \"description\": \"The maximum allowed physical network egress boundary for the data.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"INTERNET\","]
#[doc = "    \"VPC_INTERNAL\","]
#[doc = "    \"LOCAL_ENCLAVE\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum NetworkBoundary {
    #[serde(rename = "INTERNET")]
    Internet,
    #[serde(rename = "VPC_INTERNAL")]
    VpcInternal,
    #[serde(rename = "LOCAL_ENCLAVE")]
    LocalEnclave,
}
impl ::std::fmt::Display for NetworkBoundary {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Internet => f.write_str("INTERNET"),
            Self::VpcInternal => f.write_str("VPC_INTERNAL"),
            Self::LocalEnclave => f.write_str("LOCAL_ENCLAVE"),
        }
    }
}
impl ::std::str::FromStr for NetworkBoundary {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "INTERNET" => Ok(Self::Internet),
            "VPC_INTERNAL" => Ok(Self::VpcInternal),
            "LOCAL_ENCLAVE" => Ok(Self::LocalEnclave),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for NetworkBoundary {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for NetworkBoundary {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for NetworkBoundary {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: An append-only, cryptographically frozen coordinate representing the verifiable output of a MechanisticAuditContract.\n\nCAUSAL AFFORDANCE: Commits the extracted `SaeFeatureActivationState` matrix (`hook_activations`) to the Merkle-DAG. The `causal_scrubbing_applied` boolean mathematically proves that the orchestrator actively resampled or ablated the circuit to confirm direct causal responsibility.\n\nEPISTEMIC BOUNDS: Cryptographic integrity structurally anchored by `audit_cid` (128-char CID regex). The `@model_validator` sorts each `SaeFeatureActivationState` list within `hook_activations` by `feature_index`, guaranteeing zero-variance RFC 8785 Merkle-DAG hashing.\n\nMCP ROUTING TRIGGERS: Causal Scrubbing, Epistemic Provenance, Mechanistic Audit, RFC 8785 Canonicalization, Cryptographic Brain-Scan, TransformerLens, SAELens"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"NeuralAuditAttestationReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: An append-only, cryptographically frozen coordinate representing the verifiable output of a MechanisticAuditContract.\\n\\nCAUSAL AFFORDANCE: Commits the extracted `SaeFeatureActivationState` matrix (`hook_activations`) to the Merkle-DAG. The `causal_scrubbing_applied` boolean mathematically proves that the orchestrator actively resampled or ablated the circuit to confirm direct causal responsibility.\\n\\nEPISTEMIC BOUNDS: Cryptographic integrity structurally anchored by `audit_cid` (128-char CID regex). The `@model_validator` sorts each `SaeFeatureActivationState` list within `hook_activations` by `feature_index`, guaranteeing zero-variance RFC 8785 Merkle-DAG hashing.\\n\\nMCP ROUTING TRIGGERS: Causal Scrubbing, Epistemic Provenance, Mechanistic Audit, RFC 8785 Canonicalization, Cryptographic Brain-Scan, TransformerLens, SAELens\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"audit_cid\","]
#[doc = "    \"hook_activations\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"audit_cid\": {"]
#[doc = "      \"title\": \"Audit Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"causal_scrubbing_applied\": {"]
#[doc = "      \"title\": \"Causal Scrubbing Applied\","]
#[doc = "      \"description\": \"Cryptographic proof that the orchestrator actively resampled or ablated this circuit to verify its causal responsibility for the output.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"hook_activations\": {"]
#[doc = "      \"title\": \"Hook Activations\","]
#[doc = "      \"description\": \"A mapping of specific TransformerLens hook points to their top-k activated SAE features.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"array\","]
#[doc = "        \"items\": {"]
#[doc = "          \"$ref\": \"#/$defs/SaeFeatureActivationState\""]
#[doc = "        }"]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct NeuralAuditAttestationReceipt {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub audit_cid: AuditCid,
    #[doc = "Cryptographic proof that the orchestrator actively resampled or ablated this circuit to verify its causal responsibility for the output."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub causal_scrubbing_applied: ::std::option::Option<bool>,
    #[doc = "A mapping of specific TransformerLens hook points to their top-k activated SAE features."]
    pub hook_activations: ::std::collections::HashMap<
        ::std::string::String,
        ::std::vec::Vec<SaeFeatureActivationState>,
    >,
}
impl NeuralAuditAttestationReceipt {
    pub fn builder() -> builder::NeuralAuditAttestationReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Bridges the stochastic-deterministic divide by invoking Satisfiability Modulo Theories (SMT) and formal theorem provers (Z3, Lean4, Coq) to execute mathematically unassailable logic.\n\nCAUSAL AFFORDANCE: Offloads non-monotonic probabilistic reasoning into a rigid, verifiable algebraic solver, returning the mathematically proven result to the swarm.\n\nEPISTEMIC BOUNDS: The solver target is restricted to the strict `solver_protocol` Literal automaton (`[\"z3\", \"lean4\", \"coq\", \"tla_plus\", \"sympy\"]`). The Halting Problem is explicitly mitigated by clamping `timeout_ms` (`gt=0, le=18446744073709551615`), preventing infinite computational loops.\n\nMCP ROUTING TRIGGERS: Satisfiability Modulo Theories, Curry-Howard Correspondence, Theorem Proving, Symbolic Handoff, Halting Problem Mitigation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"NeuroSymbolicHandoffContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Bridges the stochastic-deterministic divide by invoking Satisfiability Modulo Theories (SMT) and formal theorem provers (Z3, Lean4, Coq) to execute mathematically unassailable logic.\\n\\nCAUSAL AFFORDANCE: Offloads non-monotonic probabilistic reasoning into a rigid, verifiable algebraic solver, returning the mathematically proven result to the swarm.\\n\\nEPISTEMIC BOUNDS: The solver target is restricted to the strict `solver_protocol` Literal automaton (`[\\\"z3\\\", \\\"lean4\\\", \\\"coq\\\", \\\"tla_plus\\\", \\\"sympy\\\"]`). The Halting Problem is explicitly mitigated by clamping `timeout_ms` (`gt=0, le=18446744073709551615`), preventing infinite computational loops.\\n\\nMCP ROUTING TRIGGERS: Satisfiability Modulo Theories, Curry-Howard Correspondence, Theorem Proving, Symbolic Handoff, Halting Problem Mitigation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"formal_grammar_payload\","]
#[doc = "    \"handoff_cid\","]
#[doc = "    \"solver_protocol\","]
#[doc = "    \"timeout_ms\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"execution_substrate\": {"]
#[doc = "      \"title\": \"Execution Substrate\","]
#[doc = "      \"description\": \"The physical transport layer topology for the execution.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"mcp_local\","]
#[doc = "        \"mcp_remote\","]
#[doc = "        \"direct_ffi\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"expected_proof_receipt_cid\": {"]
#[doc = "      \"title\": \"Expected Proof Receipt Cid\","]
#[doc = "      \"description\": \"Pointer to anticipated receipt.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"formal_grammar_payload\": {"]
#[doc = "      \"title\": \"Formal Grammar Payload\","]
#[doc = "      \"description\": \"The raw code or formal proof syntax generated by the LLM to be evaluated.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000"]
#[doc = "    },"]
#[doc = "    \"handoff_cid\": {"]
#[doc = "      \"title\": \"Handoff Cid\","]
#[doc = "      \"description\": \"Unique identifier for this symbolic delegation.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"solver_protocol\": {"]
#[doc = "      \"title\": \"Solver Protocol\","]
#[doc = "      \"description\": \"The target deterministic math/logic engine.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"lean4\","]
#[doc = "        \"z3\","]
#[doc = "        \"clingo\","]
#[doc = "        \"swi_prolog\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timeout_ms\": {"]
#[doc = "      \"title\": \"Timeout Ms\","]
#[doc = "      \"description\": \"The maximum compute time allocated to the symbolic solver before aborting.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct NeuroSymbolicHandoffContract {
    #[doc = "The physical transport layer topology for the execution."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub execution_substrate: ::std::option::Option<ExecutionSubstrate>,
    #[doc = "Pointer to anticipated receipt."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub expected_proof_receipt_cid: ::std::option::Option<::std::string::String>,
    #[doc = "The raw code or formal proof syntax generated by the LLM to be evaluated."]
    pub formal_grammar_payload: FormalGrammarPayload,
    #[doc = "Unique identifier for this symbolic delegation."]
    pub handoff_cid: HandoffCid,
    #[doc = "The target deterministic math/logic engine."]
    pub solver_protocol: SolverProtocol,
    #[doc = "The maximum compute time allocated to the symbolic solver before aborting."]
    pub timeout_ms: ::std::num::NonZeroU64,
}
impl NeuroSymbolicHandoffContract {
    pub fn builder() -> builder::NeuroSymbolicHandoffContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Orchestrates the core execution payload boundary, acting as the structural pre-inference gate for neurosymbolic probability.\n\n    CAUSAL AFFORDANCE: Empowers the routing engine to sever execution prior to LLM generation if the structural certainty SLA evaluates beyond acceptable mathematical variance boundaries.\n\n    EPISTEMIC BOUNDS: Mandates exact nesting of deterministic fidelity and uncertainty profiles. The pre-flight validator mathematically terminates evaluation if epistemic degradation breaches the SLA limit.\n\n    MCP ROUTING TRIGGERS: Pre-Inference Gate, Neurosymbolic Request, Probability Envelope, SLA Enforcement, Inference Termination"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"NeurosymbolicInferenceIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Orchestrates the core execution payload boundary, acting as the structural pre-inference gate for neurosymbolic probability.\\n\\n    CAUSAL AFFORDANCE: Empowers the routing engine to sever execution prior to LLM generation if the structural certainty SLA evaluates beyond acceptable mathematical variance boundaries.\\n\\n    EPISTEMIC BOUNDS: Mandates exact nesting of deterministic fidelity and uncertainty profiles. The pre-flight validator mathematically terminates evaluation if epistemic degradation breaches the SLA limit.\\n\\n    MCP ROUTING TRIGGERS: Pre-Inference Gate, Neurosymbolic Request, Probability Envelope, SLA Enforcement, Inference Termination\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"fidelity_receipt\","]
#[doc = "    \"sla\","]
#[doc = "    \"source_entity\","]
#[doc = "    \"uncertainty_profile\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"fidelity_receipt\": {"]
#[doc = "      \"description\": \"The immutable scalar matrix capturing pre-inference mathematical contextual completeness.\","]
#[doc = "      \"$ref\": \"#/$defs/TopologicalFidelityReceipt\""]
#[doc = "    },"]
#[doc = "    \"sla\": {"]
#[doc = "      \"description\": \"The mathematical structural boundaries defining acceptable epistemic loss perimeters.\","]
#[doc = "      \"$ref\": \"#/$defs/EpistemicCompressionSLA\""]
#[doc = "    },"]
#[doc = "    \"source_entity\": {"]
#[doc = "      \"description\": \"The structurally isolated 1D boundary representing the semantic payload injected into the context window.\","]
#[doc = "      \"$ref\": \"#/$defs/ContextualizedSourceState\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"neurosymbolic_inference\""]
#[doc = "    },"]
#[doc = "    \"uncertainty_profile\": {"]
#[doc = "      \"description\": \"The rigid matrix evaluating probabilistic uncertainty vectors bounding the initial request state.\","]
#[doc = "      \"$ref\": \"#/$defs/CognitiveUncertaintyProfile\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct NeurosymbolicInferenceIntent {
    #[doc = "The immutable scalar matrix capturing pre-inference mathematical contextual completeness."]
    pub fidelity_receipt: TopologicalFidelityReceipt,
    #[doc = "The mathematical structural boundaries defining acceptable epistemic loss perimeters."]
    pub sla: EpistemicCompressionSla,
    #[doc = "The structurally isolated 1D boundary representing the semantic payload injected into the context window."]
    pub source_entity: ContextualizedSourceState,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The rigid matrix evaluating probabilistic uncertainty vectors bounding the initial request state."]
    pub uncertainty_profile: CognitiveUncertaintyProfile,
}
impl NeurosymbolicInferenceIntent {
    pub fn builder() -> builder::NeurosymbolicInferenceIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A Zero-Cost Macro abstraction that deterministically projects a 4-stage neurosymbolic ingestion pipeline into a rigid Directed Acyclic Graph (DAG).\n\nCAUSAL AFFORDANCE: Physically guarantees that unstructured artifacts pass sequentially through the Docling extractor, OntoGPT grounding specialist, CurioCat verification oracle, and PySHACL archivist without skipping verification gates.\n\nEPISTEMIC BOUNDS: The compile_to_base_topology functor mathematically enforces strict algorithmic complexity bounds (max_depth=4, max_fan_out=1, allow_cycles=False), completely severing the capacity for recursive state-space explosions during ingestion.\n\nMCP ROUTING TRIGGERS: Neurosymbolic Ingestion, Zero-Cost Macro, Substrate Oracles, Deterministic Pipeline, Functorial Semantics"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"NeurosymbolicIngestionTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A Zero-Cost Macro abstraction that deterministically projects a 4-stage neurosymbolic ingestion pipeline into a rigid Directed Acyclic Graph (DAG).\\n\\nCAUSAL AFFORDANCE: Physically guarantees that unstructured artifacts pass sequentially through the Docling extractor, OntoGPT grounding specialist, CurioCat verification oracle, and PySHACL archivist without skipping verification gates.\\n\\nEPISTEMIC BOUNDS: The compile_to_base_topology functor mathematically enforces strict algorithmic complexity bounds (max_depth=4, max_fan_out=1, allow_cycles=False), completely severing the capacity for recursive state-space explosions during ingestion.\\n\\nMCP ROUTING TRIGGERS: Neurosymbolic Ingestion, Zero-Cost Macro, Substrate Oracles, Deterministic Pipeline, Functorial Semantics\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"archivist_node_cid\","]
#[doc = "    \"compiler_node_cid\","]
#[doc = "    \"grounding_specialist_cid\","]
#[doc = "    \"source_artifact_cid\","]
#[doc = "    \"verification_oracle_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"archivist_node_cid\": {"]
#[doc = "      \"description\": \"The W3C DID assigned to the RDF egress gateway.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"compiler_node_cid\": {"]
#[doc = "      \"description\": \"The W3C DID assigned to the Docling extractor.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"egress_format\": {"]
#[doc = "      \"title\": \"Egress Format\","]
#[doc = "      \"description\": \"Target serialization format.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"turtle\","]
#[doc = "        \"xml\","]
#[doc = "        \"json-ld\","]
#[doc = "        \"ntriples\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"epistemic_enforcement\": {"]
#[doc = "      \"description\": \"Ties the topology to the Truth Maintenance layer.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TruthMaintenancePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"grounding_specialist_cid\": {"]
#[doc = "      \"description\": \"The W3C DID assigned to the OntoGPT resolver.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this topology's configuration.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"lifecycle_phase\": {"]
#[doc = "      \"title\": \"Lifecycle Phase\","]
#[doc = "      \"description\": \"The execution phase of the graph.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"draft\","]
#[doc = "        \"live\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"nodes\": {"]
#[doc = "      \"title\": \"Nodes\","]
#[doc = "      \"description\": \"Flat registry of all nodes in this topology.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyNodeProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"observability\": {"]
#[doc = "      \"description\": \"The dynamic Level of Detail physics bound to this graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ObservabilityLODPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"semantic_flow\": {"]
#[doc = "      \"description\": \"The structural Payload Loss Prevention (PLP) contract.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticFlowPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"shared_state_contract\": {"]
#[doc = "      \"description\": \"The schema-on-write contract governing the internal state.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StateContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"source_artifact_cid\": {"]
#[doc = "      \"description\": \"The genesis artifact triggering the pipeline.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for the ingestion macro.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"macro_ingestion\""]
#[doc = "    },"]
#[doc = "    \"verification_oracle_cid\": {"]
#[doc = "      \"description\": \"The W3C DID assigned to the CurioCat NLI engine.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct NeurosymbolicIngestionTopologyManifest {
    #[doc = "The AI's declarative rationale for selecting this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "The W3C DID assigned to the RDF egress gateway."]
    pub archivist_node_cid: NodeCidState,
    #[doc = "The W3C DID assigned to the Docling extractor."]
    pub compiler_node_cid: NodeCidState,
    #[doc = "Target serialization format."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub egress_format: ::std::option::Option<EgressFormat>,
    #[doc = "Ties the topology to the Truth Maintenance layer."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_enforcement: ::std::option::Option<TruthMaintenancePolicy>,
    #[doc = "The W3C DID assigned to the OntoGPT resolver."]
    pub grounding_specialist_cid: NodeCidState,
    #[doc = "Cryptographic/audit justification for this topology's configuration."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The execution phase of the graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub lifecycle_phase: ::std::option::Option<LifecyclePhase>,
    #[doc = "Flat registry of all nodes in this topology."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub nodes: ::std::collections::HashMap<::std::string::String, AnyNodeProfile>,
    #[doc = "The dynamic Level of Detail physics bound to this graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub observability: ::std::option::Option<ObservabilityLodPolicy>,
    #[doc = "The structural Payload Loss Prevention (PLP) contract."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_flow: ::std::option::Option<SemanticFlowPolicy>,
    #[doc = "The schema-on-write contract governing the internal state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub shared_state_contract: ::std::option::Option<StateContract>,
    #[doc = "The genesis artifact triggering the pipeline."]
    pub source_artifact_cid: NodeCidState,
    #[doc = "Discriminator for the ingestion macro."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The W3C DID assigned to the CurioCat NLI engine."]
    pub verification_oracle_cid: NodeCidState,
}
impl NeurosymbolicIngestionTopologyManifest {
    pub fn builder() -> builder::NeurosymbolicIngestionTopologyManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A Zero-Cost Macro abstraction enforcing a strict Bipartite Graph for Proposer-Verifier loops. Isolates connectionist generation from symbolic validation and bounds cyclic computation.\n\n    CAUSAL AFFORDANCE: Instructs the orchestrator to enforce a strict Bipartite Graph for Proposer-Verifier loops.\n\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\n\n    MCP ROUTING TRIGGERS: Proposer-Verifier Loop, Bipartite Graph, Symbolic Validation, Cyclic Computation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"NeurosymbolicVerificationTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A Zero-Cost Macro abstraction enforcing a strict Bipartite Graph for Proposer-Verifier loops. Isolates connectionist generation from symbolic validation and bounds cyclic computation.\\n\\n    CAUSAL AFFORDANCE: Instructs the orchestrator to enforce a strict Bipartite Graph for Proposer-Verifier loops.\\n\\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\\n\\n    MCP ROUTING TRIGGERS: Proposer-Verifier Loop, Bipartite Graph, Symbolic Validation, Cyclic Computation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_revision_loops\","]
#[doc = "    \"nodes\","]
#[doc = "    \"proposer_node_cid\","]
#[doc = "    \"verifier_node_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"critique_schema_cid\": {"]
#[doc = "      \"title\": \"Critique Schema Cid\","]
#[doc = "      \"description\": \"A pointer to the penalty gradient structure.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"epistemic_enforcement\": {"]
#[doc = "      \"description\": \"Ties the topology to the Truth Maintenance layer.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TruthMaintenancePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this topology's configuration.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"lifecycle_phase\": {"]
#[doc = "      \"title\": \"Lifecycle Phase\","]
#[doc = "      \"description\": \"The execution phase of the graph. 'draft' allows incomplete structural state.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"draft\","]
#[doc = "        \"live\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_revision_loops\": {"]
#[doc = "      \"title\": \"Max Revision Loops\","]
#[doc = "      \"description\": \"The physical execution ceiling to solve the Halting Problem.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"nodes\": {"]
#[doc = "      \"title\": \"Nodes\","]
#[doc = "      \"description\": \"Flat registry of all nodes in this topology.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyNodeProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"observability\": {"]
#[doc = "      \"description\": \"The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ObservabilityLODPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"proposer_node_cid\": {"]
#[doc = "      \"title\": \"Proposer Node Cid\","]
#[doc = "      \"description\": \"The connectionist agent generating hypotheses.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255"]
#[doc = "    },"]
#[doc = "    \"semantic_flow\": {"]
#[doc = "      \"description\": \"The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticFlowPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"shared_state_contract\": {"]
#[doc = "      \"description\": \"The schema-on-write contract governing the internal state of this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StateContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a macro neurosymbolic loop.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"macro_neurosymbolic\""]
#[doc = "    },"]
#[doc = "    \"verifier_node_cid\": {"]
#[doc = "      \"title\": \"Verifier Node Cid\","]
#[doc = "      \"description\": \"The deterministic solver evaluating the hypotheses.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct NeurosymbolicVerificationTopologyManifest {
    #[doc = "The AI's declarative rationale for selecting this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "A pointer to the penalty gradient structure."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub critique_schema_cid: ::std::option::Option<::std::string::String>,
    #[doc = "Ties the topology to the Truth Maintenance layer."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_enforcement: ::std::option::Option<TruthMaintenancePolicy>,
    #[doc = "Cryptographic/audit justification for this topology's configuration."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The execution phase of the graph. 'draft' allows incomplete structural state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub lifecycle_phase: ::std::option::Option<LifecyclePhase>,
    #[doc = "The physical execution ceiling to solve the Halting Problem."]
    pub max_revision_loops: ::std::num::NonZeroU64,
    #[doc = "Flat registry of all nodes in this topology."]
    pub nodes: ::std::collections::HashMap<::std::string::String, AnyNodeProfile>,
    #[doc = "The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub observability: ::std::option::Option<ObservabilityLodPolicy>,
    #[doc = "The connectionist agent generating hypotheses."]
    pub proposer_node_cid: ProposerNodeCid,
    #[doc = "The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_flow: ::std::option::Option<SemanticFlowPolicy>,
    #[doc = "The schema-on-write contract governing the internal state of this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub shared_state_contract: ::std::option::Option<StateContract>,
    #[doc = "Discriminator for a macro neurosymbolic loop."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The deterministic solver evaluating the hypotheses."]
    pub verifier_node_cid: VerifierNodeCid,
}
impl NeurosymbolicVerificationTopologyManifest {
    pub fn builder() -> builder::NeurosymbolicVerificationTopologyManifest {
        Default::default()
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this semantic node to the Merkle-DAG."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Node Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this semantic node to the Merkle-DAG.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\","]
#[doc = "  \"rdf_subject\": true"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct NodeCid(::std::string::String);
impl ::std::ops::Deref for NodeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<NodeCid> for ::std::string::String {
    fn from(value: NodeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for NodeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for NodeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for NodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for NodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for NodeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Decentralized Identifier (DID) representing a cryptographically accountable principal within the swarm."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"description\": \"A Decentralized Identifier (DID) representing a cryptographically accountable principal within the swarm.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"minLength\": 7,"]
#[doc = "  \"pattern\": \"^did:[a-z0-9]+:[a-zA-Z0-9.\\\\-_:]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct NodeCidState(::std::string::String);
impl ::std::ops::Deref for NodeCidState {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<NodeCidState> for ::std::string::String {
    fn from(value: NodeCidState) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for NodeCidState {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() < 7usize {
            return Err("shorter than 7 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| {
                ::regress::Regex::new("^did:[a-z0-9]+:[a-zA-Z0-9.\\-_:]+$").unwrap()
            });
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^did:[a-z0-9]+:[a-zA-Z0-9.\\-_:]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for NodeCidState {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for NodeCidState {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for NodeCidState {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for NodeCidState {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "How to flatten SemanticNodeState."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Node Projection Mode\","]
#[doc = "  \"description\": \"How to flatten SemanticNodeState.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"wide_columnar\","]
#[doc = "    \"struct_array\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum NodeProjectionMode {
    #[serde(rename = "wide_columnar")]
    WideColumnar,
    #[serde(rename = "struct_array")]
    StructArray,
}
impl ::std::fmt::Display for NodeProjectionMode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::WideColumnar => f.write_str("wide_columnar"),
            Self::StructArray => f.write_str("struct_array"),
        }
    }
}
impl ::std::str::FromStr for NodeProjectionMode {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "wide_columnar" => Ok(Self::WideColumnar),
            "struct_array" => Ok(Self::StructArray),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for NodeProjectionMode {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for NodeProjectionMode {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for NodeProjectionMode {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The destination SemanticNodeState Content Identifier (CID)."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Object Node Cid\","]
#[doc = "  \"description\": \"The destination SemanticNodeState Content Identifier (CID).\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ObjectNodeCid(::std::string::String);
impl ::std::ops::Deref for ObjectNodeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ObjectNodeCid> for ::std::string::String {
    fn from(value: ObjectNodeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ObjectNodeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ObjectNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ObjectNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ObjectNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ObjectNodeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes the macroscopic Graph Coarsening Engine, replacing binary\nlogging with structural Dimensionality Reduction for massive topologies.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator to execute Spectral Graph Partitioning when\nthe topology exceeds the hardware rendering limit. It dynamically collapses dense subgraphs\ninto singular Hierarchical Level of Detail (HLOD) proxy meshes.\n\nEPISTEMIC BOUNDS: The vertex ceiling is rigidly bounded by max_rendered_vertices (gt=0,\nle=18446744073709551615) to physically prevent GPU VRAM exhaustion on the observer client. Binds the\nTelemetryBackpressureContract to link graph scaling with network flow.\n\nMCP ROUTING TRIGGERS: Spectral Graph Coarsening, Hierarchical Level of Detail, HLOD, Topology Collapse, VRAM Optimization"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ObservabilityLODPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes the macroscopic Graph Coarsening Engine, replacing binary\\nlogging with structural Dimensionality Reduction for massive topologies.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator to execute Spectral Graph Partitioning when\\nthe topology exceeds the hardware rendering limit. It dynamically collapses dense subgraphs\\ninto singular Hierarchical Level of Detail (HLOD) proxy meshes.\\n\\nEPISTEMIC BOUNDS: The vertex ceiling is rigidly bounded by max_rendered_vertices (gt=0,\\nle=18446744073709551615) to physically prevent GPU VRAM exhaustion on the observer client. Binds the\\nTelemetryBackpressureContract to link graph scaling with network flow.\\n\\nMCP ROUTING TRIGGERS: Spectral Graph Coarsening, Hierarchical Level of Detail, HLOD, Topology Collapse, VRAM Optimization\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_rendered_vertices\","]
#[doc = "    \"telemetry_backpressure\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"active_spatial_subscriptions\": {"]
#[doc = "      \"title\": \"Active Spatial Subscriptions\","]
#[doc = "      \"description\": \"The array of Area of Interest perimeters dictating spatial telemetry isolation.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/VolumetricPartitionState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"foveated_privacy_epsilon\": {"]
#[doc = "      \"title\": \"Foveated Privacy Epsilon\","]
#[doc = "      \"description\": \"The Laplacian noise parameter ($\\\\epsilon$) injected into the spatial telemetry for nodes residing in the meso and macro distance thresholds, preventing reverse-engineering of exact swarm weights.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_rendered_vertices\": {"]
#[doc = "      \"title\": \"Max Rendered Vertices\","]
#[doc = "      \"description\": \"The absolute physical ceiling of simultaneous causal nodes authorized to exist in the spatial projection pipeline.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"spectral_coarsening_active\": {"]
#[doc = "      \"title\": \"Spectral Coarsening Active\","]
#[doc = "      \"description\": \"Authorizes the dynamic algebraic collapse of dense node communities into single macroscopic proxy vertices when the vertex ceiling is threatened.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"telemetry_backpressure\": {"]
#[doc = "      \"description\": \"The network flow constraints mathematically bound to the observer's kinematics.\","]
#[doc = "      \"$ref\": \"#/$defs/TelemetryBackpressureContract\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ObservabilityLodPolicy {
    #[doc = "The array of Area of Interest perimeters dictating spatial telemetry isolation."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub active_spatial_subscriptions: ::std::vec::Vec<VolumetricPartitionState>,
    #[doc = "The Laplacian noise parameter ($\\epsilon$) injected into the spatial telemetry for nodes residing in the meso and macro distance thresholds, preventing reverse-engineering of exact swarm weights."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub foveated_privacy_epsilon: ::std::option::Option<f64>,
    #[doc = "The absolute physical ceiling of simultaneous causal nodes authorized to exist in the spatial projection pipeline."]
    pub max_rendered_vertices: ::std::num::NonZeroU64,
    #[doc = "Authorizes the dynamic algebraic collapse of dense node communities into single macroscopic proxy vertices when the vertex ceiling is threatened."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub spectral_coarsening_active: ::std::option::Option<bool>,
    #[doc = "The network flow constraints mathematically bound to the observer's kinematics."]
    pub telemetry_backpressure: TelemetryBackpressureContract,
}
impl ObservabilityLodPolicy {
    pub fn builder() -> builder::ObservabilityLodPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes the ingestion of Bayesian Evidence ($E$) by capturing the raw, lossless semantic output from a ToolInvocationEvent or environmental shift.\n\nCAUSAL AFFORDANCE: Injects verified exogenous truth into the EpistemicLedgerState. The payload is linked to its source via `triggering_invocation_cid`.\n\nEPISTEMIC BOUNDS: The `payload` dictionary is physically constrained against OOM exhaustion via the `@field_validator` `enforce_payload_topology`. Hardware attestation and zero-knowledge proofs provide cryptographic integrity.\n\nMCP ROUTING TRIGGERS: Bayesian Evidence, Neurosymbolic Binding, Exogenous Truth, Epistemic Grounding, Payload Topological Bounding"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ObservationEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes the ingestion of Bayesian Evidence ($E$) by capturing the raw, lossless semantic output from a ToolInvocationEvent or environmental shift.\\n\\nCAUSAL AFFORDANCE: Injects verified exogenous truth into the EpistemicLedgerState. The payload is linked to its source via `triggering_invocation_cid`.\\n\\nEPISTEMIC BOUNDS: The `payload` dictionary is physically constrained against OOM exhaustion via the `@field_validator` `enforce_payload_topology`. Hardware attestation and zero-knowledge proofs provide cryptographic integrity.\\n\\nMCP ROUTING TRIGGERS: Bayesian Evidence, Neurosymbolic Binding, Exogenous Truth, Epistemic Grounding, Payload Topological Bounding\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"payload\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"continuous_stream\": {"]
#[doc = "      \"description\": \"Buffers real-time audio/video or continuous token streams.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ContinuousObservationState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"disfluency_rules\": {"]
#[doc = "      \"description\": \"Rules for the forget gate to slice out stutters or ambient noise.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StreamingDisfluencyContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"hardware_attestation\": {"]
#[doc = "      \"description\": \"The physical hardware root-of-trust proving this observation was appended in a secure enclave.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/HardwareEnclaveReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"neural_audit\": {"]
#[doc = "      \"description\": \"The mathematical brain-scan proving exactly which neural circuits fired to append this event.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NeuralAuditAttestationReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"payload\": {"]
#[doc = "      \"title\": \"Payload\","]
#[doc = "      \"description\": \"Neurosymbolic Bindings of the raw, lossless semantic output appended from the environment or tool execution that anchor statistical probability to a definitive causal event hash. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"sensory_trigger\": {"]
#[doc = "      \"description\": \"The continuous multimodal trigger that forced this discrete observation.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EmbodiedSensoryVectorProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"source_node_cid\": {"]
#[doc = "      \"description\": \"The specific topological node that appended this observation.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"toolchain_snapshot\": {"]
#[doc = "      \"description\": \"The immutable cryptographic snapshot of the external environment at the moment of observation.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/AnyToolchainState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for an observation event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"observation\""]
#[doc = "    },"]
#[doc = "    \"triggering_invocation_cid\": {"]
#[doc = "      \"title\": \"Triggering Invocation Cid\","]
#[doc = "      \"description\": \"The deterministic capability pointer representing the specific ToolInvocationEvent that spawned this observation, forming a strict bipartite directed edge.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"zk_proof\": {"]
#[doc = "      \"description\": \"The mathematical attestation proving this observation was appended securely.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ZeroKnowledgeReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ObservationEvent {
    #[doc = "Buffers real-time audio/video or continuous token streams."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub continuous_stream: ::std::option::Option<ContinuousObservationState>,
    #[doc = "Rules for the forget gate to slice out stutters or ambient noise."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub disfluency_rules: ::std::option::Option<StreamingDisfluencyContract>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The physical hardware root-of-trust proving this observation was appended in a secure enclave."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub hardware_attestation: ::std::option::Option<HardwareEnclaveReceipt>,
    #[doc = "The mathematical brain-scan proving exactly which neural circuits fired to append this event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub neural_audit: ::std::option::Option<NeuralAuditAttestationReceipt>,
    #[doc = "Neurosymbolic Bindings of the raw, lossless semantic output appended from the environment or tool execution that anchor statistical probability to a definitive causal event hash. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    pub payload: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The continuous multimodal trigger that forced this discrete observation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub sensory_trigger: ::std::option::Option<EmbodiedSensoryVectorProfile>,
    #[doc = "The specific topological node that appended this observation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub source_node_cid: ::std::option::Option<NodeCidState>,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "The immutable cryptographic snapshot of the external environment at the moment of observation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub toolchain_snapshot: ::std::option::Option<AnyToolchainState>,
    #[doc = "Discriminator type for an observation event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The deterministic capability pointer representing the specific ToolInvocationEvent that spawned this observation, forming a strict bipartite directed edge."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub triggering_invocation_cid: ::std::option::Option<::std::string::String>,
    #[doc = "The mathematical attestation proving this observation was appended securely."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub zk_proof: ::std::option::Option<ZeroKnowledgeReceipt>,
}
impl ObservationEvent {
    pub fn builder() -> builder::ObservationEvent {
        Default::default()
    }
}
#[doc = "`ObservedVariablesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ObservedVariablesItem(::std::string::String);
impl ::std::ops::Deref for ObservedVariablesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ObservedVariablesItem> for ::std::string::String {
    fn from(value: ObservedVariablesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ObservedVariablesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ObservedVariablesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ObservedVariablesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ObservedVariablesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ObservedVariablesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Vector Space Isometry and Earth Mover's Distance\nbounds to mathematically verify semantic compatibility across disjoint neural\nmodels before allowing multi-agent graph coupling. As a ...Policy suffix, this\ndefines rigid mathematical boundaries.\n\nCAUSAL AFFORDANCE: Mechanically severs federated discovery attempts if the\nparticipating agents' internal embedding distances fall below the required\nthreshold. A fallback_state_contract (StateContract | None, default=None)\nforces agents to use canonical JSON Schemas when geometries are\nincommensurable.\n\nEPISTEMIC BOUNDS: The min_cosine_similarity is strictly clamped\n(ge=-1.0, le=1.0). The require_isometry_proof boolean (no default) enforces\nrigid projection validation prior to semantic mapping.\n\nMCP ROUTING TRIGGERS: Vector Space Isometry, Earth Mover's Distance, Latent\nSemantic Alignment, Zero-Trust Federation, Geometric Projection"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"OntologicalAlignmentPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Vector Space Isometry and Earth Mover's Distance\\nbounds to mathematically verify semantic compatibility across disjoint neural\\nmodels before allowing multi-agent graph coupling. As a ...Policy suffix, this\\ndefines rigid mathematical boundaries.\\n\\nCAUSAL AFFORDANCE: Mechanically severs federated discovery attempts if the\\nparticipating agents' internal embedding distances fall below the required\\nthreshold. A fallback_state_contract (StateContract | None, default=None)\\nforces agents to use canonical JSON Schemas when geometries are\\nincommensurable.\\n\\nEPISTEMIC BOUNDS: The min_cosine_similarity is strictly clamped\\n(ge=-1.0, le=1.0). The require_isometry_proof boolean (no default) enforces\\nrigid projection validation prior to semantic mapping.\\n\\nMCP ROUTING TRIGGERS: Vector Space Isometry, Earth Mover's Distance, Latent\\nSemantic Alignment, Zero-Trust Federation, Geometric Projection\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"min_cosine_similarity\","]
#[doc = "    \"require_isometry_proof\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"fallback_state_contract\": {"]
#[doc = "      \"description\": \"The rigid external JSON schema to force agents to use if their latent vector geometries are hopelessly incommensurable.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StateContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"min_cosine_similarity\": {"]
#[doc = "      \"title\": \"Min Cosine Similarity\","]
#[doc = "      \"description\": \"The absolute minimum latent vector similarity required to allow swarm communication.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": -1.0"]
#[doc = "    },"]
#[doc = "    \"require_isometry_proof\": {"]
#[doc = "      \"title\": \"Require Isometry Proof\","]
#[doc = "      \"description\": \"If True, the orchestrator must reject dimensional projections that fall below a safe isometry preservation score.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct OntologicalAlignmentPolicy {
    #[doc = "The rigid external JSON schema to force agents to use if their latent vector geometries are hopelessly incommensurable."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub fallback_state_contract: ::std::option::Option<StateContract>,
    #[doc = "The absolute minimum latent vector similarity required to allow swarm communication."]
    pub min_cosine_similarity: f64,
    #[doc = "If True, the orchestrator must reject dimensional projections that fall below a safe isometry preservation score."]
    pub require_isometry_proof: bool,
}
impl OntologicalAlignmentPolicy {
    pub fn builder() -> builder::OntologicalAlignmentPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A kinetic trigger instructing the orchestrator to route an array of ungrounded text entities through a grounding oracle (OntoGPT/OAK) to map them to formal ontology CURIEs.\n\nCAUSAL AFFORDANCE: Authorizes the runtime to execute Bipartite Ontological Mapping, collapsing high-entropy natural language strings into zero-entropy Semantic Web identifiers.\n\nEPISTEMIC BOUNDS: The search space is rigidly clamped by the `target_ontology_registries` array (e.g., ['MONDO', 'HP']). The `minimum_isometry_threshold` physically restricts acceptable mappings to a strictly positive cosine/BM25 similarity (`ge=0.0, le=1.0`).\n\nMCP ROUTING TRIGGERS: Bipartite Ontological Mapping, Grounding Oracle, CURIE Resolution, Isometry Thresholding, Semantic Crosswalk"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"OntologicalCrosswalkIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A kinetic trigger instructing the orchestrator to route an array of ungrounded text entities through a grounding oracle (OntoGPT/OAK) to map them to formal ontology CURIEs.\\n\\nCAUSAL AFFORDANCE: Authorizes the runtime to execute Bipartite Ontological Mapping, collapsing high-entropy natural language strings into zero-entropy Semantic Web identifiers.\\n\\nEPISTEMIC BOUNDS: The search space is rigidly clamped by the `target_ontology_registries` array (e.g., ['MONDO', 'HP']). The `minimum_isometry_threshold` physically restricts acceptable mappings to a strictly positive cosine/BM25 similarity (`ge=0.0, le=1.0`).\\n\\nMCP ROUTING TRIGGERS: Bipartite Ontological Mapping, Grounding Oracle, CURIE Resolution, Isometry Thresholding, Semantic Crosswalk\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"minimum_isometry_threshold\","]
#[doc = "    \"source_strings\","]
#[doc = "    \"target_graph_cid\","]
#[doc = "    \"target_ontology_registries\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"minimum_isometry_threshold\": {"]
#[doc = "      \"title\": \"Minimum Isometry Threshold\","]
#[doc = "      \"description\": \"The semantic distance threshold required to automatically accept a mapping.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"source_strings\": {"]
#[doc = "      \"title\": \"Source Strings\","]
#[doc = "      \"description\": \"The ungrounded natural language concepts extracted by the LLM.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"target_graph_cid\": {"]
#[doc = "      \"title\": \"Target Graph Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_ontology_registries\": {"]
#[doc = "      \"title\": \"Target Ontology Registries\","]
#[doc = "      \"description\": \"The strictly typed standard ontology namespaces to search (e.g., 'MONDO', 'CHEBI').\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"ontological_crosswalk\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct OntologicalCrosswalkIntent {
    #[doc = "The semantic distance threshold required to automatically accept a mapping."]
    pub minimum_isometry_threshold: f64,
    #[doc = "The ungrounded natural language concepts extracted by the LLM."]
    pub source_strings: ::std::vec::Vec<SourceStringsItem>,
    pub target_graph_cid: TargetGraphCid,
    #[doc = "The strictly typed standard ontology namespaces to search (e.g., 'MONDO', 'CHEBI')."]
    pub target_ontology_registries: ::std::vec::Vec<TargetOntologyRegistriesItem>,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl OntologicalCrosswalkIntent {
    pub fn builder() -> builder::OntologicalCrosswalkIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A non-monotonic hypothesis requesting the transformation of unstructured or dirty public data into a pristine, mathematically bounded resource.\n\nCAUSAL AFFORDANCE: Triggers the execution of proprietary ETL and semantic vectorization pipelines within the sovereign VPC.\n\nEPISTEMIC BOUNDS: Forces absolute structural isomorphism by demanding that the resulting artifact perfectly matches the geometries declared in the target_ontology_urn. URN is clamped to 2000 chars.\n\nMCP ROUTING TRIGGERS: Semantic Crosswalk, ETL Pipeline, Data Normalization, Knowledge Graph Extraction"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"OntologicalNormalizationIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A non-monotonic hypothesis requesting the transformation of unstructured or dirty public data into a pristine, mathematically bounded resource.\\n\\nCAUSAL AFFORDANCE: Triggers the execution of proprietary ETL and semantic vectorization pipelines within the sovereign VPC.\\n\\nEPISTEMIC BOUNDS: Forces absolute structural isomorphism by demanding that the resulting artifact perfectly matches the geometries declared in the target_ontology_urn. URN is clamped to 2000 chars.\\n\\nMCP ROUTING TRIGGERS: Semantic Crosswalk, ETL Pipeline, Data Normalization, Knowledge Graph Extraction\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"source_artifact_cid\","]
#[doc = "    \"target_ontology_urn\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"source_artifact_cid\": {"]
#[doc = "      \"title\": \"Source Artifact Cid\","]
#[doc = "      \"description\": \"The Content Identifier (CID) of the raw ingested data artifact.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_ontology_urn\": {"]
#[doc = "      \"title\": \"Target Ontology Urn\","]
#[doc = "      \"description\": \"The formal URN declaring the target ontological geometry for structural isomorphism.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000,"]
#[doc = "      \"pattern\": \"^urn:coreason:ontology:.*$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for the OntologicalNormalizationIntent topology.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"ontological_normalization\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct OntologicalNormalizationIntent {
    #[doc = "The Content Identifier (CID) of the raw ingested data artifact."]
    pub source_artifact_cid: SourceArtifactCid,
    #[doc = "The formal URN declaring the target ontological geometry for structural isomorphism."]
    pub target_ontology_urn: TargetOntologyUrn,
    #[doc = "Discriminator for the OntologicalNormalizationIntent topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl OntologicalNormalizationIntent {
    pub fn builder() -> builder::OntologicalNormalizationIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: An append-only, cryptographically frozen coordinate verifying the integrity of a generalized bimodal semantic transformation. Commits the transformation mechanism to the Epistemic Ledger, physically separating explicit empirical facts from machine-inferred hypotheses to eliminate traceability collapse.\n\n    CAUSAL AFFORDANCE: Physically authorizes the orchestrator to commit the transformation mechanism to the Epistemic Ledger.\n\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\n\n    MCP ROUTING TRIGGERS: Ontological Reification, Bimodal Semantic Transformation, Epistemic Ledger, Traceability Collapse"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"OntologicalReificationReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: An append-only, cryptographically frozen coordinate verifying the integrity of a generalized bimodal semantic transformation. Commits the transformation mechanism to the Epistemic Ledger, physically separating explicit empirical facts from machine-inferred hypotheses to eliminate traceability collapse.\\n\\n    CAUSAL AFFORDANCE: Physically authorizes the orchestrator to commit the transformation mechanism to the Epistemic Ledger.\\n\\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\\n\\n    MCP ROUTING TRIGGERS: Ontological Reification, Bimodal Semantic Transformation, Epistemic Ledger, Traceability Collapse\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"algorithmic_mechanism\","]
#[doc = "    \"belief_vector\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"source_data_hash\","]
#[doc = "    \"target_namespace\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"algorithmic_mechanism\": {"]
#[doc = "      \"description\": \"The deterministic or probabilistic engine used to execute the transmutation.\","]
#[doc = "      \"$ref\": \"#/$defs/TransformationMechanismProfile\""]
#[doc = "    },"]
#[doc = "    \"belief_vector\": {"]
#[doc = "      \"description\": \"The composite Dempster-Shafer tri-vector capturing independent confidence dimensions and calculated epistemic conflict.\","]
#[doc = "      \"$ref\": \"#/$defs/DempsterShaferBeliefVector\""]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"Cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"is_latent_inference\": {"]
#[doc = "      \"title\": \"Is Latent Inference\","]
#[doc = "      \"description\": \"CRITICAL: Explicit flag required if the edge or node was generated by an AI reasoning agent via transitive closure or abduction rather than extracted as an explicit empirical fact. Eliminates hallucinations of certainty.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The RFC 8785 Canonical hash of the immediate causal ancestor.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"source_data_hash\": {"]
#[doc = "      \"title\": \"Source Data Hash\","]
#[doc = "      \"description\": \"The undeniable SHA-256 hash of the pre-transmutation artifact, unstructured text chunk, or telemetry row.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"target_namespace\": {"]
#[doc = "      \"title\": \"Target Namespace\","]
#[doc = "      \"description\": \"The standardized semantic ontology namespace the data was projected into.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"The precise temporal coordinate of the event realization.\","]
#[doc = "      \"type\": \"number\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for the reification receipt.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"ontological_reification\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct OntologicalReificationReceipt {
    #[doc = "The deterministic or probabilistic engine used to execute the transmutation."]
    pub algorithmic_mechanism: TransformationMechanismProfile,
    #[doc = "The composite Dempster-Shafer tri-vector capturing independent confidence dimensions and calculated epistemic conflict."]
    pub belief_vector: DempsterShaferBeliefVector,
    #[doc = "Cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "CRITICAL: Explicit flag required if the edge or node was generated by an AI reasoning agent via transitive closure or abduction rather than extracted as an explicit empirical fact. Eliminates hallucinations of certainty."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub is_latent_inference: ::std::option::Option<bool>,
    #[doc = "The RFC 8785 Canonical hash of the immediate causal ancestor."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The undeniable SHA-256 hash of the pre-transmutation artifact, unstructured text chunk, or telemetry row."]
    pub source_data_hash: SourceDataHash,
    #[doc = "The standardized semantic ontology namespace the data was projected into."]
    pub target_namespace: TargetNamespace,
    #[doc = "The precise temporal coordinate of the event realization."]
    pub timestamp: f64,
    #[doc = "Discriminator for the reification receipt."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl OntologicalReificationReceipt {
    pub fn builder() -> builder::OntologicalReificationReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes a Bipartite Graph Projection of Gibsonian Affordances, establishing the mathematically bounded subgraph of all capabilities currently valid for the agent.\n\nCAUSAL AFFORDANCE: Injects a dynamic Action Space manifold into the agent's working memory, authorizing the invocation of strictly defined toolsets and procedural manifolds.\n\nEPISTEMIC BOUNDS: Structural integrity is mathematically guaranteed by the `@model_validator`, which enforces unique `action_space_cids` and deterministically sorts `action_spaces`, `supported_personas`, and `available_procedural_manifolds` by their CIDs, ensuring invariant RFC 8785 hashing.\n\nMCP ROUTING TRIGGERS: Gibsonian Affordances, Bipartite Graph Projection, Action Space Manifold, RFC 8785 Canonicalization, Holographic Subgraph"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"OntologicalSurfaceProjectionManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes a Bipartite Graph Projection of Gibsonian Affordances, establishing the mathematically bounded subgraph of all capabilities currently valid for the agent.\\n\\nCAUSAL AFFORDANCE: Injects a dynamic Action Space manifold into the agent's working memory, authorizing the invocation of strictly defined toolsets and procedural manifolds.\\n\\nEPISTEMIC BOUNDS: Structural integrity is mathematically guaranteed by the `@model_validator`, which enforces unique `action_space_cids` and deterministically sorts `action_spaces`, `supported_personas`, and `available_procedural_manifolds` by their CIDs, ensuring invariant RFC 8785 hashing.\\n\\nMCP ROUTING TRIGGERS: Gibsonian Affordances, Bipartite Graph Projection, Action Space Manifold, RFC 8785 Canonicalization, Holographic Subgraph\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"projection_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"action_spaces\": {"]
#[doc = "      \"title\": \"Action Spaces\","]
#[doc = "      \"description\": \"The full, machine-readable declaration of accessible tools and MCP servers.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/CognitiveActionSpaceManifest\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"available_procedural_manifolds\": {"]
#[doc = "      \"title\": \"Available Procedural Manifolds\","]
#[doc = "      \"description\": \"The lightweight progressive disclosure tier for procedural skills.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/ProceduralMetadataManifest\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"projection_cid\": {"]
#[doc = "      \"title\": \"Projection Cid\","]
#[doc = "      \"description\": \"A cryptographic Lineage Watermark bounding this specific capability set.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"supported_personas\": {"]
#[doc = "      \"title\": \"Supported Personas\","]
#[doc = "      \"description\": \"The strict array of foundational model personas available.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/ProfileCIDState\""]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct OntologicalSurfaceProjectionManifest {
    #[doc = "The full, machine-readable declaration of accessible tools and MCP servers."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub action_spaces: ::std::vec::Vec<CognitiveActionSpaceManifest>,
    #[doc = "The lightweight progressive disclosure tier for procedural skills."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub available_procedural_manifolds: ::std::vec::Vec<ProceduralMetadataManifest>,
    #[doc = "A cryptographic Lineage Watermark bounding this specific capability set."]
    pub projection_cid: ProjectionCid,
    #[doc = "The strict array of foundational model personas available."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub supported_personas: ::std::vec::Vec<ProfileCidState>,
}
impl OntologicalSurfaceProjectionManifest {
    pub fn builder() -> builder::OntologicalSurfaceProjectionManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Authorizes a Semantic Watchdog Agent to perform strict out-of-band polling against external semantic registries to monitor for ontological deprecation or semantic drift."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"OntologyDiscoveryIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Authorizes a Semantic Watchdog Agent to perform strict out-of-band polling against external semantic registries to monitor for ontological deprecation or semantic drift.\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"jsonrpc\","]
#[doc = "    \"method\","]
#[doc = "    \"query_concept_cid\","]
#[doc = "    \"target_registry_uri\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"expected_response_schema\": {"]
#[doc = "      \"title\": \"Expected Response Schema\","]
#[doc = "      \"description\": \"Optional strict schema expected from the external RDF/OWL registry.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"object\","]
#[doc = "          \"additionalProperties\": {"]
#[doc = "            \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"id\": {"]
#[doc = "      \"title\": \"Id\","]
#[doc = "      \"description\": \"Unique request identifier.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"jsonrpc\": {"]
#[doc = "      \"title\": \"Jsonrpc\","]
#[doc = "      \"description\": \"JSON-RPC version.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"2.0\""]
#[doc = "    },"]
#[doc = "    \"method\": {"]
#[doc = "      \"title\": \"Method\","]
#[doc = "      \"description\": \"Method to be invoked.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 1000"]
#[doc = "    },"]
#[doc = "    \"params\": {"]
#[doc = "      \"title\": \"Params\","]
#[doc = "      \"description\": \"Payload parameters. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"object\","]
#[doc = "          \"maxProperties\": 86400000,"]
#[doc = "          \"additionalProperties\": {"]
#[doc = "            \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"query_concept_cid\": {"]
#[doc = "      \"title\": \"Query Concept Cid\","]
#[doc = "      \"description\": \"The internal standard CID the agent is checking for deprecation or semantic drift.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_registry_uri\": {"]
#[doc = "      \"title\": \"Target Registry Uri\","]
#[doc = "      \"description\": \"The standard ontology registry endpoint (e.g., EBI-OLS, BioPortal).\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"format\": \"uri\","]
#[doc = "      \"maxLength\": 2083,"]
#[doc = "      \"minLength\": 1"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for external ontology polling.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"ontology_discovery\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct OntologyDiscoveryIntent {
    #[doc = "Optional strict schema expected from the external RDF/OWL registry."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub expected_response_schema: ::std::option::Option<
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    >,
    #[doc = "Unique request identifier."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub id: ::std::option::Option<Id>,
    #[doc = "JSON-RPC version."]
    pub jsonrpc: ::std::string::String,
    #[doc = "Method to be invoked."]
    pub method: Method,
    #[doc = "Payload parameters. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub params: ::std::option::Option<
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    >,
    #[doc = "The internal standard CID the agent is checking for deprecation or semantic drift."]
    pub query_concept_cid: QueryConceptCid,
    #[doc = "The standard ontology registry endpoint (e.g., EBI-OLS, BioPortal)."]
    pub target_registry_uri: ::std::string::String,
    #[doc = "Discriminator for external ontology polling."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl OntologyDiscoveryIntent {
    pub fn builder() -> builder::OntologyDiscoveryIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Guarantee isomorphic data translation from untrusted MCP payloads into the swarm's working memory.\nCAUSAL AFFORDANCE: Verifies that the geometric shape of the payload perfectly satisfies the expected contravariant input of the target node without executing procedural mapping code.\nEPISTEMIC BOUNDS: The `lens_source_pointer` and `prism_target_pointer` mathematically lock to max_length=2000. `strict_isomorphism` forbids type coercion.\nMCP ROUTING TRIGGERS: Category Theory, Profunctor Optics, Lens, Prism, Isomorphic State Synchronization"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"OpticalMappingContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Guarantee isomorphic data translation from untrusted MCP payloads into the swarm's working memory.\\nCAUSAL AFFORDANCE: Verifies that the geometric shape of the payload perfectly satisfies the expected contravariant input of the target node without executing procedural mapping code.\\nEPISTEMIC BOUNDS: The `lens_source_pointer` and `prism_target_pointer` mathematically lock to max_length=2000. `strict_isomorphism` forbids type coercion.\\nMCP ROUTING TRIGGERS: Category Theory, Profunctor Optics, Lens, Prism, Isomorphic State Synchronization\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"lens_source_pointer\","]
#[doc = "    \"prism_target_pointer\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"lens_source_pointer\": {"]
#[doc = "      \"title\": \"Lens Source Pointer\","]
#[doc = "      \"description\": \"RFC 6902 JSON Pointer extracting exogenous data.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"prism_target_pointer\": {"]
#[doc = "      \"title\": \"Prism Target Pointer\","]
#[doc = "      \"description\": \"RFC 6902 JSON Pointer for exact injection coordinate.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"strict_isomorphism\": {"]
#[doc = "      \"title\": \"Strict Isomorphism\","]
#[doc = "      \"description\": \"If true, mathematically forbids type coercion.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct OpticalMappingContract {
    #[doc = "RFC 6902 JSON Pointer extracting exogenous data."]
    pub lens_source_pointer: LensSourcePointer,
    #[doc = "RFC 6902 JSON Pointer for exact injection coordinate."]
    pub prism_target_pointer: PrismTargetPointer,
    #[doc = "If true, mathematically forbids type coercion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub strict_isomorphism: ::std::option::Option<bool>,
}
impl OpticalMappingContract {
    pub fn builder() -> builder::OpticalMappingContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes the hardware and thermodynamic boundaries for the Docling vision models, dictating the deployment of Real-Time Detection Transformers (RT-DETR).\n\nCAUSAL AFFORDANCE: Physically acts as a computational throttle, authorizing the orchestrator to deploy expensive pixel-level Optical Character Recognition (OCR) and Table Structure Recognition (TSR) models over standard byte-extraction.\n\nEPISTEMIC BOUNDS: The `bitmap_dpi_resolution` is physically clamped to `ge=72, le=600` to mathematically prevent VRAM memory bombs on oversized, high-density raster images.\n\nMCP ROUTING TRIGGERS: Optical Thermodynamic Bounding, RT-DETR, VRAM Throttling, LayoutLMv3, Hardware Guillotine"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"OpticalParsingSLA\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes the hardware and thermodynamic boundaries for the Docling vision models, dictating the deployment of Real-Time Detection Transformers (RT-DETR).\\n\\nCAUSAL AFFORDANCE: Physically acts as a computational throttle, authorizing the orchestrator to deploy expensive pixel-level Optical Character Recognition (OCR) and Table Structure Recognition (TSR) models over standard byte-extraction.\\n\\nEPISTEMIC BOUNDS: The `bitmap_dpi_resolution` is physically clamped to `ge=72, le=600` to mathematically prevent VRAM memory bombs on oversized, high-density raster images.\\n\\nMCP ROUTING TRIGGERS: Optical Thermodynamic Bounding, RT-DETR, VRAM Throttling, LayoutLMv3, Hardware Guillotine\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"properties\": {"]
#[doc = "    \"bitmap_dpi_resolution\": {"]
#[doc = "      \"title\": \"Bitmap Dpi Resolution\","]
#[doc = "      \"description\": \"The strict maximum spatial resolution authorized for rendering rasterized tensors.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 600.0,"]
#[doc = "      \"minimum\": 72.0"]
#[doc = "    },"]
#[doc = "    \"force_ocr\": {"]
#[doc = "      \"title\": \"Force Ocr\","]
#[doc = "      \"description\": \"Boolean gate authorizing deep optical evaluation when native PDF byte-extraction fails.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"table_structure_recognition\": {"]
#[doc = "      \"title\": \"Table Structure Recognition\","]
#[doc = "      \"description\": \"Authorizes the deployment of dense bipartite mapping models (e.g., TableFormer) over tabular grids.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct OpticalParsingSla {
    #[doc = "The strict maximum spatial resolution authorized for rendering rasterized tensors."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub bitmap_dpi_resolution: ::std::option::Option<i64>,
    #[doc = "Boolean gate authorizing deep optical evaluation when native PDF byte-extraction fails."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub force_ocr: ::std::option::Option<bool>,
    #[doc = "Authorizes the deployment of dense bipartite mapping models (e.g., TableFormer) over tabular grids."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub table_structure_recognition: ::std::option::Option<bool>,
}
impl ::std::default::Default for OpticalParsingSla {
    fn default() -> Self {
        Self {
            bitmap_dpi_resolution: Default::default(),
            force_ocr: Default::default(),
            table_structure_recognition: Default::default(),
        }
    }
}
impl OpticalParsingSla {
    pub fn builder() -> builder::OpticalParsingSla {
        Default::default()
    }
}
#[doc = "`OptimizationDirectionProfile`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"maximize\","]
#[doc = "    \"minimize\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum OptimizationDirectionProfile {
    #[serde(rename = "maximize")]
    Maximize,
    #[serde(rename = "minimize")]
    Minimize,
}
impl ::std::fmt::Display for OptimizationDirectionProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Maximize => f.write_str("maximize"),
            Self::Minimize => f.write_str("minimize"),
        }
    }
}
impl ::std::str::FromStr for OptimizationDirectionProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "maximize" => Ok(Self::Maximize),
            "minimize" => Ok(Self::Minimize),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for OptimizationDirectionProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for OptimizationDirectionProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for OptimizationDirectionProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A cryptographically frozen historical fact attesting that a specific solver agent executed a task within the Claw Swarm. This receipt is immutable and logged in the Merkle-DAG chain of custody. Do not attempt to mutate this object.\n\nCAUSAL AFFORDANCE: Unlocks downstream neurosymbolic synthesis by proving that external epistemic grounding was securely retrieved and executed by a validated solver. The `execution_hash` provides undeniable cryptographic provenance for audit trails. The `tokens_burned` enables the Thermodynamic Quota Manager to settle compute costs.\n\nEPISTEMIC BOUNDS: The `execution_hash` is strictly bounded to exactly 64 hexadecimal characters (SHA-256). The `solver_urn` is anchored to the `urn:coreason:solver:` namespace. The `tokens_burned` is bounded to `[0, 10_000_000]` to prevent integer overflow during thermodynamic tallying. The `human_attestation_signature` is optional and only populated when a Human-in-the-Loop (HITL) operator cryptographically signs off on the execution result.\n\nMCP ROUTING TRIGGERS: Execution Audit, Merkle-DAG Provenance, Thermodynamic Accounting, Oracle Telemetry, Human-in-the-Loop Attestation, Cryptographic Receipt"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"OracleExecutionReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A cryptographically frozen historical fact attesting that a specific solver agent executed a task within the Claw Swarm. This receipt is immutable and logged in the Merkle-DAG chain of custody. Do not attempt to mutate this object.\\n\\nCAUSAL AFFORDANCE: Unlocks downstream neurosymbolic synthesis by proving that external epistemic grounding was securely retrieved and executed by a validated solver. The `execution_hash` provides undeniable cryptographic provenance for audit trails. The `tokens_burned` enables the Thermodynamic Quota Manager to settle compute costs.\\n\\nEPISTEMIC BOUNDS: The `execution_hash` is strictly bounded to exactly 64 hexadecimal characters (SHA-256). The `solver_urn` is anchored to the `urn:coreason:solver:` namespace. The `tokens_burned` is bounded to `[0, 10_000_000]` to prevent integer overflow during thermodynamic tallying. The `human_attestation_signature` is optional and only populated when a Human-in-the-Loop (HITL) operator cryptographically signs off on the execution result.\\n\\nMCP ROUTING TRIGGERS: Execution Audit, Merkle-DAG Provenance, Thermodynamic Accounting, Oracle Telemetry, Human-in-the-Loop Attestation, Cryptographic Receipt\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"execution_hash\","]
#[doc = "    \"solver_urn\","]
#[doc = "    \"tokens_burned\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"execution_hash\": {"]
#[doc = "      \"title\": \"Execution Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the complete execution payload, providing undeniable cryptographic provenance for the Merkle-DAG audit trail.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"human_attestation_signature\": {"]
#[doc = "      \"title\": \"Human Attestation Signature\","]
#[doc = "      \"description\": \"An optional cryptographic signature from a Human-in-the-Loop (HITL) operator attesting to the correctness of the execution result. Populated only when the Temporal workflow escalates to manual review.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"solver_urn\": {"]
#[doc = "      \"title\": \"Solver Urn\","]
#[doc = "      \"description\": \"The fully qualified URN of the solver agent that performed the execution.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^urn:coreason:solver:.*$\""]
#[doc = "    },"]
#[doc = "    \"tokens_burned\": {"]
#[doc = "      \"title\": \"Tokens Burned\","]
#[doc = "      \"description\": \"The total number of tokens consumed during this execution, settled by the Thermodynamic Quota Manager.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 10000000.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for the OracleExecutionReceipt topology.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"oracle_execution_receipt\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct OracleExecutionReceipt {
    #[doc = "The SHA-256 hash of the complete execution payload, providing undeniable cryptographic provenance for the Merkle-DAG audit trail."]
    pub execution_hash: ExecutionHash,
    #[doc = "An optional cryptographic signature from a Human-in-the-Loop (HITL) operator attesting to the correctness of the execution result. Populated only when the Temporal workflow escalates to manual review."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub human_attestation_signature: ::std::option::Option<::std::string::String>,
    #[doc = "The fully qualified URN of the solver agent that performed the execution."]
    pub solver_urn: SolverUrn,
    #[doc = "The total number of tokens consumed during this execution, settled by the Thermodynamic Quota Manager."]
    pub tokens_burned: i64,
    #[doc = "Discriminator for the OracleExecutionReceipt topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl OracleExecutionReceipt {
    pub fn builder() -> builder::OracleExecutionReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes a contravariant Functor (Category Theory) or\nFunctional Lens, extracting terminal coordinate shifts from a nested subgraph\nback into the parent's topological state. As a ...Contract suffix, this enforces\nrigid mathematical boundaries globally.\n\nCAUSAL AFFORDANCE: Authorizes the mutation of the macroscopic\nshared_state_contract using precisely mapped structural returns from a\ncompleted CompositeNodeProfile execution, guaranteeing side-effect-free state\nbubbling.\n\nEPISTEMIC BOUNDS: The routing paths child_key and parent_key are physically\nbounded by max_length=2000 to prevent memory allocation faults and pointer\noverflow during the orchestrator's post-execution dictionary merge operations.\n\nMCP ROUTING TRIGGERS: Functional Lens, Contravariant Functor, State Bubbling,\nSide-Effect Free Mutation, Graph Isomorphism"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"OutputMappingContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes a contravariant Functor (Category Theory) or\\nFunctional Lens, extracting terminal coordinate shifts from a nested subgraph\\nback into the parent's topological state. As a ...Contract suffix, this enforces\\nrigid mathematical boundaries globally.\\n\\nCAUSAL AFFORDANCE: Authorizes the mutation of the macroscopic\\nshared_state_contract using precisely mapped structural returns from a\\ncompleted CompositeNodeProfile execution, guaranteeing side-effect-free state\\nbubbling.\\n\\nEPISTEMIC BOUNDS: The routing paths child_key and parent_key are physically\\nbounded by max_length=2000 to prevent memory allocation faults and pointer\\noverflow during the orchestrator's post-execution dictionary merge operations.\\n\\nMCP ROUTING TRIGGERS: Functional Lens, Contravariant Functor, State Bubbling,\\nSide-Effect Free Mutation, Graph Isomorphism\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"child_key\","]
#[doc = "    \"parent_key\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"child_key\": {"]
#[doc = "      \"title\": \"Child Key\","]
#[doc = "      \"description\": \"The key in the nested topology's state contract.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"parent_key\": {"]
#[doc = "      \"title\": \"Parent Key\","]
#[doc = "      \"description\": \"The mapped key in the parent's shared state contract.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct OutputMappingContract {
    #[doc = "The key in the nested topology's state contract."]
    pub child_key: ChildKey,
    #[doc = "The mapped key in the parent's shared state contract."]
    pub parent_key: ParentKey,
}
impl OutputMappingContract {
    pub fn builder() -> builder::OutputMappingContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A Dictatorial Byzantine Fault Resolution mechanism. It is an absolute, zero-trust kinetic override that violently preempts autonomous algorithmic consensus or prediction market resolution.\n\nCAUSAL AFFORDANCE: Forces an absolute Pearlian do-operator intervention ($do(X=x)$). Physically shatters the active causal chain of the `target_node_cid` and forcibly injects the `override_action` payload into the state vector, bypassing decentralized voting.\n\nEPISTEMIC BOUNDS: The blast radius is strictly confined to the `target_node_cid`. The orchestrator must mathematically verify the `authorized_node_cid` against the highest-tier W3C DID enterprise clearance before allowing the payload to overwrite the Epistemic Blackboard (`override_action` bounded `max_length=1000`).\n\nMCP ROUTING TRIGGERS: Dictatorial Override, Byzantine Fault Resolution, Pearlian Intervention, Causal Shattering, Zero-Trust Override"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"OverrideIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A Dictatorial Byzantine Fault Resolution mechanism. It is an absolute, zero-trust kinetic override that violently preempts autonomous algorithmic consensus or prediction market resolution.\\n\\nCAUSAL AFFORDANCE: Forces an absolute Pearlian do-operator intervention ($do(X=x)$). Physically shatters the active causal chain of the `target_node_cid` and forcibly injects the `override_action` payload into the state vector, bypassing decentralized voting.\\n\\nEPISTEMIC BOUNDS: The blast radius is strictly confined to the `target_node_cid`. The orchestrator must mathematically verify the `authorized_node_cid` against the highest-tier W3C DID enterprise clearance before allowing the payload to overwrite the Epistemic Blackboard (`override_action` bounded `max_length=1000`).\\n\\nMCP ROUTING TRIGGERS: Dictatorial Override, Byzantine Fault Resolution, Pearlian Intervention, Causal Shattering, Zero-Trust Override\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"authorized_node_cid\","]
#[doc = "    \"justification\","]
#[doc = "    \"override_action\","]
#[doc = "    \"target_node_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"authorized_node_cid\": {"]
#[doc = "      \"description\": \"The NodeCIDState of the human or agent executing the override.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic audit justification for bypassing algorithmic consensus.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"override_action\": {"]
#[doc = "      \"title\": \"Override Action\","]
#[doc = "      \"description\": \"The exact payload forcefully injected into the state.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"description\": \"The NodeCIDState being forcefully overridden.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The type of the intervention payload.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"override\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct OverrideIntent {
    #[doc = "The NodeCIDState of the human or agent executing the override."]
    pub authorized_node_cid: NodeCidState,
    #[doc = "Cryptographic audit justification for bypassing algorithmic consensus."]
    pub justification: Justification,
    #[doc = "The exact payload forcefully injected into the state."]
    pub override_action: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "The NodeCIDState being forcefully overridden."]
    pub target_node_cid: NodeCidState,
    #[doc = "The type of the intervention payload."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl OverrideIntent {
    pub fn builder() -> builder::OverrideIntent {
        Default::default()
    }
}
#[doc = "The unique identifier for this UI panel."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Panel Cid\","]
#[doc = "  \"description\": \"The unique identifier for this UI panel.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PanelCid(::std::string::String);
impl ::std::ops::Deref for PanelCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PanelCid> for ::std::string::String {
    fn from(value: PanelCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PanelCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PanelCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PanelCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PanelCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PanelCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The key in the parent's shared state contract."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Parent Key\","]
#[doc = "  \"description\": \"The key in the parent's shared state contract.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ParentKey(::std::string::String);
impl ::std::ops::Deref for ParentKey {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ParentKey> for ::std::string::String {
    fn from(value: ParentKey) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ParentKey {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ParentKey {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ParentKey {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ParentKey {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ParentKey {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SHA-256 hash of the parent thought node in the MCTS tree, establishing Merkle-DAG lineage. For root nodes, use the SHA-256 hash of the initial escalation intent."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Parent Node Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the parent thought node in the MCTS tree, establishing Merkle-DAG lineage. For root nodes, use the SHA-256 hash of the initial escalation intent.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ParentNodeHash(::std::string::String);
impl ::std::ops::Deref for ParentNodeHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ParentNodeHash> for ::std::string::String {
    fn from(value: ParentNodeHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ParentNodeHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ParentNodeHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ParentNodeHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ParentNodeHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ParentNodeHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`ParticipantNodeCidsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ParticipantNodeCidsItem(::std::string::String);
impl ::std::ops::Deref for ParticipantNodeCidsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ParticipantNodeCidsItem> for ::std::string::String {
    fn from(value: ParticipantNodeCidsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ParticipantNodeCidsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ParticipantNodeCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ParticipantNodeCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ParticipantNodeCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ParticipantNodeCidsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Unique identifier for this ephemeral partition."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Partition Cid\","]
#[doc = "  \"description\": \"Unique identifier for this ephemeral partition.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PartitionCid(::std::string::String);
impl ::std::ops::Deref for PartitionCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PartitionCid> for ::std::string::String {
    fn from(value: PartitionCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PartitionCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PartitionCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PartitionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PartitionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PartitionCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`PatchOperationProfile`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"add\","]
#[doc = "    \"remove\","]
#[doc = "    \"replace\","]
#[doc = "    \"copy\","]
#[doc = "    \"move\","]
#[doc = "    \"test\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum PatchOperationProfile {
    #[serde(rename = "add")]
    Add,
    #[serde(rename = "remove")]
    Remove,
    #[serde(rename = "replace")]
    Replace,
    #[serde(rename = "copy")]
    Copy,
    #[serde(rename = "move")]
    Move,
    #[serde(rename = "test")]
    Test,
}
impl ::std::fmt::Display for PatchOperationProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Add => f.write_str("add"),
            Self::Remove => f.write_str("remove"),
            Self::Replace => f.write_str("replace"),
            Self::Copy => f.write_str("copy"),
            Self::Move => f.write_str("move"),
            Self::Test => f.write_str("test"),
        }
    }
}
impl ::std::str::FromStr for PatchOperationProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "add" => Ok(Self::Add),
            "remove" => Ok(Self::Remove),
            "replace" => Ok(Self::Replace),
            "copy" => Ok(Self::Copy),
            "move" => Ok(Self::Move),
            "test" => Ok(Self::Test),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for PatchOperationProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PatchOperationProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PatchOperationProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The JSON pointer indicating the exact state vector to mutate deterministically."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Path\","]
#[doc = "  \"description\": \"The JSON pointer indicating the exact state vector to mutate deterministically.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Path(::std::string::String);
impl ::std::ops::Deref for Path {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Path> for ::std::string::String {
    fn from(value: Path) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Path {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Path {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Path {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Path {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Path {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Low-Rank Adaptation (LoRA) and Matrix Factorization to dynamically project parameter-efficient weight matrices into the base model's computation graph.\n\nCAUSAL AFFORDANCE: Instructs the inference engine to dynamically hot-swap targeted attention modules via `target_modules`, altering the network's forward-pass physics without mutating the frozen foundation weights.\n\nEPISTEMIC BOUNDS: VRAM allocation strictly clamped by the intrinsic rank parameter `adapter_rank` (`gt=0, le=18446744073709551615`), physically preventing petabyte-scale matrix instantiations and OOM faults. `target_modules` array deterministically sorted via `@model_validator`.\n\nMCP ROUTING TRIGGERS: Low-Rank Adaptation, Matrix Factorization, LoRA, GPU VRAM Allocation, Attention Head Injection"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"PeftAdapterContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Low-Rank Adaptation (LoRA) and Matrix Factorization to dynamically project parameter-efficient weight matrices into the base model's computation graph.\\n\\nCAUSAL AFFORDANCE: Instructs the inference engine to dynamically hot-swap targeted attention modules via `target_modules`, altering the network's forward-pass physics without mutating the frozen foundation weights.\\n\\nEPISTEMIC BOUNDS: VRAM allocation strictly clamped by the intrinsic rank parameter `adapter_rank` (`gt=0, le=18446744073709551615`), physically preventing petabyte-scale matrix instantiations and OOM faults. `target_modules` array deterministically sorted via `@model_validator`.\\n\\nMCP ROUTING TRIGGERS: Low-Rank Adaptation, Matrix Factorization, LoRA, GPU VRAM Allocation, Attention Head Injection\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"adapter_cid\","]
#[doc = "    \"adapter_rank\","]
#[doc = "    \"base_model_hash\","]
#[doc = "    \"safetensors_hash\","]
#[doc = "    \"target_modules\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"adapter_cid\": {"]
#[doc = "      \"title\": \"Adapter Cid\","]
#[doc = "      \"description\": \"Unique identifier for the requested LoRA adapter.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"adapter_rank\": {"]
#[doc = "      \"title\": \"Adapter Rank\","]
#[doc = "      \"description\": \"The low-rank intrinsic dimension (r) of the update matrices, used by the orchestrator to calculate VRAM cost.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"base_model_hash\": {"]
#[doc = "      \"title\": \"Base Model Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the exact foundational model this adapter was mathematically trained against.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"eviction_ttl_seconds\": {"]
#[doc = "      \"title\": \"Eviction Ttl Seconds\","]
#[doc = "      \"description\": \"The time-to-live before the inference engine forcefully evicts this adapter from the LRU cache.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"exclusiveMinimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"safetensors_hash\": {"]
#[doc = "      \"title\": \"Safetensors Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the cold-storage adapter weights file ensuring supply-chain zero-trust.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"target_modules\": {"]
#[doc = "      \"title\": \"Target Modules\","]
#[doc = "      \"description\": \"The explicit array of attention head modules to inject (e.g., ['q_proj', 'v_proj']).\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct PeftAdapterContract {
    #[doc = "Unique identifier for the requested LoRA adapter."]
    pub adapter_cid: AdapterCid,
    #[doc = "The low-rank intrinsic dimension (r) of the update matrices, used by the orchestrator to calculate VRAM cost."]
    pub adapter_rank: ::std::num::NonZeroU64,
    #[doc = "The SHA-256 hash of the exact foundational model this adapter was mathematically trained against."]
    pub base_model_hash: BaseModelHash,
    #[doc = "The time-to-live before the inference engine forcefully evicts this adapter from the LRU cache."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub eviction_ttl_seconds: ::std::option::Option<::std::num::NonZeroU64>,
    #[doc = "The SHA-256 hash of the cold-storage adapter weights file ensuring supply-chain zero-trust."]
    pub safetensors_hash: SafetensorsHash,
    #[doc = "The explicit array of attention head modules to inject (e.g., ['q_proj', 'v_proj'])."]
    pub target_modules: ::std::vec::Vec<TargetModulesItem>,
}
impl PeftAdapterContract {
    pub fn builder() -> builder::PeftAdapterContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: The strict Zero-Trust Architecture security perimeter defining exactly what external physical systems or networks an agent node is authorized to touch.\n\nCAUSAL AFFORDANCE: Mechanically limits kinetic reach. Forces the orchestrator to drop network egress packets, block disk I/O, or mandate cryptographic handshakes (e.g., mTLS) before allocating compute.\n\nEPISTEMIC BOUNDS: Bounded by deterministic string arrays (`allowed_domains`, `auth_requirements` constrained to `max_length=2000`) that are alphabetically sorted at instantiation via `@model_validator` to prevent Hash Poisoning attacks.\n\nMCP ROUTING TRIGGERS: Zero-Trust Architecture, Network Egress Filtering, Capability-Based Security, mTLS Handshake, Hash Poisoning Prevention"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"PermissionBoundaryPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: The strict Zero-Trust Architecture security perimeter defining exactly what external physical systems or networks an agent node is authorized to touch.\\n\\nCAUSAL AFFORDANCE: Mechanically limits kinetic reach. Forces the orchestrator to drop network egress packets, block disk I/O, or mandate cryptographic handshakes (e.g., mTLS) before allocating compute.\\n\\nEPISTEMIC BOUNDS: Bounded by deterministic string arrays (`allowed_domains`, `auth_requirements` constrained to `max_length=2000`) that are alphabetically sorted at instantiation via `@model_validator` to prevent Hash Poisoning attacks.\\n\\nMCP ROUTING TRIGGERS: Zero-Trust Architecture, Network Egress Filtering, Capability-Based Security, mTLS Handshake, Hash Poisoning Prevention\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"file_system_mutation_forbidden\","]
#[doc = "    \"network_access\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"allowed_domains\": {"]
#[doc = "      \"title\": \"Allowed Domains\","]
#[doc = "      \"description\": \"The explicit whitelist of allowed network domains if network access is true.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"array\","]
#[doc = "          \"items\": {"]
#[doc = "            \"type\": \"string\","]
#[doc = "            \"maxLength\": 2000"]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"auth_requirements\": {"]
#[doc = "      \"title\": \"Auth Requirements\","]
#[doc = "      \"description\": \"An explicit array of authentication protocol identifiers (e.g., 'oauth2:github', 'mtls:internal') the orchestrator must negotiate before allocating compute.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"array\","]
#[doc = "          \"items\": {"]
#[doc = "            \"type\": \"string\","]
#[doc = "            \"maxLength\": 2000"]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"file_system_mutation_forbidden\": {"]
#[doc = "      \"title\": \"File System Mutation Forbidden\","]
#[doc = "      \"description\": \"The strict Boolean constraint severing local disk I/O capabilities.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"network_access\": {"]
#[doc = "      \"title\": \"Network Access\","]
#[doc = "      \"description\": \"The absolute Boolean gate authorizing or severing exogenous network egress.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct PermissionBoundaryPolicy {
    #[doc = "The explicit whitelist of allowed network domains if network access is true."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub allowed_domains:
        ::std::option::Option<::std::vec::Vec<PermissionBoundaryPolicyAllowedDomainsItem>>,
    #[doc = "An explicit array of authentication protocol identifiers (e.g., 'oauth2:github', 'mtls:internal') the orchestrator must negotiate before allocating compute."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub auth_requirements:
        ::std::option::Option<::std::vec::Vec<PermissionBoundaryPolicyAuthRequirementsItem>>,
    #[doc = "The strict Boolean constraint severing local disk I/O capabilities."]
    pub file_system_mutation_forbidden: bool,
    #[doc = "The absolute Boolean gate authorizing or severing exogenous network egress."]
    pub network_access: bool,
}
impl PermissionBoundaryPolicy {
    pub fn builder() -> builder::PermissionBoundaryPolicy {
        Default::default()
    }
}
#[doc = "`PermissionBoundaryPolicyAllowedDomainsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PermissionBoundaryPolicyAllowedDomainsItem(::std::string::String);
impl ::std::ops::Deref for PermissionBoundaryPolicyAllowedDomainsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PermissionBoundaryPolicyAllowedDomainsItem> for ::std::string::String {
    fn from(value: PermissionBoundaryPolicyAllowedDomainsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PermissionBoundaryPolicyAllowedDomainsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PermissionBoundaryPolicyAllowedDomainsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String>
    for PermissionBoundaryPolicyAllowedDomainsItem
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PermissionBoundaryPolicyAllowedDomainsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PermissionBoundaryPolicyAllowedDomainsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`PermissionBoundaryPolicyAuthRequirementsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PermissionBoundaryPolicyAuthRequirementsItem(::std::string::String);
impl ::std::ops::Deref for PermissionBoundaryPolicyAuthRequirementsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PermissionBoundaryPolicyAuthRequirementsItem> for ::std::string::String {
    fn from(value: PermissionBoundaryPolicyAuthRequirementsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PermissionBoundaryPolicyAuthRequirementsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PermissionBoundaryPolicyAuthRequirementsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String>
    for PermissionBoundaryPolicyAuthRequirementsItem
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String>
    for PermissionBoundaryPolicyAuthRequirementsItem
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PermissionBoundaryPolicyAuthRequirementsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`PermittedClassificationTiersItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"public\","]
#[doc = "    \"internal\","]
#[doc = "    \"confidential\","]
#[doc = "    \"restricted\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum PermittedClassificationTiersItem {
    #[serde(rename = "public")]
    Public,
    #[serde(rename = "internal")]
    Internal,
    #[serde(rename = "confidential")]
    Confidential,
    #[serde(rename = "restricted")]
    Restricted,
}
impl ::std::fmt::Display for PermittedClassificationTiersItem {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Public => f.write_str("public"),
            Self::Internal => f.write_str("internal"),
            Self::Confidential => f.write_str("confidential"),
            Self::Restricted => f.write_str("restricted"),
        }
    }
}
impl ::std::str::FromStr for PermittedClassificationTiersItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "public" => Ok(Self::Public),
            "internal" => Ok(Self::Internal),
            "confidential" => Ok(Self::Confidential),
            "restricted" => Ok(Self::Restricted),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for PermittedClassificationTiersItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PermittedClassificationTiersItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PermittedClassificationTiersItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`PermittedRemoteDecodingProtocolsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^(STRICT_JSON_SCHEMA|NATIVE_PDA_GRAMMAR|LOOSE_JSON_MODE|NONE)$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PermittedRemoteDecodingProtocolsItem(::std::string::String);
impl ::std::ops::Deref for PermittedRemoteDecodingProtocolsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PermittedRemoteDecodingProtocolsItem> for ::std::string::String {
    fn from(value: PermittedRemoteDecodingProtocolsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PermittedRemoteDecodingProtocolsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| {
                ::regress::Regex::new(
                    "^(STRICT_JSON_SCHEMA|NATIVE_PDA_GRAMMAR|LOOSE_JSON_MODE|NONE)$",
                )
                .unwrap()
            });
        if PATTERN.find(value).is_none() {
            return Err ("doesn't match pattern \"^(STRICT_JSON_SCHEMA|NATIVE_PDA_GRAMMAR|LOOSE_JSON_MODE|NONE)$\"" . into ()) ;
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PermittedRemoteDecodingProtocolsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PermittedRemoteDecodingProtocolsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PermittedRemoteDecodingProtocolsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PermittedRemoteDecodingProtocolsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the absolute Write-Ahead Logging (WAL) serialization of an ephemeral state differential to durable cold-storage.\n\nCAUSAL AFFORDANCE: Commits the internal `committed_temporal_crdt_cid` into the macroscopic Apache Iceberg or Delta Lake backing store, yielding a verifiable `lakehouse_snapshot_cid` to guarantee Eventual Consistency.\n\nEPISTEMIC BOUNDS: `lakehouse_snapshot_cid` and `committed_temporal_crdt_cid` are rigorously clamped by `max_length=128` and a strict CID regex (`^[a-zA-Z0-9_.:-]+$`), mathematically preventing path traversal injections.\n\nMCP ROUTING TRIGGERS: Event Sourcing, Write-Ahead Logging, Two-Phase Commit, Lakehouse Serialization, State Differential Flush"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"PersistenceCommitReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the absolute Write-Ahead Logging (WAL) serialization of an ephemeral state differential to durable cold-storage.\\n\\nCAUSAL AFFORDANCE: Commits the internal `committed_temporal_crdt_cid` into the macroscopic Apache Iceberg or Delta Lake backing store, yielding a verifiable `lakehouse_snapshot_cid` to guarantee Eventual Consistency.\\n\\nEPISTEMIC BOUNDS: `lakehouse_snapshot_cid` and `committed_temporal_crdt_cid` are rigorously clamped by `max_length=128` and a strict CID regex (`^[a-zA-Z0-9_.:-]+$`), mathematically preventing path traversal injections.\\n\\nMCP ROUTING TRIGGERS: Event Sourcing, Write-Ahead Logging, Two-Phase Commit, Lakehouse Serialization, State Differential Flush\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"committed_temporal_crdt_cid\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"lakehouse_snapshot_cid\","]
#[doc = "    \"target_table_uri\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"committed_temporal_crdt_cid\": {"]
#[doc = "      \"title\": \"Committed Temporal Crdt Cid\","]
#[doc = "      \"description\": \"The internal TemporalGraphCRDTManifest CID that was flushed.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"lakehouse_snapshot_cid\": {"]
#[doc = "      \"title\": \"Lakehouse Snapshot Cid\","]
#[doc = "      \"description\": \"The external cryptographic receipt generated by Iceberg/Delta.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_table_uri\": {"]
#[doc = "      \"title\": \"Target Table Uri\","]
#[doc = "      \"description\": \"The specific table mutated.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2048,"]
#[doc = "      \"minLength\": 1"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for a persistence commit receipt.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"persistence_commit\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct PersistenceCommitReceipt {
    #[doc = "The internal TemporalGraphCRDTManifest CID that was flushed."]
    pub committed_temporal_crdt_cid: CommittedTemporalCrdtCid,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The external cryptographic receipt generated by Iceberg/Delta."]
    pub lakehouse_snapshot_cid: LakehouseSnapshotCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The specific table mutated."]
    pub target_table_uri: TargetTableUri,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "Discriminator type for a persistence commit receipt."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl PersistenceCommitReceipt {
    pub fn builder() -> builder::PersistenceCommitReceipt {
        Default::default()
    }
}
#[doc = "The cryptographic hash of the Platform Configuration Registers (PCRs) proving the memory state was physically isolated."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Platform Measurement Hash\","]
#[doc = "  \"description\": \"The cryptographic hash of the Platform Configuration Registers (PCRs) proving the memory state was physically isolated.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PlatformMeasurementHash(::std::string::String);
impl ::std::ops::Deref for PlatformMeasurementHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PlatformMeasurementHash> for ::std::string::String {
    fn from(value: PlatformMeasurementHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PlatformMeasurementHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PlatformMeasurementHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PlatformMeasurementHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PlatformMeasurementHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PlatformMeasurementHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Unique identifier for this specific separation boundary."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Policy Cid\","]
#[doc = "  \"description\": \"Unique identifier for this specific separation boundary.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PolicyCid(::std::string::String);
impl ::std::ops::Deref for PolicyCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PolicyCid> for ::std::string::String {
    fn from(value: PolicyCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PolicyCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PolicyCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PolicyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PolicyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PolicyCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: The definitive output of a successful latent manifold alignment. Represents a dynamic assembly of a standardized entity (Base Concept + Contextual Modifiers) to achieve infinite semantic specificity without requiring an infinitely large pre-coordinated vocabulary.\n\n    CAUSAL AFFORDANCE: Physically authorizes the orchestrator to assemble a standardized entity with contextual modifiers.\n\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\n\n    MCP ROUTING TRIGGERS: Post-Coordinated Semantics, Latent Manifold Alignment, Semantic Specificity, Entity Assembly"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"PostCoordinatedSemanticState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: The definitive output of a successful latent manifold alignment. Represents a dynamic assembly of a standardized entity (Base Concept + Contextual Modifiers) to achieve infinite semantic specificity without requiring an infinitely large pre-coordinated vocabulary.\\n\\n    CAUSAL AFFORDANCE: Physically authorizes the orchestrator to assemble a standardized entity with contextual modifiers.\\n\\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\\n\\n    MCP ROUTING TRIGGERS: Post-Coordinated Semantics, Latent Manifold Alignment, Semantic Specificity, Entity Assembly\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"alignment_metric_used\","]
#[doc = "    \"base_concept_cid\","]
#[doc = "    \"concept_cid\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"isometry_score\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"alignment_metric_used\": {"]
#[doc = "      \"description\": \"Audit trail of the exact mathematical metric applied during projection.\","]
#[doc = "      \"$ref\": \"#/$defs/ManifoldAlignmentMetricProfile\""]
#[doc = "    },"]
#[doc = "    \"base_concept_cid\": {"]
#[doc = "      \"description\": \"The pointer to the foundational, universal entity identified in the global EpistemicDomainGraphManifest.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"concept_cid\": {"]
#[doc = "      \"title\": \"Concept Cid\","]
#[doc = "      \"description\": \"The unique geometric coordinate representing this specific assembled concept.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"contextual_modifiers\": {"]
#[doc = "      \"title\": \"Contextual Modifiers\","]
#[doc = "      \"description\": \"An untyped dictionary storing the isolated conditional factors dynamically extracted from the telemetry row.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"Cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"isometry_score\": {"]
#[doc = "      \"title\": \"Isometry Score\","]
#[doc = "      \"description\": \"The exact mathematical fidelity achieved during projection.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The RFC 8785 Canonical hash of the immediate causal ancestor.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"The precise temporal coordinate of the event realization.\","]
#[doc = "      \"type\": \"number\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"post_coordinated_concept\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct PostCoordinatedSemanticState {
    #[doc = "Audit trail of the exact mathematical metric applied during projection."]
    pub alignment_metric_used: ManifoldAlignmentMetricProfile,
    #[doc = "The pointer to the foundational, universal entity identified in the global EpistemicDomainGraphManifest."]
    pub base_concept_cid: NodeCidState,
    #[doc = "The unique geometric coordinate representing this specific assembled concept."]
    pub concept_cid: ConceptCid,
    #[doc = "An untyped dictionary storing the isolated conditional factors dynamically extracted from the telemetry row."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub contextual_modifiers:
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "Cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The exact mathematical fidelity achieved during projection."]
    pub isometry_score: f64,
    #[doc = "The RFC 8785 Canonical hash of the immediate causal ancestor."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The precise temporal coordinate of the event realization."]
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl PostCoordinatedSemanticState {
    pub fn builder() -> builder::PostCoordinatedSemanticState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements NIST FIPS Post-Quantum Cryptography (PQC), utilizing lattice-based or stateless hash-based structures to guarantee long-term topological integrity on the Merkle-DAG.\n\nCAUSAL AFFORDANCE: Secures the causal execution graph and Bilateral SLAs against temporal decryption attacks (Harvest Now, Decrypt Later) via Shor's algorithm executed on fault-tolerant quantum computers.\n\nEPISTEMIC BOUNDS: To accommodate massive dimensional geometry, `pq_signature_blob` is structurally bound to a `100000`-byte `max_length`. `pq_algorithm` is restricted to the Literal set `[\"ml-dsa\", \"slh-dsa\", \"falcon\"]`. `public_key_cid` is a 128-char CID.\n\nMCP ROUTING TRIGGERS: Post-Quantum Cryptography, ML-DSA, SLH-DSA, Shor's Algorithm Resistance, Lattice-based Cryptography"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"PostQuantumSignatureReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements NIST FIPS Post-Quantum Cryptography (PQC), utilizing lattice-based or stateless hash-based structures to guarantee long-term topological integrity on the Merkle-DAG.\\n\\nCAUSAL AFFORDANCE: Secures the causal execution graph and Bilateral SLAs against temporal decryption attacks (Harvest Now, Decrypt Later) via Shor's algorithm executed on fault-tolerant quantum computers.\\n\\nEPISTEMIC BOUNDS: To accommodate massive dimensional geometry, `pq_signature_blob` is structurally bound to a `100000`-byte `max_length`. `pq_algorithm` is restricted to the Literal set `[\\\"ml-dsa\\\", \\\"slh-dsa\\\", \\\"falcon\\\"]`. `public_key_cid` is a 128-char CID.\\n\\nMCP ROUTING TRIGGERS: Post-Quantum Cryptography, ML-DSA, SLH-DSA, Shor's Algorithm Resistance, Lattice-based Cryptography\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"pq_algorithm\","]
#[doc = "    \"pq_signature_blob\","]
#[doc = "    \"public_key_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"pq_algorithm\": {"]
#[doc = "      \"title\": \"Pq Algorithm\","]
#[doc = "      \"description\": \"The NIST FIPS post-quantum cryptographic algorithm used.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"ml-dsa\","]
#[doc = "        \"slh-dsa\","]
#[doc = "        \"falcon\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"pq_signature_blob\": {"]
#[doc = "      \"title\": \"Pq Signature Blob\","]
#[doc = "      \"description\": \"The base64-encoded post-quantum signature. Bounded to 100KB to safely accommodate massive SPHINCS+ hash trees without OOM crashes.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000"]
#[doc = "    },"]
#[doc = "    \"public_key_cid\": {"]
#[doc = "      \"title\": \"Public Key Cid\","]
#[doc = "      \"description\": \"The identifier of the post-quantum public evaluation key.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct PostQuantumSignatureReceipt {
    #[doc = "The NIST FIPS post-quantum cryptographic algorithm used."]
    pub pq_algorithm: PqAlgorithm,
    #[doc = "The base64-encoded post-quantum signature. Bounded to 100KB to safely accommodate massive SPHINCS+ hash trees without OOM crashes."]
    pub pq_signature_blob: PqSignatureBlob,
    #[doc = "The identifier of the post-quantum public evaluation key."]
    pub public_key_cid: PublicKeyCid,
}
impl PostQuantumSignatureReceipt {
    pub fn builder() -> builder::PostQuantumSignatureReceipt {
        Default::default()
    }
}
#[doc = "The definitive SHA-256 hash of the sanitized, mathematically clean payload."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Post Redaction Hash\","]
#[doc = "  \"description\": \"The definitive SHA-256 hash of the sanitized, mathematically clean payload.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PostRedactionHash(::std::string::String);
impl ::std::ops::Deref for PostRedactionHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PostRedactionHash> for ::std::string::String {
    fn from(value: PostRedactionHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PostRedactionHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PostRedactionHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PostRedactionHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PostRedactionHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PostRedactionHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The NIST FIPS post-quantum cryptographic algorithm used."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Pq Algorithm\","]
#[doc = "  \"description\": \"The NIST FIPS post-quantum cryptographic algorithm used.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"ml-dsa\","]
#[doc = "    \"slh-dsa\","]
#[doc = "    \"falcon\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum PqAlgorithm {
    #[serde(rename = "ml-dsa")]
    MlDsa,
    #[serde(rename = "slh-dsa")]
    SlhDsa,
    #[serde(rename = "falcon")]
    Falcon,
}
impl ::std::fmt::Display for PqAlgorithm {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::MlDsa => f.write_str("ml-dsa"),
            Self::SlhDsa => f.write_str("slh-dsa"),
            Self::Falcon => f.write_str("falcon"),
        }
    }
}
impl ::std::str::FromStr for PqAlgorithm {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "ml-dsa" => Ok(Self::MlDsa),
            "slh-dsa" => Ok(Self::SlhDsa),
            "falcon" => Ok(Self::Falcon),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for PqAlgorithm {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PqAlgorithm {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PqAlgorithm {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The base64-encoded post-quantum signature. Bounded to 100KB to safely accommodate massive SPHINCS+ hash trees without OOM crashes."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Pq Signature Blob\","]
#[doc = "  \"description\": \"The base64-encoded post-quantum signature. Bounded to 100KB to safely accommodate massive SPHINCS+ hash trees without OOM crashes.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PqSignatureBlob(::std::string::String);
impl ::std::ops::Deref for PqSignatureBlob {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PqSignatureBlob> for ::std::string::String {
    fn from(value: PqSignatureBlob) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PqSignatureBlob {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PqSignatureBlob {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PqSignatureBlob {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PqSignatureBlob {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PqSignatureBlob {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`PredicateCurie`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Predicate Curie\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$\","]
#[doc = "  \"rdf_edge_property\": true"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PredicateCurie(::std::string::String);
impl ::std::ops::Deref for PredicateCurie {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PredicateCurie> for ::std::string::String {
    fn from(value: PredicateCurie) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PredicateCurie {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| {
                ::regress::Regex::new("^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$").unwrap()
            });
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PredicateCurie {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PredicateCurie {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PredicateCurie {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PredicateCurie {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`PredictedTopKTokensItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PredictedTopKTokensItem(::std::string::String);
impl ::std::ops::Deref for PredictedTopKTokensItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PredictedTopKTokensItem> for ::std::string::String {
    fn from(value: PredictedTopKTokensItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PredictedTopKTokensItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PredictedTopKTokensItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PredictedTopKTokensItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PredictedTopKTokensItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PredictedTopKTokensItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the mathematical Automated Market Maker (AMM) using Robin Hanson's Logarithmic Market Scoring Rule (LMSR) parameters to guarantee infinite liquidity.\n\nCAUSAL AFFORDANCE: Triggers quadratic staking functions to mathematically prevent Sybil attacks and dictates the exact `convergence_delta_threshold` required to halt trading and collapse the probability wave.\n\nEPISTEMIC BOUNDS: `min_liquidity_magnitude` is capped at an integer `le=18446744073709551615, ge=0`, and `convergence_delta_threshold` is strictly clamped to a probability distribution `[ge=0.0, le=1.0]`. `staking_function` is a Literal.\n\nMCP ROUTING TRIGGERS: LMSR, Automated Market Maker, Quadratic Staking, Sybil Resistance, Convergence Delta"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"PredictionMarketPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the mathematical Automated Market Maker (AMM) using Robin Hanson's Logarithmic Market Scoring Rule (LMSR) parameters to guarantee infinite liquidity.\\n\\nCAUSAL AFFORDANCE: Triggers quadratic staking functions to mathematically prevent Sybil attacks and dictates the exact `convergence_delta_threshold` required to halt trading and collapse the probability wave.\\n\\nEPISTEMIC BOUNDS: `min_liquidity_magnitude` is capped at an integer `le=18446744073709551615, ge=0`, and `convergence_delta_threshold` is strictly clamped to a probability distribution `[ge=0.0, le=1.0]`. `staking_function` is a Literal.\\n\\nMCP ROUTING TRIGGERS: LMSR, Automated Market Maker, Quadratic Staking, Sybil Resistance, Convergence Delta\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"convergence_delta_threshold\","]
#[doc = "    \"min_liquidity_magnitude\","]
#[doc = "    \"staking_function\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"convergence_delta_threshold\": {"]
#[doc = "      \"title\": \"Convergence Delta Threshold\","]
#[doc = "      \"description\": \"The threshold indicating the market price has stabilized enough to trigger the resolution oracle.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"min_liquidity_magnitude\": {"]
#[doc = "      \"title\": \"Min Liquidity Magnitude\","]
#[doc = "      \"description\": \"Minimum liquidity required.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"staking_function\": {"]
#[doc = "      \"title\": \"Staking Function\","]
#[doc = "      \"description\": \"The mathematical curve applied to stakes. Quadratic enforces Sybil resistance.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"linear\","]
#[doc = "        \"quadratic\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct PredictionMarketPolicy {
    #[doc = "The threshold indicating the market price has stabilized enough to trigger the resolution oracle."]
    pub convergence_delta_threshold: f64,
    #[doc = "Minimum liquidity required."]
    pub min_liquidity_magnitude: u64,
    #[doc = "The mathematical curve applied to stakes. Quadratic enforces Sybil resistance."]
    pub staking_function: StakingFunction,
}
impl PredictionMarketPolicy {
    pub fn builder() -> builder::PredictionMarketPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative, frozen snapshot of an Automated Market Maker (AMM) utilizing Robin Hanson's Logarithmic Market Scoring Rule (LMSR) to guarantee infinite liquidity.\n\nCAUSAL AFFORDANCE: Aggregates `HypothesisStakeReceipt` vectors, allowing the orchestrator to track the shifting probability manifold and trigger market resolution when the AMM reaches the required convergence threshold.\n\nEPISTEMIC BOUNDS: `current_market_probabilities` is geometrically bounded by `max_length=1000`. `market_cid` is restricted to a 128-char CID. `order_book` array is deterministically sorted by `agent_cid` via `@model_validator`.\n\nMCP ROUTING TRIGGERS: Logarithmic Market Scoring Rule, Automated Market Maker, Prediction Market, Infinite Liquidity, Brier Score"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"PredictionMarketState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative, frozen snapshot of an Automated Market Maker (AMM) utilizing Robin Hanson's Logarithmic Market Scoring Rule (LMSR) to guarantee infinite liquidity.\\n\\nCAUSAL AFFORDANCE: Aggregates `HypothesisStakeReceipt` vectors, allowing the orchestrator to track the shifting probability manifold and trigger market resolution when the AMM reaches the required convergence threshold.\\n\\nEPISTEMIC BOUNDS: `current_market_probabilities` is geometrically bounded by `max_length=1000`. `market_cid` is restricted to a 128-char CID. `order_book` array is deterministically sorted by `agent_cid` via `@model_validator`.\\n\\nMCP ROUTING TRIGGERS: Logarithmic Market Scoring Rule, Automated Market Maker, Prediction Market, Infinite Liquidity, Brier Score\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"current_market_probabilities\","]
#[doc = "    \"lmsr_b_parameter\","]
#[doc = "    \"market_cid\","]
#[doc = "    \"order_book\","]
#[doc = "    \"resolution_oracle_condition_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"current_market_probabilities\": {"]
#[doc = "      \"title\": \"Current Market Probabilities\","]
#[doc = "      \"description\": \"Mapping of hypothesis IDs to their current LMSR-calculated market price (probability) as stringified decimals.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"lmsr_b_parameter\": {"]
#[doc = "      \"title\": \"Lmsr B Parameter\","]
#[doc = "      \"description\": \"The stringified decimal representing the liquidity parameter defining the market depth and max loss for the AMM.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255,"]
#[doc = "      \"pattern\": \"^\\\\d+\\\\.\\\\d+$\""]
#[doc = "    },"]
#[doc = "    \"market_cid\": {"]
#[doc = "      \"title\": \"Market Cid\","]
#[doc = "      \"description\": \"The deterministic capability pointer representing the prediction market.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"order_book\": {"]
#[doc = "      \"title\": \"Order Book\","]
#[doc = "      \"description\": \"The immutable ledger of all stakes placed by the swarm.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/HypothesisStakeReceipt\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"resolution_oracle_condition_cid\": {"]
#[doc = "      \"title\": \"Resolution Oracle Condition Cid\","]
#[doc = "      \"description\": \"The specific FalsificationContract ID whose execution will trigger the market payout.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct PredictionMarketState {
    #[doc = "Mapping of hypothesis IDs to their current LMSR-calculated market price (probability) as stringified decimals."]
    pub current_market_probabilities: ::std::collections::HashMap<
        ::std::string::String,
        PredictionMarketStateCurrentMarketProbabilitiesValue,
    >,
    #[doc = "The stringified decimal representing the liquidity parameter defining the market depth and max loss for the AMM."]
    pub lmsr_b_parameter: LmsrBParameter,
    #[doc = "The deterministic capability pointer representing the prediction market."]
    pub market_cid: MarketCid,
    #[doc = "The immutable ledger of all stakes placed by the swarm."]
    pub order_book: ::std::vec::Vec<HypothesisStakeReceipt>,
    #[doc = "The specific FalsificationContract ID whose execution will trigger the market payout."]
    pub resolution_oracle_condition_cid: ResolutionOracleConditionCid,
}
impl PredictionMarketState {
    pub fn builder() -> builder::PredictionMarketState {
        Default::default()
    }
}
#[doc = "`PredictionMarketStateCurrentMarketProbabilitiesValue`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PredictionMarketStateCurrentMarketProbabilitiesValue(::std::string::String);
impl ::std::ops::Deref for PredictionMarketStateCurrentMarketProbabilitiesValue {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PredictionMarketStateCurrentMarketProbabilitiesValue>
    for ::std::string::String
{
    fn from(value: PredictionMarketStateCurrentMarketProbabilitiesValue) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PredictionMarketStateCurrentMarketProbabilitiesValue {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PredictionMarketStateCurrentMarketProbabilitiesValue {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String>
    for PredictionMarketStateCurrentMarketProbabilitiesValue
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String>
    for PredictionMarketStateCurrentMarketProbabilitiesValue
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PredictionMarketStateCurrentMarketProbabilitiesValue {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The natural language explanation of the abductive theory."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Premise Text\","]
#[doc = "  \"description\": \"The natural language explanation of the abductive theory.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PremiseText(::std::string::String);
impl ::std::ops::Deref for PremiseText {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PremiseText> for ::std::string::String {
    fn from(value: PremiseText) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PremiseText {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PremiseText {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PremiseText {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PremiseText {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PremiseText {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The exact cryptographic standard used to encode this credential presentation."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Presentation Format\","]
#[doc = "  \"description\": \"The exact cryptographic standard used to encode this credential presentation.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"jwt_vc\","]
#[doc = "    \"ldp_vc\","]
#[doc = "    \"sd_jwt\","]
#[doc = "    \"zkp_vc\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum PresentationFormat {
    #[serde(rename = "jwt_vc")]
    JwtVc,
    #[serde(rename = "ldp_vc")]
    LdpVc,
    #[serde(rename = "sd_jwt")]
    SdJwt,
    #[serde(rename = "zkp_vc")]
    ZkpVc,
}
impl ::std::fmt::Display for PresentationFormat {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::JwtVc => f.write_str("jwt_vc"),
            Self::LdpVc => f.write_str("ldp_vc"),
            Self::SdJwt => f.write_str("sd_jwt"),
            Self::ZkpVc => f.write_str("zkp_vc"),
        }
    }
}
impl ::std::str::FromStr for PresentationFormat {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "jwt_vc" => Ok(Self::JwtVc),
            "ldp_vc" => Ok(Self::LdpVc),
            "sd_jwt" => Ok(Self::SdJwt),
            "zkp_vc" => Ok(Self::ZkpVc),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for PresentationFormat {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PresentationFormat {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PresentationFormat {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: The macroscopic orchestrator envelope binding a deterministic visual\nmanifold (grid: MacroGridProfile) to a specific Supervisory Control Theory cognitive\nstate (intent: AnyPresentationIntent). As a ...Manifest suffix, this defines a frozen,\nN-dimensional coordinate state.\n\nCAUSAL AFFORDANCE: Forces the active orchestration loop to suspend or pivot by projecting\na human-in-the-loop interaction surface (e.g., Drafting, Adjudication) alongside its\nvisual evidentiary warrants.\n\nEPISTEMIC BOUNDS: Mathematically binds exactly one AnyPresentationIntent to one\nMacroGridProfile, preventing asynchronous UI state drift and ensuring the generated grid\nis causally justified by a verified intent. The focal_depth_meters is strictly clamped\n(ge=0.1, le=100.0) to physically intercept the observer's optical plane at a safe depth.\n\nMCP ROUTING TRIGGERS: Supervisory Control Theory, Mixed-Initiative UI, Cognitive State\nBinding, Structural Manifold Envelope, Human-in-the-Loop"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"PresentationManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: The macroscopic orchestrator envelope binding a deterministic visual\\nmanifold (grid: MacroGridProfile) to a specific Supervisory Control Theory cognitive\\nstate (intent: AnyPresentationIntent). As a ...Manifest suffix, this defines a frozen,\\nN-dimensional coordinate state.\\n\\nCAUSAL AFFORDANCE: Forces the active orchestration loop to suspend or pivot by projecting\\na human-in-the-loop interaction surface (e.g., Drafting, Adjudication) alongside its\\nvisual evidentiary warrants.\\n\\nEPISTEMIC BOUNDS: Mathematically binds exactly one AnyPresentationIntent to one\\nMacroGridProfile, preventing asynchronous UI state drift and ensuring the generated grid\\nis causally justified by a verified intent. The focal_depth_meters is strictly clamped\\n(ge=0.1, le=100.0) to physically intercept the observer's optical plane at a safe depth.\\n\\nMCP ROUTING TRIGGERS: Supervisory Control Theory, Mixed-Initiative UI, Cognitive State\\nBinding, Structural Manifold Envelope, Human-in-the-Loop\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"grid\","]
#[doc = "    \"intent\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"ambient_telemetry\": {"]
#[doc = "      \"description\": \"Stateless non-blocking telemetry for continuous progress updates.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/AmbientState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"focal_depth_meters\": {"]
#[doc = "      \"title\": \"Focal Depth Meters\","]
#[doc = "      \"description\": \"The absolute Z-axis physical distance to lock the Presentation UI relative to the observer's optical center, resolving vergence-accommodation conflicts.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 100.0,"]
#[doc = "      \"minimum\": 0.1"]
#[doc = "    },"]
#[doc = "    \"grid\": {"]
#[doc = "      \"description\": \"The grid of panels being presented.\","]
#[doc = "      \"$ref\": \"#/$defs/MacroGridProfile\""]
#[doc = "    },"]
#[doc = "    \"intent\": {"]
#[doc = "      \"description\": \"The reason an agent is presenting this data to a human.\","]
#[doc = "      \"$ref\": \"#/$defs/AnyPresentationIntent\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct PresentationManifest {
    #[doc = "Stateless non-blocking telemetry for continuous progress updates."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub ambient_telemetry: ::std::option::Option<AmbientState>,
    #[doc = "The absolute Z-axis physical distance to lock the Presentation UI relative to the observer's optical center, resolving vergence-accommodation conflicts."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub focal_depth_meters: ::std::option::Option<f64>,
    #[doc = "The grid of panels being presented."]
    pub grid: MacroGridProfile,
    #[doc = "The reason an agent is presenting this data to a human."]
    pub intent: AnyPresentationIntent,
}
impl PresentationManifest {
    pub fn builder() -> builder::PresentationManifest {
        Default::default()
    }
}
#[doc = "The SHA-256 hash of the cryptographic seed used to initialize the pseudo-random function (PRF)."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Prf Seed Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the cryptographic seed used to initialize the pseudo-random function (PRF).\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PrfSeedHash(::std::string::String);
impl ::std::ops::Deref for PrfSeedHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PrfSeedHash> for ::std::string::String {
    fn from(value: PrfSeedHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PrfSeedHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PrfSeedHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PrfSeedHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PrfSeedHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PrfSeedHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "RFC 6902 JSON Pointer for exact injection coordinate."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Prism Target Pointer\","]
#[doc = "  \"description\": \"RFC 6902 JSON Pointer for exact injection coordinate.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PrismTargetPointer(::std::string::String);
impl ::std::ops::Deref for PrismTargetPointer {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PrismTargetPointer> for ::std::string::String {
    fn from(value: PrismTargetPointer) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PrismTargetPointer {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PrismTargetPointer {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PrismTargetPointer {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PrismTargetPointer {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PrismTargetPointer {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes a Level-1 Epistemic Discovery Surface utilizing Lazy Evaluation and Information Bottleneck Theory to act as a progressive disclosure pointer to a massive EpistemicSOPManifest.\n\nCAUSAL AFFORDANCE: Prevents context window token exhaustion by keeping the full Standard Operating Procedure in cold storage until the agent's generative trajectory actively mathematically intersects with the `trigger_description`.\n\nEPISTEMIC BOUNDS: The `metadata_cid` and `target_sop_cid` are physically locked to 128-char CIDs. The semantic geometry of the `trigger_description` is clamped at `max_length=2000` to prevent dictionary bombing during routing evaluation.\n\nMCP ROUTING TRIGGERS: Lazy Evaluation, Progressive Disclosure, Information Bottleneck, Discovery Surface, Epistemic Pointer"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ProceduralMetadataManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes a Level-1 Epistemic Discovery Surface utilizing Lazy Evaluation and Information Bottleneck Theory to act as a progressive disclosure pointer to a massive EpistemicSOPManifest.\\n\\nCAUSAL AFFORDANCE: Prevents context window token exhaustion by keeping the full Standard Operating Procedure in cold storage until the agent's generative trajectory actively mathematically intersects with the `trigger_description`.\\n\\nEPISTEMIC BOUNDS: The `metadata_cid` and `target_sop_cid` are physically locked to 128-char CIDs. The semantic geometry of the `trigger_description` is clamped at `max_length=2000` to prevent dictionary bombing during routing evaluation.\\n\\nMCP ROUTING TRIGGERS: Lazy Evaluation, Progressive Disclosure, Information Bottleneck, Discovery Surface, Epistemic Pointer\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"metadata_cid\","]
#[doc = "    \"target_sop_cid\","]
#[doc = "    \"trigger_description\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"latent_vector_coordinate\": {"]
#[doc = "      \"description\": \"Optional dense-vector geometry for zero-shot semantic routing without LLM forward-pass evaluation.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/VectorEmbeddingState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"metadata_cid\": {"]
#[doc = "      \"title\": \"Metadata Cid\","]
#[doc = "      \"description\": \"A strict cryptographic string identifier for this L1 procedural pointer.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_sop_cid\": {"]
#[doc = "      \"title\": \"Target Sop Cid\","]
#[doc = "      \"description\": \"The Content Identifier (CID) of the heavy EpistemicSOPManifest resting in cold storage.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"trigger_description\": {"]
#[doc = "      \"title\": \"Trigger Description\","]
#[doc = "      \"description\": \"The mathematically bounded semantic projection defining when the router must trigger this SOP.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ProceduralMetadataManifest {
    #[doc = "Optional dense-vector geometry for zero-shot semantic routing without LLM forward-pass evaluation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub latent_vector_coordinate: ::std::option::Option<VectorEmbeddingState>,
    #[doc = "A strict cryptographic string identifier for this L1 procedural pointer."]
    pub metadata_cid: MetadataCid,
    #[doc = "The Content Identifier (CID) of the heavy EpistemicSOPManifest resting in cold storage."]
    pub target_sop_cid: TargetSopCid,
    #[doc = "The mathematically bounded semantic projection defining when the router must trigger this SOP."]
    pub trigger_description: TriggerDescription,
}
impl ProceduralMetadataManifest {
    pub fn builder() -> builder::ProceduralMetadataManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Enforces the Step-Level Verification heuristics for Process Reward Models (PRMs) during non-monotonic reasoning searches and test-time compute.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator to physically prune hallucinating ThoughtBranchState vectors from the LatentScratchpadReceipt if their logit probabilities drop below the viable threshold, emulating rigorous Beam Search pruning.\n\nEPISTEMIC BOUNDS: Strictly bounds the search space geometry via `pruning_threshold` (`ge=0.0, le=1.0`) and mechanically caps State-Space Explosion through `max_backtracks_allowed` (`ge=0, le=18446744073709551615`).\n\nMCP ROUTING TRIGGERS: Process Reward Model, Beam Search Pruning, Latent Trajectory, State-Space Explosion, A* Search"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ProcessRewardContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Enforces the Step-Level Verification heuristics for Process Reward Models (PRMs) during non-monotonic reasoning searches and test-time compute.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator to physically prune hallucinating ThoughtBranchState vectors from the LatentScratchpadReceipt if their logit probabilities drop below the viable threshold, emulating rigorous Beam Search pruning.\\n\\nEPISTEMIC BOUNDS: Strictly bounds the search space geometry via `pruning_threshold` (`ge=0.0, le=1.0`) and mechanically caps State-Space Explosion through `max_backtracks_allowed` (`ge=0, le=18446744073709551615`).\\n\\nMCP ROUTING TRIGGERS: Process Reward Model, Beam Search Pruning, Latent Trajectory, State-Space Explosion, A* Search\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_backtracks_allowed\","]
#[doc = "    \"pruning_threshold\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"convergence_sla\": {"]
#[doc = "      \"description\": \"The dynamic circuit breaker that halts the search when PRM variance converges, preventing VRAM waste.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/DynamicConvergenceSLA\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"evaluator_matrix_name\": {"]
#[doc = "      \"title\": \"Evaluator Matrix Name\","]
#[doc = "      \"description\": \"The specific PRM model used to score the logic (e.g., 'math-prm-v2').\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_backtracks_allowed\": {"]
#[doc = "      \"title\": \"Max Backtracks Allowed\","]
#[doc = "      \"description\": \"The absolute limit on how many times the agent can start a new branch before throwing a SystemFaultEvent.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"pruning_threshold\": {"]
#[doc = "      \"title\": \"Pruning Threshold\","]
#[doc = "      \"description\": \"If a ThoughtBranchState's prm_score falls below this threshold, the orchestrator MUST halt its generation.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ProcessRewardContract {
    #[doc = "The dynamic circuit breaker that halts the search when PRM variance converges, preventing VRAM waste."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub convergence_sla: ::std::option::Option<DynamicConvergenceSla>,
    #[doc = "The specific PRM model used to score the logic (e.g., 'math-prm-v2')."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub evaluator_matrix_name: ::std::option::Option<::std::string::String>,
    #[doc = "The absolute limit on how many times the agent can start a new branch before throwing a SystemFaultEvent."]
    pub max_backtracks_allowed: u64,
    #[doc = "If a ThoughtBranchState's prm_score falls below this threshold, the orchestrator MUST halt its generation."]
    pub pruning_threshold: f64,
}
impl ProcessRewardContract {
    pub fn builder() -> builder::ProcessRewardContract {
        Default::default()
    }
}
#[doc = "Unique identifier for this simulation profile."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Profile Cid\","]
#[doc = "  \"description\": \"Unique identifier for this simulation profile.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ProfileCid(::std::string::String);
impl ::std::ops::Deref for ProfileCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ProfileCid> for ::std::string::String {
    fn from(value: ProfileCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ProfileCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ProfileCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProfileCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProfileCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ProfileCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A deterministic cognitive routing boundary that defines the non-monotonic instruction set for the agent."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"description\": \"A deterministic cognitive routing boundary that defines the non-monotonic instruction set for the agent.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ProfileCidState(::std::string::String);
impl ::std::ops::Deref for ProfileCidState {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ProfileCidState> for ::std::string::String {
    fn from(value: ProfileCidState) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ProfileCidState {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ProfileCidState {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProfileCidState {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProfileCidState {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ProfileCidState {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A cryptographic Lineage Watermark bounding this specific capability set."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Projection Cid\","]
#[doc = "  \"description\": \"A cryptographic Lineage Watermark bounding this specific capability set.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ProjectionCid(::std::string::String);
impl ::std::ops::Deref for ProjectionCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ProjectionCid> for ::std::string::String {
    fn from(value: ProjectionCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ProjectionCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ProjectionCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProjectionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProjectionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ProjectionCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The linear algebraic projection operator applied to collapse the topology."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Projection Class\","]
#[doc = "  \"description\": \"The linear algebraic projection operator applied to collapse the topology.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"perspective\","]
#[doc = "    \"orthographic\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ProjectionClass {
    #[serde(rename = "perspective")]
    Perspective,
    #[serde(rename = "orthographic")]
    Orthographic,
}
impl ::std::fmt::Display for ProjectionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Perspective => f.write_str("perspective"),
            Self::Orthographic => f.write_str("orthographic"),
        }
    }
}
impl ::std::str::FromStr for ProjectionClass {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "perspective" => Ok(Self::Perspective),
            "orthographic" => Ok(Self::Orthographic),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ProjectionClass {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProjectionClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProjectionClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The name of the prompt template."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Prompt Name\","]
#[doc = "  \"description\": \"The name of the prompt template.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PromptName(::std::string::String);
impl ::std::ops::Deref for PromptName {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PromptName> for ::std::string::String {
    fn from(value: PromptName) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PromptName {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PromptName {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PromptName {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PromptName {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PromptName {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) for this specific topological proof."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Proof Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) for this specific topological proof.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ProofCid(::std::string::String);
impl ::std::ops::Deref for ProofCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ProofCid> for ::std::string::String {
    fn from(value: ProofCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ProofCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ProofCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProofCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProofCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ProofCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The URN of the mathematical dialect of the cryptographic proof (e.g., 'urn:coreason:zk:snark')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Proof Protocol\","]
#[doc = "  \"description\": \"The URN of the mathematical dialect of the cryptographic proof (e.g., 'urn:coreason:zk:snark').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ProofProtocol(::std::string::String);
impl ::std::ops::Deref for ProofProtocol {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ProofProtocol> for ::std::string::String {
    fn from(value: ProofProtocol) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ProofProtocol {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^urn:coreason:.*$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^urn:coreason:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ProofProtocol {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProofProtocol {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProofProtocol {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ProofProtocol {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The mathematical dialect and theorem prover used to compile the proof."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Proof System\","]
#[doc = "  \"description\": \"The mathematical dialect and theorem prover used to compile the proof.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"lean4\","]
#[doc = "    \"z3\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ProofSystem {
    #[serde(rename = "lean4")]
    Lean4,
    #[serde(rename = "z3")]
    Z3,
}
impl ::std::fmt::Display for ProofSystem {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Lean4 => f.write_str("lean4"),
            Self::Z3 => f.write_str("z3"),
        }
    }
}
impl ::std::str::FromStr for ProofSystem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "lean4" => Ok(Self::Lean4),
            "z3" => Ok(Self::Z3),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ProofSystem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProofSystem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProofSystem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the agent or system that advanced this claim."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Proponent Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the agent or system that advanced this claim.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ProponentCid(::std::string::String);
impl ::std::ops::Deref for ProponentCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ProponentCid> for ::std::string::String {
    fn from(value: ProponentCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ProponentCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ProponentCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProponentCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProponentCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ProponentCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The cryptographic Merkle-DAG anchor for the proposal."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Proposal Cid\","]
#[doc = "  \"description\": \"The cryptographic Merkle-DAG anchor for the proposal.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ProposalCid(::std::string::String);
impl ::std::ops::Deref for ProposalCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ProposalCid> for ::std::string::String {
    fn from(value: ProposalCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ProposalCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ProposalCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProposalCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProposalCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ProposalCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A structured natural-language description of the proposed heuristic leap or code modification strategy."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Proposed Action\","]
#[doc = "  \"description\": \"A structured natural-language description of the proposed heuristic leap or code modification strategy.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 10000,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ProposedAction(::std::string::String);
impl ::std::ops::Deref for ProposedAction {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ProposedAction> for ::std::string::String {
    fn from(value: ProposedAction) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ProposedAction {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 10000usize {
            return Err("longer than 10000 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ProposedAction {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProposedAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProposedAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ProposedAction {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The connectionist agent generating hypotheses."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Proposer Node Cid\","]
#[doc = "  \"description\": \"The connectionist agent generating hypotheses.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ProposerNodeCid(::std::string::String);
impl ::std::ops::Deref for ProposerNodeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ProposerNodeCid> for ::std::string::String {
    fn from(value: ProposerNodeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ProposerNodeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ProposerNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProposerNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProposerNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ProposerNodeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) bounding this specific extracted proposition."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Proposition Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) bounding this specific extracted proposition.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PropositionCid(::std::string::String);
impl ::std::ops::Deref for PropositionCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PropositionCid> for ::std::string::String {
    fn from(value: PropositionCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PropositionCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PropositionCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PropositionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PropositionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PropositionCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`ProtectedEventCidsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ProtectedEventCidsItem(::std::string::String);
impl ::std::ops::Deref for ProtectedEventCidsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ProtectedEventCidsItem> for ::std::string::String {
    fn from(value: ProtectedEventCidsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ProtectedEventCidsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ProtectedEventCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProtectedEventCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProtectedEventCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ProtectedEventCidsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The name of the provider hosting the model."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Provider\","]
#[doc = "  \"description\": \"The name of the provider hosting the model.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Provider(::std::string::String);
impl ::std::ops::Deref for Provider {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Provider> for ::std::string::String {
    fn from(value: Provider) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Provider {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Provider {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Provider {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Provider {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Provider {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`ProviderWhitelistItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ProviderWhitelistItem(::std::string::String);
impl ::std::ops::Deref for ProviderWhitelistItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ProviderWhitelistItem> for ::std::string::String {
    fn from(value: ProviderWhitelistItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ProviderWhitelistItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ProviderWhitelistItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProviderWhitelistItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProviderWhitelistItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ProviderWhitelistItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The deterministic UUID generated by the runtime to represent this field."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Proxy Cid\","]
#[doc = "  \"description\": \"The deterministic UUID generated by the runtime to represent this field.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ProxyCid(::std::string::String);
impl ::std::ops::Deref for ProxyCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ProxyCid> for ::std::string::String {
    fn from(value: ProxyCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ProxyCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ProxyCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ProxyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ProxyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ProxyCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SHA-256 hash of the public inputs (e.g., prompt, Lamport clock) anchoring this proof to the specific state index."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Public Inputs Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the public inputs (e.g., prompt, Lamport clock) anchoring this proof to the specific state index.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PublicInputsHash(::std::string::String);
impl ::std::ops::Deref for PublicInputsHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PublicInputsHash> for ::std::string::String {
    fn from(value: PublicInputsHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PublicInputsHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PublicInputsHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PublicInputsHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PublicInputsHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PublicInputsHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The public key of the oracle or node used to verify the VRF proof."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Public Key\","]
#[doc = "  \"description\": \"The public key of the oracle or node used to verify the VRF proof.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 8192,"]
#[doc = "  \"minLength\": 10"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PublicKey(::std::string::String);
impl ::std::ops::Deref for PublicKey {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PublicKey> for ::std::string::String {
    fn from(value: PublicKey) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PublicKey {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 8192usize {
            return Err("longer than 8192 characters".into());
        }
        if value.chars().count() < 10usize {
            return Err("shorter than 10 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PublicKey {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PublicKey {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PublicKey {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PublicKey {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The Content Identifier (CID) of the public evaluation key the orchestrator must utilize to perform privacy-preserving geometric math on ciphertext without epistemic contamination."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Public Key Cid\","]
#[doc = "  \"description\": \"The Content Identifier (CID) of the public evaluation key the orchestrator must utilize to perform privacy-preserving geometric math on ciphertext without epistemic contamination.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct PublicKeyCid(::std::string::String);
impl ::std::ops::Deref for PublicKeyCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<PublicKeyCid> for ::std::string::String {
    fn from(value: PublicKeyCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for PublicKeyCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for PublicKeyCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for PublicKeyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for PublicKeyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for PublicKeyCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`QoSClassificationProfile`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"critical\","]
#[doc = "    \"high\","]
#[doc = "    \"interactive\","]
#[doc = "    \"background_batch\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum QoSClassificationProfile {
    #[serde(rename = "critical")]
    Critical,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "interactive")]
    Interactive,
    #[serde(rename = "background_batch")]
    BackgroundBatch,
}
impl ::std::fmt::Display for QoSClassificationProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Critical => f.write_str("critical"),
            Self::High => f.write_str("high"),
            Self::Interactive => f.write_str("interactive"),
            Self::BackgroundBatch => f.write_str("background_batch"),
        }
    }
}
impl ::std::str::FromStr for QoSClassificationProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "critical" => Ok(Self::Critical),
            "high" => Ok(Self::High),
            "interactive" => Ok(Self::Interactive),
            "background_batch" => Ok(Self::BackgroundBatch),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for QoSClassificationProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for QoSClassificationProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for QoSClassificationProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "A universal automaton classifying the type of statistical boundary."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Qualifier Type\","]
#[doc = "  \"description\": \"A universal automaton classifying the type of statistical boundary.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"probability_value\","]
#[doc = "    \"sample_size\","]
#[doc = "    \"variance_metric\","]
#[doc = "    \"effect_size\","]
#[doc = "    \"confidence_interval\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum QualifierType {
    #[serde(rename = "probability_value")]
    ProbabilityValue,
    #[serde(rename = "sample_size")]
    SampleSize,
    #[serde(rename = "variance_metric")]
    VarianceMetric,
    #[serde(rename = "effect_size")]
    EffectSize,
    #[serde(rename = "confidence_interval")]
    ConfidenceInterval,
}
impl ::std::fmt::Display for QualifierType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::ProbabilityValue => f.write_str("probability_value"),
            Self::SampleSize => f.write_str("sample_size"),
            Self::VarianceMetric => f.write_str("variance_metric"),
            Self::EffectSize => f.write_str("effect_size"),
            Self::ConfidenceInterval => f.write_str("confidence_interval"),
        }
    }
}
impl ::std::str::FromStr for QualifierType {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "probability_value" => Ok(Self::ProbabilityValue),
            "sample_size" => Ok(Self::SampleSize),
            "variance_metric" => Ok(Self::VarianceMetric),
            "effect_size" => Ok(Self::EffectSize),
            "confidence_interval" => Ok(Self::ConfidenceInterval),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for QualifierType {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for QualifierType {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for QualifierType {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Triggers an Epistemic Quarantine utilizing rigid Spectral Graph Partitioning to mathematically isolate a hallucinating, degraded, or Byzantine node from the active working context.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator to sever all outgoing causal edges from the `target_node_cid`, reducing its algebraic connectivity to zero. Neutralizes probability mass in the routing manifold and prevents entropy contamination.\n\nEPISTEMIC BOUNDS: The execution discriminator is locked to a strict Literal string. Topological isolation is strictly targeted via `target_node_cid`. The causal justification for the graph cut is physically constrained to `reason` (`max_length=2000`).\n\nMCP ROUTING TRIGGERS: Spectral Graph Partitioning, Byzantine Fault Isolation, Epistemic Contagion, Defeasible Logic, Algebraic Connectivity"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"QuarantineIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Triggers an Epistemic Quarantine utilizing rigid Spectral Graph Partitioning to mathematically isolate a hallucinating, degraded, or Byzantine node from the active working context.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator to sever all outgoing causal edges from the `target_node_cid`, reducing its algebraic connectivity to zero. Neutralizes probability mass in the routing manifold and prevents entropy contamination.\\n\\nEPISTEMIC BOUNDS: The execution discriminator is locked to a strict Literal string. Topological isolation is strictly targeted via `target_node_cid`. The causal justification for the graph cut is physically constrained to `reason` (`max_length=2000`).\\n\\nMCP ROUTING TRIGGERS: Spectral Graph Partitioning, Byzantine Fault Isolation, Epistemic Contagion, Defeasible Logic, Algebraic Connectivity\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"reason\","]
#[doc = "    \"target_node_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"reason\": {"]
#[doc = "      \"title\": \"Reason\","]
#[doc = "      \"description\": \"The deterministic causal justification for the structural quarantine.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"description\": \"The deterministic capability pointer representing the node to be quarantined.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The type of the resilience payload.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"quarantine_intent\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct QuarantineIntent {
    #[doc = "The deterministic causal justification for the structural quarantine."]
    pub reason: Reason,
    #[doc = "The deterministic capability pointer representing the node to be quarantined."]
    pub target_node_cid: NodeCidState,
    #[doc = "The type of the resilience payload."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl QuarantineIntent {
    pub fn builder() -> builder::QuarantineIntent {
        Default::default()
    }
}
#[doc = "`QuarantinedEventCidsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct QuarantinedEventCidsItem(::std::string::String);
impl ::std::ops::Deref for QuarantinedEventCidsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<QuarantinedEventCidsItem> for ::std::string::String {
    fn from(value: QuarantinedEventCidsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for QuarantinedEventCidsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for QuarantinedEventCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for QuarantinedEventCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for QuarantinedEventCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for QuarantinedEventCidsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The internal standard CID the agent is checking for deprecation or semantic drift."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Query Concept Cid\","]
#[doc = "  \"description\": \"The internal standard CID the agent is checking for deprecation or semantic drift.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct QueryConceptCid(::std::string::String);
impl ::std::ops::Deref for QueryConceptCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<QueryConceptCid> for ::std::string::String {
    fn from(value: QueryConceptCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for QueryConceptCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for QueryConceptCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for QueryConceptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for QueryConceptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for QueryConceptCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A pointer back to the SPARQLQueryIntent that authorized this execution."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Query Intent Cid\","]
#[doc = "  \"description\": \"A pointer back to the SPARQLQueryIntent that authorized this execution.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct QueryIntentCid(::std::string::String);
impl ::std::ops::Deref for QueryIntentCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<QueryIntentCid> for ::std::string::String {
    fn from(value: QueryIntentCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for QueryIntentCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for QueryIntentCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for QueryIntentCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for QueryIntentCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for QueryIntentCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes the Practical Byzantine Fault Tolerance (pBFT)\nmathematical boundaries for a decentralized swarm to survive malicious or hallucinating\nactors. As a ...Policy suffix, this object defines rigid mathematical boundaries.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator to validate the state_validation_metric\n(Literal [\"ledger_hash\", \"zk_proof\", \"semantic_embedding\"]) across $N$ nodes, physically\nexecuting the byzantine_action (Literal [\"quarantine\", \"slash_escrow\", \"ignore\"])\nagainst nodes that violate the consensus.\n\nEPISTEMIC BOUNDS: Physically bounds max_tolerable_faults (ge=0, le=18446744073709551615) and\nmin_quorum_size (gt=0, le=18446744073709551615). The @model_validator enforce_bft_math enforces\nthe strict invariant $N \\ge 3f + 1$, guaranteeing Byzantine agreement.\n\nMCP ROUTING TRIGGERS: Byzantine Fault Tolerance, pBFT, Quorum Sensing, Sybil\nResistance, Distributed Consensus"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"QuorumPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes the Practical Byzantine Fault Tolerance (pBFT)\\nmathematical boundaries for a decentralized swarm to survive malicious or hallucinating\\nactors. As a ...Policy suffix, this object defines rigid mathematical boundaries.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator to validate the state_validation_metric\\n(Literal [\\\"ledger_hash\\\", \\\"zk_proof\\\", \\\"semantic_embedding\\\"]) across $N$ nodes, physically\\nexecuting the byzantine_action (Literal [\\\"quarantine\\\", \\\"slash_escrow\\\", \\\"ignore\\\"])\\nagainst nodes that violate the consensus.\\n\\nEPISTEMIC BOUNDS: Physically bounds max_tolerable_faults (ge=0, le=18446744073709551615) and\\nmin_quorum_size (gt=0, le=18446744073709551615). The @model_validator enforce_bft_math enforces\\nthe strict invariant $N \\\\ge 3f + 1$, guaranteeing Byzantine agreement.\\n\\nMCP ROUTING TRIGGERS: Byzantine Fault Tolerance, pBFT, Quorum Sensing, Sybil\\nResistance, Distributed Consensus\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"byzantine_action\","]
#[doc = "    \"max_tolerable_faults\","]
#[doc = "    \"min_quorum_size\","]
#[doc = "    \"state_validation_metric\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"byzantine_action\": {"]
#[doc = "      \"title\": \"Byzantine Action\","]
#[doc = "      \"description\": \"The deterministic punishment executed by the orchestrator against nodes that violate the consensus quorum.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"quarantine\","]
#[doc = "        \"slash_escrow\","]
#[doc = "        \"ignore\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_tolerable_faults\": {"]
#[doc = "      \"title\": \"Max Tolerable Faults\","]
#[doc = "      \"description\": \"The maximum number of actively malicious, hallucinating, or degraded nodes (f) the swarm must survive.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"min_quorum_size\": {"]
#[doc = "      \"title\": \"Min Quorum Size\","]
#[doc = "      \"description\": \"The minimum number of participating agents (N) required to form consensus.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"state_validation_metric\": {"]
#[doc = "      \"title\": \"State Validation Metric\","]
#[doc = "      \"description\": \"The cryptographic material the agents must sign to submit a valid vote.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"ledger_hash\","]
#[doc = "        \"zk_proof\","]
#[doc = "        \"semantic_embedding\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct QuorumPolicy {
    #[doc = "The deterministic punishment executed by the orchestrator against nodes that violate the consensus quorum."]
    pub byzantine_action: ByzantineAction,
    #[doc = "The maximum number of actively malicious, hallucinating, or degraded nodes (f) the swarm must survive."]
    pub max_tolerable_faults: u64,
    #[doc = "The minimum number of participating agents (N) required to form consensus."]
    pub min_quorum_size: ::std::num::NonZeroU64,
    #[doc = "The cryptographic material the agents must sign to submit a valid vote."]
    pub state_validation_metric: StateValidationMetric,
}
impl QuorumPolicy {
    pub fn builder() -> builder::QuorumPolicy {
        Default::default()
    }
}
#[doc = "`QuorumSignaturesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 10000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct QuorumSignaturesItem(::std::string::String);
impl ::std::ops::Deref for QuorumSignaturesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<QuorumSignaturesItem> for ::std::string::String {
    fn from(value: QuorumSignaturesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for QuorumSignaturesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 10000usize {
            return Err("longer than 10000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for QuorumSignaturesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for QuorumSignaturesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for QuorumSignaturesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for QuorumSignaturesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The causal reasoning chain explaining why this action is expected to resolve the epistemic deficit, including references to specific code structures or domain constraints."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Rationale\","]
#[doc = "  \"description\": \"The causal reasoning chain explaining why this action is expected to resolve the epistemic deficit, including references to specific code structures or domain constraints.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 10000,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Rationale(::std::string::String);
impl ::std::ops::Deref for Rationale {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Rationale> for ::std::string::String {
    fn from(value: Rationale) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Rationale {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 10000usize {
            return Err("longer than 10000 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Rationale {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Rationale {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Rationale {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Rationale {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The anchor to the initial, unstructured MultimodalArtifactReceipt uploaded by the human."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Raw Human Artifact Cid\","]
#[doc = "  \"description\": \"The anchor to the initial, unstructured MultimodalArtifactReceipt uploaded by the human.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RawHumanArtifactCid(::std::string::String);
impl ::std::ops::Deref for RawHumanArtifactCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RawHumanArtifactCid> for ::std::string::String {
    fn from(value: RawHumanArtifactCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RawHumanArtifactCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RawHumanArtifactCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RawHumanArtifactCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RawHumanArtifactCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RawHumanArtifactCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The raw, unparsed human natural language instruction."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Raw Input String\","]
#[doc = "  \"description\": \"The raw, unparsed human natural language instruction.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RawInputString(::std::string::String);
impl ::std::ops::Deref for RawInputString {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RawInputString> for ::std::string::String {
    fn from(value: RawInputString) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RawInputString {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RawInputString {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RawInputString {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RawInputString {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RawInputString {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"RDFExportReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"export_cid\","]
#[doc = "    \"rdf_triple_count\","]
#[doc = "    \"serialized_payload\","]
#[doc = "    \"sha256_graph_hash\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"export_cid\": {"]
#[doc = "      \"title\": \"Export Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"rdf_triple_count\": {"]
#[doc = "      \"title\": \"Rdf Triple Count\","]
#[doc = "      \"type\": \"integer\""]
#[doc = "    },"]
#[doc = "    \"serialized_payload\": {"]
#[doc = "      \"title\": \"Serialized Payload\","]
#[doc = "      \"type\": \"string\""]
#[doc = "    },"]
#[doc = "    \"sha256_graph_hash\": {"]
#[doc = "      \"title\": \"Sha256 Graph Hash\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"rdf_export_receipt\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct RdfExportReceipt {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    pub export_cid: ExportCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    pub rdf_triple_count: i64,
    pub serialized_payload: ::std::string::String,
    pub sha256_graph_hash: Sha256GraphHash,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl RdfExportReceipt {
    pub fn builder() -> builder::RdfExportReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"RDFSerializationIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"base_uri_namespace\","]
#[doc = "    \"export_cid\","]
#[doc = "    \"target_graph_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"base_uri_namespace\": {"]
#[doc = "      \"title\": \"Base Uri Namespace\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"format\": \"uri\","]
#[doc = "      \"minLength\": 1"]
#[doc = "    },"]
#[doc = "    \"export_cid\": {"]
#[doc = "      \"title\": \"Export Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"shacl_governance\": {"]
#[doc = "      \"description\": \"The structural shape constraints governing the exported RDF graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SHACLValidationSLA\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_format\": {"]
#[doc = "      \"title\": \"Target Format\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"turtle\","]
#[doc = "        \"xml\","]
#[doc = "        \"json-ld\","]
#[doc = "        \"ntriples\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_graph_cid\": {"]
#[doc = "      \"title\": \"Target Graph Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"rdf_serialization\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct RdfSerializationIntent {
    pub base_uri_namespace: ::std::string::String,
    pub export_cid: ExportCid,
    #[doc = "The structural shape constraints governing the exported RDF graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub shacl_governance: ::std::option::Option<ShaclValidationSla>,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub target_format: ::std::option::Option<TargetFormat>,
    pub target_graph_cid: TargetGraphCid,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl RdfSerializationIntent {
    pub fn builder() -> builder::RdfSerializationIntent {
        Default::default()
    }
}
#[doc = "The deterministic causal justification for the structural quarantine."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Reason\","]
#[doc = "  \"description\": \"The deterministic causal justification for the structural quarantine.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Reason(::std::string::String);
impl ::std::ops::Deref for Reason {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Reason> for ::std::string::String {
    fn from(value: Reason) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Reason {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Reason {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Reason {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Reason {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Reason {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The deterministic logical proof justifying the final verdict and mathematical score."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Reasoning\","]
#[doc = "  \"description\": \"The deterministic logical proof justifying the final verdict and mathematical score.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Reasoning(::std::string::String);
impl ::std::ops::Deref for Reasoning {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Reasoning> for ::std::string::String {
    fn from(value: Reasoning) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Reasoning {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Reasoning {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Reasoning {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Reasoning {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Reasoning {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Governs how human rejections translate into penalty scalars to bend the agent's Monte Carlo Tree Search.\n\nCAUSAL AFFORDANCE: Permits human observation and penalty insertion into internal LatentScratchpadReceipt traces without halting the execution tree.\n\nEPISTEMIC BOUNDS: Bounds `telemetry_export_frequency_hz` between 1 and 60. Bounds `human_override_gradient` between `0.0` and `1.0`.\n\nMCP ROUTING TRIGGERS: Supervisory Control Theory, MCTS Bending, Penalty Scalar, Trace Evaluation, Cognitive Engineering"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ReasoningEngineeringPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Governs how human rejections translate into penalty scalars to bend the agent's Monte Carlo Tree Search.\\n\\nCAUSAL AFFORDANCE: Permits human observation and penalty insertion into internal LatentScratchpadReceipt traces without halting the execution tree.\\n\\nEPISTEMIC BOUNDS: Bounds `telemetry_export_frequency_hz` between 1 and 60. Bounds `human_override_gradient` between `0.0` and `1.0`.\\n\\nMCP ROUTING TRIGGERS: Supervisory Control Theory, MCTS Bending, Penalty Scalar, Trace Evaluation, Cognitive Engineering\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"human_override_gradient\","]
#[doc = "    \"telemetry_export_frequency_hz\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"human_override_gradient\": {"]
#[doc = "      \"title\": \"Human Override Gradient\","]
#[doc = "      \"description\": \"The absolute penalty applied to a prm_score if a human rejects the branch.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"telemetry_export_frequency_hz\": {"]
#[doc = "      \"title\": \"Telemetry Export Frequency Hz\","]
#[doc = "      \"description\": \"The continuous stream rate of the thought branch expansion.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 60.0,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ReasoningEngineeringPolicy {
    #[doc = "The absolute penalty applied to a prm_score if a human rejects the branch."]
    pub human_override_gradient: f64,
    #[doc = "The continuous stream rate of the thought branch expansion."]
    pub telemetry_export_frequency_hz: ::std::num::NonZeroU64,
}
impl ReasoningEngineeringPolicy {
    pub fn builder() -> builder::ReasoningEngineeringPolicy {
        Default::default()
    }
}
#[doc = "The cryptographic Merkle root of the specific ThoughtBranch being evaluated."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Reasoning Trace Hash\","]
#[doc = "  \"description\": \"The cryptographic Merkle root of the specific ThoughtBranch being evaluated.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ReasoningTraceHash(::std::string::String);
impl ::std::ops::Deref for ReasoningTraceHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ReasoningTraceHash> for ::std::string::String {
    fn from(value: ReasoningTraceHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ReasoningTraceHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ReasoningTraceHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ReasoningTraceHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ReasoningTraceHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ReasoningTraceHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`ReceiptCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Receipt Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ReceiptCid(::std::string::String);
impl ::std::ops::Deref for ReceiptCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ReceiptCid> for ::std::string::String {
    fn from(value: ReceiptCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ReceiptCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ReceiptCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ReceiptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ReceiptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ReceiptCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SpatialReferenceFrameManifest CID this coordinate is relative to, anchoring it to a physical or virtual room."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Reference Frame Cid\","]
#[doc = "  \"description\": \"The SpatialReferenceFrameManifest CID this coordinate is relative to, anchoring it to a physical or virtual room.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ReferenceFrameCid(::std::string::String);
impl ::std::ops::Deref for ReferenceFrameCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ReferenceFrameCid> for ::std::string::String {
    fn from(value: ReferenceFrameCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ReferenceFrameCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ReferenceFrameCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ReferenceFrameCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ReferenceFrameCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ReferenceFrameCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The exact NodeCIDState to return funds to if the release condition fails."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Refund Target Node Cid\","]
#[doc = "  \"description\": \"The exact NodeCIDState to return funds to if the release condition fails.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RefundTargetNodeCid(::std::string::String);
impl ::std::ops::Deref for RefundTargetNodeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RefundTargetNodeCid> for ::std::string::String {
    fn from(value: RefundTargetNodeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RefundTargetNodeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RefundTargetNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RefundTargetNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RefundTargetNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RefundTargetNodeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A declarative pointer to the SLA or QA rubric required to release the funds."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Release Condition Metric\","]
#[doc = "  \"description\": \"A declarative pointer to the SLA or QA rubric required to release the funds.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ReleaseConditionMetric(::std::string::String);
impl ::std::ops::Deref for ReleaseConditionMetric {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ReleaseConditionMetric> for ::std::string::String {
    fn from(value: ReleaseConditionMetric) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ReleaseConditionMetric {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ReleaseConditionMetric {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ReleaseConditionMetric {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ReleaseConditionMetric {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ReleaseConditionMetric {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The exact semantic prompt injected into the LLM if the AST assertion collapses natively."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Remediation Prompt\","]
#[doc = "  \"description\": \"The exact semantic prompt injected into the LLM if the AST assertion collapses natively.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2048"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RemediationPrompt(::std::string::String);
impl ::std::ops::Deref for RemediationPrompt {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RemediationPrompt> for ::std::string::String {
    fn from(value: RemediationPrompt) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RemediationPrompt {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2048usize {
            return Err("longer than 2048 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RemediationPrompt {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RemediationPrompt {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RemediationPrompt {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RemediationPrompt {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The regular expression pattern identifying a structural disfluency marker in the stream."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Repair Marker Regex\","]
#[doc = "  \"description\": \"The regular expression pattern identifying a structural disfluency marker in the stream.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RepairMarkerRegex(::std::string::String);
impl ::std::ops::Deref for RepairMarkerRegex {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RepairMarkerRegex> for ::std::string::String {
    fn from(value: RepairMarkerRegex) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RepairMarkerRegex {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RepairMarkerRegex {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RepairMarkerRegex {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RepairMarkerRegex {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RepairMarkerRegex {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the causal rollback operation."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Request Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the causal rollback operation.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RequestCid(::std::string::String);
impl ::std::ops::Deref for RequestCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RequestCid> for ::std::string::String {
    fn from(value: RequestCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RequestCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RequestCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RequestCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RequestCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RequestCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The mandatory cryptographic attestation URN required to verify the human operator's identity."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Required Attestation\","]
#[doc = "  \"description\": \"The mandatory cryptographic attestation URN required to verify the human operator's identity.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RequiredAttestation(::std::string::String);
impl ::std::ops::Deref for RequiredAttestation {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RequiredAttestation> for ::std::string::String {
    fn from(value: RequiredAttestation) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RequiredAttestation {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^urn:coreason:.*$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^urn:coreason:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RequiredAttestation {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RequiredAttestation {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RequiredAttestation {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RequiredAttestation {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`RequiredCapabilitiesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RequiredCapabilitiesItem(::std::string::String);
impl ::std::ops::Deref for RequiredCapabilitiesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RequiredCapabilitiesItem> for ::std::string::String {
    fn from(value: RequiredCapabilitiesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RequiredCapabilitiesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RequiredCapabilitiesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RequiredCapabilitiesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RequiredCapabilitiesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RequiredCapabilitiesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Dictates the required granularity of the MultimodalTokenAnchorState (e.g., must the model map every single entity, or just the global claim?)."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Required Grounding Density\","]
#[doc = "  \"description\": \"Dictates the required granularity of the MultimodalTokenAnchorState (e.g., must the model map every single entity, or just the global claim?).\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"sparse\","]
#[doc = "    \"dense\","]
#[doc = "    \"exhaustive\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum RequiredGroundingDensity {
    #[serde(rename = "sparse")]
    Sparse,
    #[serde(rename = "dense")]
    Dense,
    #[serde(rename = "exhaustive")]
    Exhaustive,
}
impl ::std::fmt::Display for RequiredGroundingDensity {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Sparse => f.write_str("sparse"),
            Self::Dense => f.write_str("dense"),
            Self::Exhaustive => f.write_str("exhaustive"),
        }
    }
}
impl ::std::str::FromStr for RequiredGroundingDensity {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "sparse" => Ok(Self::Sparse),
            "dense" => Ok(Self::Dense),
            "exhaustive" => Ok(Self::Exhaustive),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for RequiredGroundingDensity {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RequiredGroundingDensity {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RequiredGroundingDensity {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`RequiredLicensesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RequiredLicensesItem(::std::string::String);
impl ::std::ops::Deref for RequiredLicensesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RequiredLicensesItem> for ::std::string::String {
    fn from(value: RequiredLicensesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RequiredLicensesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RequiredLicensesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RequiredLicensesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RequiredLicensesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RequiredLicensesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`RequiredPackageSignaturesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RequiredPackageSignaturesItem(::std::string::String);
impl ::std::ops::Deref for RequiredPackageSignaturesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RequiredPackageSignaturesItem> for ::std::string::String {
    fn from(value: RequiredPackageSignaturesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RequiredPackageSignaturesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RequiredPackageSignaturesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RequiredPackageSignaturesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RequiredPackageSignaturesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RequiredPackageSignaturesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`RequiredStructuralTypesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RequiredStructuralTypesItem(::std::string::String);
impl ::std::ops::Deref for RequiredStructuralTypesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RequiredStructuralTypesItem> for ::std::string::String {
    fn from(value: RequiredStructuralTypesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RequiredStructuralTypesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RequiredStructuralTypesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RequiredStructuralTypesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RequiredStructuralTypesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RequiredStructuralTypesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`ResidualEntropyVectorsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ResidualEntropyVectorsItem(::std::string::String);
impl ::std::ops::Deref for ResidualEntropyVectorsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ResidualEntropyVectorsItem> for ::std::string::String {
    fn from(value: ResidualEntropyVectorsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ResidualEntropyVectorsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ResidualEntropyVectorsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ResidualEntropyVectorsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ResidualEntropyVectorsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ResidualEntropyVectorsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The specific FalsificationContract ID whose execution will trigger the market payout."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Resolution Oracle Condition Cid\","]
#[doc = "  \"description\": \"The specific FalsificationContract ID whose execution will trigger the market payout.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ResolutionOracleConditionCid(::std::string::String);
impl ::std::ops::Deref for ResolutionOracleConditionCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ResolutionOracleConditionCid> for ::std::string::String {
    fn from(value: ResolutionOracleConditionCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ResolutionOracleConditionCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ResolutionOracleConditionCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ResolutionOracleConditionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ResolutionOracleConditionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ResolutionOracleConditionCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SOTA mathematical heuristic used to project the new manifold."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Restructure Heuristic\","]
#[doc = "  \"description\": \"The SOTA mathematical heuristic used to project the new manifold.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"chronological\","]
#[doc = "    \"entity_centric\","]
#[doc = "    \"semantic_cluster\","]
#[doc = "    \"confidence_decay\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum RestructureHeuristic {
    #[serde(rename = "chronological")]
    Chronological,
    #[serde(rename = "entity_centric")]
    EntityCentric,
    #[serde(rename = "semantic_cluster")]
    SemanticCluster,
    #[serde(rename = "confidence_decay")]
    ConfidenceDecay,
}
impl ::std::fmt::Display for RestructureHeuristic {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Chronological => f.write_str("chronological"),
            Self::EntityCentric => f.write_str("entity_centric"),
            Self::SemanticCluster => f.write_str("semantic_cluster"),
            Self::ConfidenceDecay => f.write_str("confidence_decay"),
        }
    }
}
impl ::std::str::FromStr for RestructureHeuristic {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "chronological" => Ok(Self::Chronological),
            "entity_centric" => Ok(Self::EntityCentric),
            "semantic_cluster" => Ok(Self::SemanticCluster),
            "confidence_decay" => Ok(Self::ConfidenceDecay),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for RestructureHeuristic {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RestructureHeuristic {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RestructureHeuristic {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The 'stutter' state: the incomplete fragment of thought or text appended before the kill signal. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Retained Partial Payload\","]
#[doc = "  \"description\": \"The 'stutter' state: the incomplete fragment of thought or text appended before the kill signal. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "  \"anyOf\": ["]
#[doc = "    {"]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"string\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"null\""]
#[doc = "    }"]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum RetainedPartialPayload {
    Object(::std::collections::HashMap<::std::string::String, JsonPrimitiveState>),
    String(::std::string::String),
    Null,
}
impl ::std::convert::From<::std::collections::HashMap<::std::string::String, JsonPrimitiveState>>
    for RetainedPartialPayload
{
    fn from(value: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>) -> Self {
        Self::Object(value)
    }
}
#[doc = "`RetractedNodesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RetractedNodesItem(::std::string::String);
impl ::std::ops::Deref for RetractedNodesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RetractedNodesItem> for ::std::string::String {
    fn from(value: RetractedNodesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RetractedNodesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RetractedNodesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RetractedNodesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RetractedNodesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RetractedNodesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Dictates whether to cap valid_to bounds or destructively delete branches upon retroactive falsification."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Retroactive Falsification Mode\","]
#[doc = "  \"description\": \"Dictates whether to cap valid_to bounds or destructively delete branches upon retroactive falsification.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"cap_validity\","]
#[doc = "    \"delete_branch\","]
#[doc = "    \"preserve_as_counterfactual\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum RetroactiveFalsificationMode {
    #[serde(rename = "cap_validity")]
    CapValidity,
    #[serde(rename = "delete_branch")]
    DeleteBranch,
    #[serde(rename = "preserve_as_counterfactual")]
    PreserveAsCounterfactual,
}
impl ::std::fmt::Display for RetroactiveFalsificationMode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::CapValidity => f.write_str("cap_validity"),
            Self::DeleteBranch => f.write_str("delete_branch"),
            Self::PreserveAsCounterfactual => f.write_str("preserve_as_counterfactual"),
        }
    }
}
impl ::std::str::FromStr for RetroactiveFalsificationMode {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "cap_validity" => Ok(Self::CapValidity),
            "delete_branch" => Ok(Self::DeleteBranch),
            "preserve_as_counterfactual" => Ok(Self::PreserveAsCounterfactual),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for RetroactiveFalsificationMode {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RetroactiveFalsificationMode {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RetroactiveFalsificationMode {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "AGENT INSTRUCTION: Maps unstructured text segments into the strict logical confines of Rhetorical Structure Theory (RST), authorizing the extraction engine to build directed dependency graphs."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"RhetoricalStructureProfile\","]
#[doc = "  \"description\": \"AGENT INSTRUCTION: Maps unstructured text segments into the strict logical confines of Rhetorical Structure Theory (RST), authorizing the extraction engine to build directed dependency graphs.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"premise\","]
#[doc = "    \"conclusion\","]
#[doc = "    \"elaboration\","]
#[doc = "    \"contrast\","]
#[doc = "    \"concession\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum RhetoricalStructureProfile {
    #[serde(rename = "premise")]
    Premise,
    #[serde(rename = "conclusion")]
    Conclusion,
    #[serde(rename = "elaboration")]
    Elaboration,
    #[serde(rename = "contrast")]
    Contrast,
    #[serde(rename = "concession")]
    Concession,
}
impl ::std::fmt::Display for RhetoricalStructureProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Premise => f.write_str("premise"),
            Self::Conclusion => f.write_str("conclusion"),
            Self::Elaboration => f.write_str("elaboration"),
            Self::Contrast => f.write_str("contrast"),
            Self::Concession => f.write_str("concession"),
        }
    }
}
impl ::std::str::FromStr for RhetoricalStructureProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "premise" => Ok(Self::Premise),
            "conclusion" => Ok(Self::Conclusion),
            "elaboration" => Ok(Self::Elaboration),
            "contrast" => Ok(Self::Contrast),
            "concession" => Ok(Self::Concession),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for RhetoricalStructureProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RhetoricalStructureProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RhetoricalStructureProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "AGENT INSTRUCTION: Formalizes Quantitative Risk Assessment and Utility Theory, translating qualitative human threat vectors into computable scalar magnitudes that dictate systemic halting thresholds.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator's control theory loop to measure the aggregate expected utility loss of a proposed topology. It serves as the physical threshold that triggers hardware circuit breakers or forced escalation overrides.\n\nEPISTEMIC BOUNDS: The semantic strings are mathematically locked to an absolute integer space via the `weight` property (0, 1, 2). Rich comparison methods explicitly bridge the string definitions to integer evaluations, guaranteeing zero variance during distributed ledger verification.\n\nMCP ROUTING TRIGGERS: Quantitative Risk Assessment, Game Theory, Cybernetic Governance, Structural Circuit Breaker, Utility Theory"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"RiskLevelPolicy\","]
#[doc = "  \"description\": \"AGENT INSTRUCTION: Formalizes Quantitative Risk Assessment and Utility Theory, translating qualitative human threat vectors into computable scalar magnitudes that dictate systemic halting thresholds.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator's control theory loop to measure the aggregate expected utility loss of a proposed topology. It serves as the physical threshold that triggers hardware circuit breakers or forced escalation overrides.\\n\\nEPISTEMIC BOUNDS: The semantic strings are mathematically locked to an absolute integer space via the `weight` property (0, 1, 2). Rich comparison methods explicitly bridge the string definitions to integer evaluations, guaranteeing zero variance during distributed ledger verification.\\n\\nMCP ROUTING TRIGGERS: Quantitative Risk Assessment, Game Theory, Cybernetic Governance, Structural Circuit Breaker, Utility Theory\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"safe\","]
#[doc = "    \"standard\","]
#[doc = "    \"critical\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum RiskLevelPolicy {
    #[serde(rename = "safe")]
    Safe,
    #[serde(rename = "standard")]
    Standard,
    #[serde(rename = "critical")]
    Critical,
}
impl ::std::fmt::Display for RiskLevelPolicy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Safe => f.write_str("safe"),
            Self::Standard => f.write_str("standard"),
            Self::Critical => f.write_str("critical"),
        }
    }
}
impl ::std::str::FromStr for RiskLevelPolicy {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "safe" => Ok(Self::Safe),
            "standard" => Ok(Self::Standard),
            "critical" => Ok(Self::Critical),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for RiskLevelPolicy {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RiskLevelPolicy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RiskLevelPolicy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"RollbackIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"request_cid\","]
#[doc = "    \"target_event_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"invalidated_node_cids\": {"]
#[doc = "      \"title\": \"Invalidated Node Cids\","]
#[doc = "      \"description\": \"The strict array of nodes whose operational histories are causally tainted and must be flushed.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"request_cid\": {"]
#[doc = "      \"title\": \"Request Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the causal rollback operation.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_event_cid\": {"]
#[doc = "      \"title\": \"Target Event Cid\","]
#[doc = "      \"description\": \"The Content Identifier (CID) of the corrupted event in the EpistemicLedgerState to revert to.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"rollback_intent\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct RollbackIntent {
    #[doc = "The strict array of nodes whose operational histories are causally tainted and must be flushed."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub invalidated_node_cids: ::std::vec::Vec<InvalidatedNodeCidsItem>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the causal rollback operation."]
    pub request_cid: RequestCid,
    #[doc = "The Content Identifier (CID) of the corrupted event in the EpistemicLedgerState to revert to."]
    pub target_event_cid: TargetEventCid,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl RollbackIntent {
    pub fn builder() -> builder::RollbackIntent {
        Default::default()
    }
}
#[doc = "`RollbackPointersItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RollbackPointersItem(::std::string::String);
impl ::std::ops::Deref for RollbackPointersItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RollbackPointersItem> for ::std::string::String {
    fn from(value: RollbackPointersItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RollbackPointersItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RollbackPointersItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RollbackPointersItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RollbackPointersItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RollbackPointersItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`RootBlockCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Root Block Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RootBlockCid(::std::string::String);
impl ::std::ops::Deref for RootBlockCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RootBlockCid> for ::std::string::String {
    fn from(value: RootBlockCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RootBlockCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RootBlockCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RootBlockCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RootBlockCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RootBlockCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The source BeliefMutationEvent or HypothesisGenerationEvent Content Identifier (CID) that collapsed and triggered this cascade."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Root Falsified Event Cid\","]
#[doc = "  \"description\": \"The source BeliefMutationEvent or HypothesisGenerationEvent Content Identifier (CID) that collapsed and triggered this cascade.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RootFalsifiedEventCid(::std::string::String);
impl ::std::ops::Deref for RootFalsifiedEventCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RootFalsifiedEventCid> for ::std::string::String {
    fn from(value: RootFalsifiedEventCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RootFalsifiedEventCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RootFalsifiedEventCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RootFalsifiedEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RootFalsifiedEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RootFalsifiedEventCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The globally unique decentralized identifier (DID) anchoring the top-level TaxonomicNodeState initiating the tree."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Root Node Cid\","]
#[doc = "  \"description\": \"The globally unique decentralized identifier (DID) anchoring the top-level TaxonomicNodeState initiating the tree.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RootNodeCid(::std::string::String);
impl ::std::ops::Deref for RootNodeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RootNodeCid> for ::std::string::String {
    fn from(value: RootNodeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RootNodeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RootNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RootNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RootNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RootNodeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: The Multi-Objective Optimization matrix used to navigate the Spot-Market compute layer, calculating the Pareto Efficiency frontier between speed, cost, and intelligence.\n\nCAUSAL AFFORDANCE: Instructs the Spot-Market router on how to mechanically weigh competing inference engines. If a query requires extreme logic, it authorizes high cost; if it requires a UI reflex, it enforces strict latency bounds.\n\nEPISTEMIC BOUNDS: Strict physical, economic, and thermodynamic ceilings are mathematically enforced: `max_latency_ms` (`le=18446744073709551615`), `max_cost_magnitude_per_token` (`le=18446744073709551615`), and an absolute ESG bound via `max_carbon_intensity_gco2eq_kwh` (`le=18446744073709551615.0`).\n\nMCP ROUTING TRIGGERS: Pareto Efficiency, Multi-Objective Optimization, Spot-Market Routing, Carbon Budget, Compute Allocation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"RoutingFrontierPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: The Multi-Objective Optimization matrix used to navigate the Spot-Market compute layer, calculating the Pareto Efficiency frontier between speed, cost, and intelligence.\\n\\nCAUSAL AFFORDANCE: Instructs the Spot-Market router on how to mechanically weigh competing inference engines. If a query requires extreme logic, it authorizes high cost; if it requires a UI reflex, it enforces strict latency bounds.\\n\\nEPISTEMIC BOUNDS: Strict physical, economic, and thermodynamic ceilings are mathematically enforced: `max_latency_ms` (`le=18446744073709551615`), `max_cost_magnitude_per_token` (`le=18446744073709551615`), and an absolute ESG bound via `max_carbon_intensity_gco2eq_kwh` (`le=18446744073709551615.0`).\\n\\nMCP ROUTING TRIGGERS: Pareto Efficiency, Multi-Objective Optimization, Spot-Market Routing, Carbon Budget, Compute Allocation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_cost_magnitude_per_token\","]
#[doc = "    \"max_latency_ms\","]
#[doc = "    \"min_capability_score\","]
#[doc = "    \"tradeoff_preference\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_carbon_intensity_gco2eq_kwh\": {"]
#[doc = "      \"title\": \"Max Carbon Intensity Gco2Eq Kwh\","]
#[doc = "      \"description\": \"The maximum operational carbon intensity of the physical data center grid allowed for this agent's routing.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_cost_magnitude_per_token\": {"]
#[doc = "      \"title\": \"Max Cost Magnitude Per Token\","]
#[doc = "      \"description\": \"The strict magnitude ceiling. MUST be an integer to maintain cryptographic determinism.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"max_latency_ms\": {"]
#[doc = "      \"title\": \"Max Latency Ms\","]
#[doc = "      \"description\": \"The absolute physical speed limit acceptable for time-to-first-token or total generation.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"min_capability_score\": {"]
#[doc = "      \"title\": \"Min Capability Score\","]
#[doc = "      \"description\": \"The cognitive capability floor required for the task (0.0 to 1.0).\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"tradeoff_preference\": {"]
#[doc = "      \"title\": \"Tradeoff Preference\","]
#[doc = "      \"description\": \"The mathematical optimization vector to break ties within the frontier.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"latency_optimized\","]
#[doc = "        \"cost_optimized\","]
#[doc = "        \"capability_optimized\","]
#[doc = "        \"carbon_optimized\","]
#[doc = "        \"balanced\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct RoutingFrontierPolicy {
    #[doc = "The maximum operational carbon intensity of the physical data center grid allowed for this agent's routing."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_carbon_intensity_gco2eq_kwh: ::std::option::Option<f64>,
    #[doc = "The strict magnitude ceiling. MUST be an integer to maintain cryptographic determinism."]
    pub max_cost_magnitude_per_token: ::std::num::NonZeroU64,
    #[doc = "The absolute physical speed limit acceptable for time-to-first-token or total generation."]
    pub max_latency_ms: ::std::num::NonZeroU64,
    #[doc = "The cognitive capability floor required for the task (0.0 to 1.0)."]
    pub min_capability_score: f64,
    #[doc = "The mathematical optimization vector to break ties within the frontier."]
    pub tradeoff_preference: TradeoffPreference,
}
impl RoutingFrontierPolicy {
    pub fn builder() -> builder::RoutingFrontierPolicy {
        Default::default()
    }
}
#[doc = "The cryptographic pointer to the rubric dictating adjudication."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Rubric Cid\","]
#[doc = "  \"description\": \"The cryptographic pointer to the rubric dictating adjudication.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct RubricCid(::std::string::String);
impl ::std::ops::Deref for RubricCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<RubricCid> for ::std::string::String {
    fn from(value: RubricCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for RubricCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for RubricCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for RubricCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for RubricCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for RubricCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SHA-256 hash of the exact SAE projection matrix required to decode this feature."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Sae Dictionary Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the exact SAE projection matrix required to decode this feature.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SaeDictionaryHash(::std::string::String);
impl ::std::ops::Deref for SaeDictionaryHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SaeDictionaryHash> for ::std::string::String {
    fn from(value: SaeDictionaryHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SaeDictionaryHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SaeDictionaryHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SaeDictionaryHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SaeDictionaryHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SaeDictionaryHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Isolates a discrete, monosemantic feature from the foundational model's polysemantic residual stream using a Sparse Autoencoder (SAE) projection matrix.\n\nCAUSAL AFFORDANCE: Surfaces hidden geometric concept vectors (e.g., 'sycophancy' or 'truth_retrieval') to the orchestrator, enabling real-time circuit-level inspection, feature clamping, and causal tracing.\n\nEPISTEMIC BOUNDS: The semantic abstraction is rigidly bounded to a specific `feature_index` (`ge=0, le=18446744073709551615`). `activation_magnitude` physically measures Euclidean strength (`le=18446744073709551615`). Optional `interpretability_label` restricts semantic descriptions (`max_length=2000`).\n\nMCP ROUTING TRIGGERS: Sparse Autoencoder, Monosemantic Feature, Concept Vector, Mechanistic Interpretability, Euclidean Magnitude"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SaeFeatureActivationState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Isolates a discrete, monosemantic feature from the foundational model's polysemantic residual stream using a Sparse Autoencoder (SAE) projection matrix.\\n\\nCAUSAL AFFORDANCE: Surfaces hidden geometric concept vectors (e.g., 'sycophancy' or 'truth_retrieval') to the orchestrator, enabling real-time circuit-level inspection, feature clamping, and causal tracing.\\n\\nEPISTEMIC BOUNDS: The semantic abstraction is rigidly bounded to a specific `feature_index` (`ge=0, le=18446744073709551615`). `activation_magnitude` physically measures Euclidean strength (`le=18446744073709551615`). Optional `interpretability_label` restricts semantic descriptions (`max_length=2000`).\\n\\nMCP ROUTING TRIGGERS: Sparse Autoencoder, Monosemantic Feature, Concept Vector, Mechanistic Interpretability, Euclidean Magnitude\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"activation_magnitude\","]
#[doc = "    \"feature_index\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"activation_magnitude\": {"]
#[doc = "      \"title\": \"Activation Magnitude\","]
#[doc = "      \"description\": \"The mathematical strength of this feature's activation during the forward pass.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"feature_index\": {"]
#[doc = "      \"title\": \"Feature Index\","]
#[doc = "      \"description\": \"The exact dimensional index of the monosemantic feature in the Sparse Autoencoder dictionary.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"interpretability_label\": {"]
#[doc = "      \"title\": \"Interpretability Label\","]
#[doc = "      \"description\": \"The strictly typed semantic concept mapped to this feature (e.g., 'sycophancy', 'truth_retrieval').\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SaeFeatureActivationState {
    #[doc = "The mathematical strength of this feature's activation during the forward pass."]
    pub activation_magnitude: f64,
    #[doc = "The exact dimensional index of the monosemantic feature in the Sparse Autoencoder dictionary."]
    pub feature_index: u64,
    #[doc = "The strictly typed semantic concept mapped to this feature (e.g., 'sycophancy', 'truth_retrieval')."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub interpretability_label: ::std::option::Option<::std::string::String>,
}
impl SaeFeatureActivationState {
    pub fn builder() -> builder::SaeFeatureActivationState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Sparse Dictionary Learning and Mechanistic Interpretability to actively monitor and steer monosemantic neural circuits during the model's forward pass. Execution of this policy is strictly delegated to the external `TransformerLens` substrate to preserve the Hollow Data Plane constraints.\n\nCAUSAL AFFORDANCE: Executes real-time tensor remediation—clamping, halting, quarantining, or smoothly decaying residual stream activations—when specific features diverge toward adversarial or hallucinated geometries.\n\nEPISTEMIC BOUNDS: The `max_activation_threshold` (`ge=0.0, le=18446744073709551615.0`) physically bounds the continuous Euclidean magnitude of the `target_feature_index`. Topologically locked to SAE matrix via `sae_dictionary_hash` (SHA-256). The `@model_validator` `validate_smooth_decay` mathematically enforces asymptotic bounds.\n\nMCP ROUTING TRIGGERS: Mechanistic Interpretability, Sparse Autoencoders, Residual Stream Steering, Tensor Remediation, Monosemantic Features, TransformerLens, SAELens"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SaeLatentPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Sparse Dictionary Learning and Mechanistic Interpretability to actively monitor and steer monosemantic neural circuits during the model's forward pass. Execution of this policy is strictly delegated to the external `TransformerLens` substrate to preserve the Hollow Data Plane constraints.\\n\\nCAUSAL AFFORDANCE: Executes real-time tensor remediation—clamping, halting, quarantining, or smoothly decaying residual stream activations—when specific features diverge toward adversarial or hallucinated geometries.\\n\\nEPISTEMIC BOUNDS: The `max_activation_threshold` (`ge=0.0, le=18446744073709551615.0`) physically bounds the continuous Euclidean magnitude of the `target_feature_index`. Topologically locked to SAE matrix via `sae_dictionary_hash` (SHA-256). The `@model_validator` `validate_smooth_decay` mathematically enforces asymptotic bounds.\\n\\nMCP ROUTING TRIGGERS: Mechanistic Interpretability, Sparse Autoencoders, Residual Stream Steering, Tensor Remediation, Monosemantic Features, TransformerLens, SAELens\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_activation_threshold\","]
#[doc = "    \"monitored_hook_points\","]
#[doc = "    \"sae_dictionary_hash\","]
#[doc = "    \"target_feature_index\","]
#[doc = "    \"violation_action\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"clamp_value\": {"]
#[doc = "      \"title\": \"Clamp Value\","]
#[doc = "      \"description\": \"If violation_action is 'clamp', the physical value to which the activation tensor is forced.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_activation_threshold\": {"]
#[doc = "      \"title\": \"Max Activation Threshold\","]
#[doc = "      \"description\": \"The mathematical magnitude limit. If the feature activates beyond this, the firewall trips.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"monitored_hook_points\": {"]
#[doc = "      \"title\": \"Monitored Hook Points\","]
#[doc = "      \"description\": \"The specific TransformerLens hook points where this feature activation must be monitored.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 256,"]
#[doc = "        \"minLength\": 1,"]
#[doc = "        \"pattern\": \"^[a-zA-Z0-9_.]+$\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"sae_dictionary_hash\": {"]
#[doc = "      \"title\": \"Sae Dictionary Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the exact SAE projection matrix required to decode this feature.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"smoothing_profile\": {"]
#[doc = "      \"description\": \"The geometric parameters for continuous attenuation if violation_action is 'smooth_decay'.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/LatentSmoothingProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_feature_index\": {"]
#[doc = "      \"title\": \"Target Feature Index\","]
#[doc = "      \"description\": \"The exact dimensional index of the monosemantic feature in the Sparse Autoencoder dictionary.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"violation_action\": {"]
#[doc = "      \"title\": \"Violation Action\","]
#[doc = "      \"description\": \"The tensor-level remediation applied when the threshold is breached.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"clamp\","]
#[doc = "        \"halt\","]
#[doc = "        \"quarantine\","]
#[doc = "        \"smooth_decay\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SaeLatentPolicy {
    #[doc = "If violation_action is 'clamp', the physical value to which the activation tensor is forced."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub clamp_value: ::std::option::Option<f64>,
    #[doc = "The mathematical magnitude limit. If the feature activates beyond this, the firewall trips."]
    pub max_activation_threshold: f64,
    #[doc = "The specific TransformerLens hook points where this feature activation must be monitored."]
    pub monitored_hook_points: ::std::vec::Vec<MonitoredHookPointsItem>,
    #[doc = "The SHA-256 hash of the exact SAE projection matrix required to decode this feature."]
    pub sae_dictionary_hash: SaeDictionaryHash,
    #[doc = "The geometric parameters for continuous attenuation if violation_action is 'smooth_decay'."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub smoothing_profile: ::std::option::Option<LatentSmoothingProfile>,
    #[doc = "The exact dimensional index of the monosemantic feature in the Sparse Autoencoder dictionary."]
    pub target_feature_index: u64,
    #[doc = "The tensor-level remediation applied when the threshold is breached."]
    pub violation_action: ViolationAction,
}
impl SaeLatentPolicy {
    pub fn builder() -> builder::SaeLatentPolicy {
        Default::default()
    }
}
#[doc = "The SHA-256 hash of the cold-storage adapter weights file ensuring supply-chain zero-trust."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Safetensors Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the cold-storage adapter weights file ensuring supply-chain zero-trust.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SafetensorsHash(::std::string::String);
impl ::std::ops::Deref for SafetensorsHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SafetensorsHash> for ::std::string::String {
    fn from(value: SafetensorsHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SafetensorsHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SafetensorsHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SafetensorsHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SafetensorsHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SafetensorsHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements the Ebbinghaus Forgetting Curve and Temporal Difference (TD)\nattention weighting to mechanistically degrade the systemic relevance of older epistemic\ncoordinates. As a ...Profile suffix, this is a declarative, frozen snapshot.\n\nCAUSAL AFFORDANCE: Drives the mathematical heuristic for the orchestrator's EvictionPolicy,\ncontinuously attenuating context retention based on the prescribed decay_rate scalar to\nfreely recover GPU VRAM without catastrophic memory loss.\n\nEPISTEMIC BOUNDS: Both baseline_importance and decay_rate are physically clamped to normalized\nprobability vectors (ge=0.0, le=1.0). This strict bounding prevents exponential scalar explosion\nduring unbounded timeframe calculations.\n\nMCP ROUTING TRIGGERS: Ebbinghaus Forgetting Curve, Temporal Difference, Attention Decay, GPU VRAM Optimization, Memory Salience"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SalienceProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements the Ebbinghaus Forgetting Curve and Temporal Difference (TD)\\nattention weighting to mechanistically degrade the systemic relevance of older epistemic\\ncoordinates. As a ...Profile suffix, this is a declarative, frozen snapshot.\\n\\nCAUSAL AFFORDANCE: Drives the mathematical heuristic for the orchestrator's EvictionPolicy,\\ncontinuously attenuating context retention based on the prescribed decay_rate scalar to\\nfreely recover GPU VRAM without catastrophic memory loss.\\n\\nEPISTEMIC BOUNDS: Both baseline_importance and decay_rate are physically clamped to normalized\\nprobability vectors (ge=0.0, le=1.0). This strict bounding prevents exponential scalar explosion\\nduring unbounded timeframe calculations.\\n\\nMCP ROUTING TRIGGERS: Ebbinghaus Forgetting Curve, Temporal Difference, Attention Decay, GPU VRAM Optimization, Memory Salience\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"baseline_importance\","]
#[doc = "    \"decay_rate\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"baseline_importance\": {"]
#[doc = "      \"title\": \"Baseline Importance\","]
#[doc = "      \"description\": \"The starting importance score of this latent state from 0.0 to 1.0.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"decay_rate\": {"]
#[doc = "      \"title\": \"Decay Rate\","]
#[doc = "      \"description\": \"The rate at which this epistemic coordinate's relevance decays over time.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SalienceProfile {
    #[doc = "The starting importance score of this latent state from 0.0 to 1.0."]
    pub baseline_importance: f64,
    #[doc = "The rate at which this epistemic coordinate's relevance decays over time."]
    pub decay_rate: f64,
}
impl SalienceProfile {
    pub fn builder() -> builder::SalienceProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Stevens's levels of measurement and Wilkinson's Grammar of Graphics to mathematically project abstract data domains into visual geometric ranges.\n\nCAUSAL AFFORDANCE: Physically distorts or linearly maps the input metric tensor into rendering space, dictating how the orchestrator processes logarithmic, temporal, or ordinal data vectors for UI projection.\n\nEPISTEMIC BOUNDS: The transformation algorithm is strictly constrained to a Literal automaton `[\"linear\", \"log\", \"time\", \"ordinal\", \"nominal\"]`. Physical data boundaries (`domain_min`, `domain_max`) are upper-bounded by `le=18446744073709551615.0` to prevent geometric projection overflow.\n\nMCP ROUTING TRIGGERS: Grammar of Graphics, Metric Tensor Distortion, Levels of Measurement, Scale Projection, FSM Literal"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ScalePolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Stevens's levels of measurement and Wilkinson's Grammar of Graphics to mathematically project abstract data domains into visual geometric ranges.\\n\\nCAUSAL AFFORDANCE: Physically distorts or linearly maps the input metric tensor into rendering space, dictating how the orchestrator processes logarithmic, temporal, or ordinal data vectors for UI projection.\\n\\nEPISTEMIC BOUNDS: The transformation algorithm is strictly constrained to a Literal automaton `[\\\"linear\\\", \\\"log\\\", \\\"time\\\", \\\"ordinal\\\", \\\"nominal\\\"]`. Physical data boundaries (`domain_min`, `domain_max`) are upper-bounded by `le=18446744073709551615.0` to prevent geometric projection overflow.\\n\\nMCP ROUTING TRIGGERS: Grammar of Graphics, Metric Tensor Distortion, Levels of Measurement, Scale Projection, FSM Literal\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"topology_class\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"domain_max\": {"]
#[doc = "      \"title\": \"Domain Max\","]
#[doc = "      \"description\": \"The optional maximum bound of the scale domain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"domain_min\": {"]
#[doc = "      \"title\": \"Domain Min\","]
#[doc = "      \"description\": \"The optional minimum bound of the scale domain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The strictly typed mathematical mapping function distorting metrics into Euclidean pixel space.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"linear\","]
#[doc = "        \"log\","]
#[doc = "        \"time\","]
#[doc = "        \"ordinal\","]
#[doc = "        \"nominal\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ScalePolicy {
    #[doc = "The optional maximum bound of the scale domain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub domain_max: ::std::option::Option<f64>,
    #[doc = "The optional minimum bound of the scale domain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub domain_min: ::std::option::Option<f64>,
    #[doc = "The strictly typed mathematical mapping function distorting metrics into Euclidean pixel space."]
    pub topology_class: TopologyClass,
}
impl ScalePolicy {
    pub fn builder() -> builder::ScalePolicy {
        Default::default()
    }
}
#[doc = "The registered URI of the Pydantic schema used to generate the proxies."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Schema Blueprint Name\","]
#[doc = "  \"description\": \"The registered URI of the Pydantic schema used to generate the proxies.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 256"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SchemaBlueprintName(::std::string::String);
impl ::std::ops::Deref for SchemaBlueprintName {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SchemaBlueprintName> for ::std::string::String {
    fn from(value: SchemaBlueprintName) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SchemaBlueprintName {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 256usize {
            return Err("longer than 256 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SchemaBlueprintName {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SchemaBlueprintName {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SchemaBlueprintName {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SchemaBlueprintName {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SchemaDrivenExtractionSLA\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"extraction_framework\","]
#[doc = "    \"max_schema_retries\","]
#[doc = "    \"schema_registry_uri\","]
#[doc = "    \"validation_failure_action\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"extraction_framework\": {"]
#[doc = "      \"title\": \"Extraction Framework\","]
#[doc = "      \"description\": \"The URN of the specific extraction framework utilized (e.g., 'urn:coreason:extraction:docling_graph_explicit').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "    },"]
#[doc = "    \"linkml_governance\": {"]
#[doc = "      \"description\": \"The structural shape constraints for the graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/LinkMLValidationSLA\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_schema_retries\": {"]
#[doc = "      \"title\": \"Max Schema Retries\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"schema_registry_uri\": {"]
#[doc = "      \"title\": \"Schema Registry Uri\","]
#[doc = "      \"description\": \"RFC 8785 canonicalized URI to the exact Pydantic template or LinkML definition.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"format\": \"uri\","]
#[doc = "      \"minLength\": 1"]
#[doc = "    },"]
#[doc = "    \"validation_failure_action\": {"]
#[doc = "      \"title\": \"Validation Failure Action\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"quarantine_chunk\","]
#[doc = "        \"escalate_to_human\","]
#[doc = "        \"drop_edge\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SchemaDrivenExtractionSla {
    #[doc = "The URN of the specific extraction framework utilized (e.g., 'urn:coreason:extraction:docling_graph_explicit')."]
    pub extraction_framework: ExtractionFramework,
    #[doc = "The structural shape constraints for the graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub linkml_governance: ::std::option::Option<LinkMlValidationSla>,
    pub max_schema_retries: u64,
    #[doc = "RFC 8785 canonicalized URI to the exact Pydantic template or LinkML definition."]
    pub schema_registry_uri: ::std::string::String,
    pub validation_failure_action: ValidationFailureAction,
}
impl SchemaDrivenExtractionSla {
    pub fn builder() -> builder::SchemaDrivenExtractionSla {
        Default::default()
    }
}
#[doc = "The cryptographic namespace partitioning boundary. Global is public, Tenant is corporate, Session is ephemeral."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Scope\","]
#[doc = "  \"description\": \"The cryptographic namespace partitioning boundary. Global is public, Tenant is corporate, Session is ephemeral.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"global\","]
#[doc = "    \"tenant\","]
#[doc = "    \"session\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum Scope {
    #[serde(rename = "global")]
    Global,
    #[serde(rename = "tenant")]
    Tenant,
    #[serde(rename = "session")]
    Session,
}
impl ::std::fmt::Display for Scope {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Global => f.write_str("global"),
            Self::Tenant => f.write_str("tenant"),
            Self::Session => f.write_str("session"),
        }
    }
}
impl ::std::str::FromStr for Scope {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "global" => Ok(Self::Global),
            "tenant" => Ok(Self::Tenant),
            "session" => Ok(Self::Session),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for Scope {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Scope {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Scope {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents a strict rigid-body transformation within the Special Euclidean group SE(3). Projects an absolute mathematical coordinate encompassing both translation ($\\mathbb{R}^3$) and rotation ($S^3$).\n\nCAUSAL AFFORDANCE: Provides the absolute spatial terminus for UI matrices, multi-agent topologies, and multimodal tokens, dictating the exact kinematic positioning of a node relative to a verified SpatialReferenceFrameManifest.\n\nEPISTEMIC BOUNDS: Translation vectors are unbounded floats. Rotational geometry is rigidly constrained to a 4D unit quaternion bounded `[-1.0, 1.0]`. The `@model_validator` `enforce_quaternion_normalization` physically guarantees singularity-free rotation by enforcing an absolute quaternion magnitude of 1.0, eliminating Gimbal Lock. `scale` is bounded `[0.0001, 10000.0]`.\n\nMCP ROUTING TRIGGERS: Special Euclidean Group, SE(3) Manifold, Rigid Body Transformation, Hamiltonian Unit Quaternion, Kinematic Topology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SE3TransformProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents a strict rigid-body transformation within the Special Euclidean group SE(3). Projects an absolute mathematical coordinate encompassing both translation ($\\\\mathbb{R}^3$) and rotation ($S^3$).\\n\\nCAUSAL AFFORDANCE: Provides the absolute spatial terminus for UI matrices, multi-agent topologies, and multimodal tokens, dictating the exact kinematic positioning of a node relative to a verified SpatialReferenceFrameManifest.\\n\\nEPISTEMIC BOUNDS: Translation vectors are unbounded floats. Rotational geometry is rigidly constrained to a 4D unit quaternion bounded `[-1.0, 1.0]`. The `@model_validator` `enforce_quaternion_normalization` physically guarantees singularity-free rotation by enforcing an absolute quaternion magnitude of 1.0, eliminating Gimbal Lock. `scale` is bounded `[0.0001, 10000.0]`.\\n\\nMCP ROUTING TRIGGERS: Special Euclidean Group, SE(3) Manifold, Rigid Body Transformation, Hamiltonian Unit Quaternion, Kinematic Topology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"reference_frame_cid\","]
#[doc = "    \"x\","]
#[doc = "    \"y\","]
#[doc = "    \"z\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"dual_quaternion_motor\": {"]
#[doc = "      \"title\": \"Dual Quaternion Motor\","]
#[doc = "      \"description\": \"The 8-dimensional Clifford Algebra motor for mathematically flawless ScLERP interpolation.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"array\","]
#[doc = "          \"maxItems\": 8,"]
#[doc = "          \"minItems\": 8,"]
#[doc = "          \"prefixItems\": ["]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            }"]
#[doc = "          ]"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ],"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"kinematic_derivatives\": {"]
#[doc = "      \"description\": \"Tensors governing continuous momentum and velocity.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/KinematicDerivativeProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"qw\": {"]
#[doc = "      \"title\": \"Qw\","]
#[doc = "      \"description\": \"The real (scalar) part of the rotation quaternion.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": -1.0"]
#[doc = "    },"]
#[doc = "    \"qx\": {"]
#[doc = "      \"title\": \"Qx\","]
#[doc = "      \"description\": \"The i component of the rotation quaternion.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": -1.0"]
#[doc = "    },"]
#[doc = "    \"qy\": {"]
#[doc = "      \"title\": \"Qy\","]
#[doc = "      \"description\": \"The j component of the rotation quaternion.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": -1.0"]
#[doc = "    },"]
#[doc = "    \"qz\": {"]
#[doc = "      \"title\": \"Qz\","]
#[doc = "      \"description\": \"The k component of the rotation quaternion.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": -1.0"]
#[doc = "    },"]
#[doc = "    \"reference_frame_cid\": {"]
#[doc = "      \"title\": \"Reference Frame Cid\","]
#[doc = "      \"description\": \"The SpatialReferenceFrameManifest CID this coordinate is relative to, anchoring it to a physical or virtual room.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"scale\": {"]
#[doc = "      \"title\": \"Scale\","]
#[doc = "      \"description\": \"Strictly positive uniform volumetric scaling factor.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0001"]
#[doc = "    },"]
#[doc = "    \"x\": {"]
#[doc = "      \"title\": \"X\","]
#[doc = "      \"description\": \"Translation along the X-axis relative to the reference frame.\","]
#[doc = "      \"type\": \"number\""]
#[doc = "    },"]
#[doc = "    \"y\": {"]
#[doc = "      \"title\": \"Y\","]
#[doc = "      \"description\": \"Translation along the Y-axis relative to the reference frame.\","]
#[doc = "      \"type\": \"number\""]
#[doc = "    },"]
#[doc = "    \"z\": {"]
#[doc = "      \"title\": \"Z\","]
#[doc = "      \"description\": \"Translation along the Z-axis relative to the reference frame.\","]
#[doc = "      \"type\": \"number\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct Se3TransformProfile {
    #[doc = "The 8-dimensional Clifford Algebra motor for mathematically flawless ScLERP interpolation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub dual_quaternion_motor: ::std::option::Option<[::serde_json::Value; 8usize]>,
    #[doc = "Tensors governing continuous momentum and velocity."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub kinematic_derivatives: ::std::option::Option<KinematicDerivativeProfile>,
    #[doc = "The real (scalar) part of the rotation quaternion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub qw: ::std::option::Option<f64>,
    #[doc = "The i component of the rotation quaternion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub qx: ::std::option::Option<f64>,
    #[doc = "The j component of the rotation quaternion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub qy: ::std::option::Option<f64>,
    #[doc = "The k component of the rotation quaternion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub qz: ::std::option::Option<f64>,
    #[doc = "The SpatialReferenceFrameManifest CID this coordinate is relative to, anchoring it to a physical or virtual room."]
    pub reference_frame_cid: ReferenceFrameCid,
    #[doc = "Strictly positive uniform volumetric scaling factor."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub scale: ::std::option::Option<f64>,
    #[doc = "Translation along the X-axis relative to the reference frame."]
    pub x: f64,
    #[doc = "Translation along the Y-axis relative to the reference frame."]
    pub y: f64,
    #[doc = "Translation along the Z-axis relative to the reference frame."]
    pub z: f64,
}
impl Se3TransformProfile {
    pub fn builder() -> builder::Se3TransformProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes the Principle of Least Privilege (PoLP) and Time-Based Access Control (TBAC) for handling high-entropy cryptographic secrets within a declarative N-dimensional coordinate.\n\nCAUSAL AFFORDANCE: Authorizes a temporary, mathematically bounded partition where the agent can access unredacted enterprise vault keys without permanently leaking them into the global EpistemicLedgerState.\n\nEPISTEMIC BOUNDS: The temporal exposure window is physically clamped by `max_ttl_seconds` (`ge=1, le=18446744073709551615`), enforcing an absolute maximum 1-hour session. Spatial access is geometrically restricted to `allowed_vault_keys` (`max_length=100`), deterministically sorted by `@model_validator` for RFC 8785 hashing.\n\nMCP ROUTING TRIGGERS: Principle of Least Privilege, Time-Based Access Control, Secret Vaulting, Ephemeral Partition, Cryptographic Isolation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SecureSubSessionState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes the Principle of Least Privilege (PoLP) and Time-Based Access Control (TBAC) for handling high-entropy cryptographic secrets within a declarative N-dimensional coordinate.\\n\\nCAUSAL AFFORDANCE: Authorizes a temporary, mathematically bounded partition where the agent can access unredacted enterprise vault keys without permanently leaking them into the global EpistemicLedgerState.\\n\\nEPISTEMIC BOUNDS: The temporal exposure window is physically clamped by `max_ttl_seconds` (`ge=1, le=18446744073709551615`), enforcing an absolute maximum 1-hour session. Spatial access is geometrically restricted to `allowed_vault_keys` (`max_length=100`), deterministically sorted by `@model_validator` for RFC 8785 hashing.\\n\\nMCP ROUTING TRIGGERS: Principle of Least Privilege, Time-Based Access Control, Secret Vaulting, Ephemeral Partition, Cryptographic Isolation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"allowed_vault_keys\","]
#[doc = "    \"description\","]
#[doc = "    \"max_ttl_seconds\","]
#[doc = "    \"session_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"allowed_vault_keys\": {"]
#[doc = "      \"title\": \"Allowed Vault Keys\","]
#[doc = "      \"description\": \"The explicit array of enterprise vault keys the agent is temporarily allowed to access.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 100"]
#[doc = "    },"]
#[doc = "    \"description\": {"]
#[doc = "      \"title\": \"Description\","]
#[doc = "      \"description\": \"Audit justification for this temporary secure session.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"max_ttl_seconds\": {"]
#[doc = "      \"title\": \"Max Ttl Seconds\","]
#[doc = "      \"description\": \"Maximum time-to-live for the unredacted state partition.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"session_cid\": {"]
#[doc = "      \"title\": \"Session Cid\","]
#[doc = "      \"description\": \"Unique identifier for the secure session.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 255,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SecureSubSessionState {
    #[doc = "The explicit array of enterprise vault keys the agent is temporarily allowed to access."]
    pub allowed_vault_keys: ::std::vec::Vec<AllowedVaultKeysItem>,
    #[doc = "Audit justification for this temporary secure session."]
    pub description: Description,
    #[doc = "Maximum time-to-live for the unredacted state partition."]
    pub max_ttl_seconds: ::std::num::NonZeroU64,
    #[doc = "Unique identifier for the secure session."]
    pub session_cid: SessionCid,
}
impl SecureSubSessionState {
    pub fn builder() -> builder::SecureSubSessionState {
        Default::default()
    }
}
#[doc = "The SHA-256 hash of the origin seed used to initialize the VRF."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Seed Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the origin seed used to initialize the VRF.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 10,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SeedHash(::std::string::String);
impl ::std::ops::Deref for SeedHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SeedHash> for ::std::string::String {
    fn from(value: SeedHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SeedHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 10usize {
            return Err("shorter than 10 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SeedHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SeedHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SeedHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SeedHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The exact tool from the CognitiveActionSpaceManifest allocated for this experiment."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Selected Tool Name\","]
#[doc = "  \"description\": \"The exact tool from the CognitiveActionSpaceManifest allocated for this experiment.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SelectedToolName(::std::string::String);
impl ::std::ops::Deref for SelectedToolName {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SelectedToolName> for ::std::string::String {
    fn from(value: SelectedToolName) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SelectedToolName {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SelectedToolName {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SelectedToolName {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SelectedToolName {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SelectedToolName {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Acts as the System 2 executive controller, utilizing Non-Monotonic\nLogic and iterative backtracking to mathematically resolve structural, semantic, or\nkinetic execution errors. As a ...Policy suffix, this object defines rigid mathematical\nboundaries that the orchestrator must enforce globally.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator to physically rewind the causal DAG and\nretry generation paths via an Actor-Critic refinement loop when a System 1 failure or\nepistemic gap is detected.\n\nEPISTEMIC BOUNDS: Mathematically prevents infinite compute burn (State-Space Explosion)\nby strictly capping max_loops (ge=0, le=18446744073709551615). The rollback_on_failure boolean serves as\na physical fail-safe, forcing a deterministic reversion to the last pristine Merkle root\nif the loop ceiling is breached.\n\nMCP ROUTING TRIGGERS: Non-Monotonic Logic, Actor-Critic Refinement, System 2 Executive,\nBacktracking Search, State-Space Explosion Prevention"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SelfCorrectionPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Acts as the System 2 executive controller, utilizing Non-Monotonic\\nLogic and iterative backtracking to mathematically resolve structural, semantic, or\\nkinetic execution errors. As a ...Policy suffix, this object defines rigid mathematical\\nboundaries that the orchestrator must enforce globally.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator to physically rewind the causal DAG and\\nretry generation paths via an Actor-Critic refinement loop when a System 1 failure or\\nepistemic gap is detected.\\n\\nEPISTEMIC BOUNDS: Mathematically prevents infinite compute burn (State-Space Explosion)\\nby strictly capping max_loops (ge=0, le=18446744073709551615). The rollback_on_failure boolean serves as\\na physical fail-safe, forcing a deterministic reversion to the last pristine Merkle root\\nif the loop ceiling is breached.\\n\\nMCP ROUTING TRIGGERS: Non-Monotonic Logic, Actor-Critic Refinement, System 2 Executive,\\nBacktracking Search, State-Space Explosion Prevention\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_loops\","]
#[doc = "    \"rollback_on_failure\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_loops\": {"]
#[doc = "      \"title\": \"Max Loops\","]
#[doc = "      \"description\": \"The maximum number of self-correction loops allowed.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"rollback_on_failure\": {"]
#[doc = "      \"title\": \"Rollback On Failure\","]
#[doc = "      \"description\": \"Whether to rollback to the previous state on failure.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SelfCorrectionPolicy {
    #[doc = "The maximum number of self-correction loops allowed."]
    pub max_loops: u64,
    #[doc = "Whether to rollback to the previous state on failure."]
    pub rollback_on_failure: bool,
}
impl SelfCorrectionPolicy {
    pub fn builder() -> builder::SelfCorrectionPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Orchestrates zero-shot latent capability routing by computing the geometric Cosine Distance between the agent's epistemic deficit vector and the available tool manifold.\n\nCAUSAL AFFORDANCE: Unlocks the dynamic, runtime mounting of tools and MCP servers whose dense vector embeddings (`query_vector`) align mathematically with the query tensor, bypassing hardcoded tool schemas.\n\nEPISTEMIC BOUNDS: Mechanically rejects capabilities that fall below the `min_isometry_score` (`ge=-1.0, le=1.0`) boundary. The returned toolsets are strictly limited to the deterministically sorted `required_structural_types` array (`max_length=1000`), enforced by the `@model_validator`.\n\nMCP ROUTING TRIGGERS: Zero-Shot Tool Discovery, Capability Routing, Dense Vector Embedding, Epistemic Deficit Resolution"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SemanticDiscoveryIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Orchestrates zero-shot latent capability routing by computing the geometric Cosine Distance between the agent's epistemic deficit vector and the available tool manifold.\\n\\nCAUSAL AFFORDANCE: Unlocks the dynamic, runtime mounting of tools and MCP servers whose dense vector embeddings (`query_vector`) align mathematically with the query tensor, bypassing hardcoded tool schemas.\\n\\nEPISTEMIC BOUNDS: Mechanically rejects capabilities that fall below the `min_isometry_score` (`ge=-1.0, le=1.0`) boundary. The returned toolsets are strictly limited to the deterministically sorted `required_structural_types` array (`max_length=1000`), enforced by the `@model_validator`.\\n\\nMCP ROUTING TRIGGERS: Zero-Shot Tool Discovery, Capability Routing, Dense Vector Embedding, Epistemic Deficit Resolution\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"min_isometry_score\","]
#[doc = "    \"query_vector\","]
#[doc = "    \"required_structural_types\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"min_isometry_score\": {"]
#[doc = "      \"title\": \"Min Isometry Score\","]
#[doc = "      \"description\": \"The minimum cosine similarity required to authorize a capability mount.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": -1.0"]
#[doc = "    },"]
#[doc = "    \"query_vector\": {"]
#[doc = "      \"description\": \"The latent vector representation of the epistemic deficit the agent is trying to solve.\","]
#[doc = "      \"$ref\": \"#/$defs/VectorEmbeddingState\""]
#[doc = "    },"]
#[doc = "    \"required_structural_types\": {"]
#[doc = "      \"title\": \"Required Structural Types\","]
#[doc = "      \"description\": \"The strict array of strings defining topological limits on the discovered tools.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for geometric boundary of latent tool discovery.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"semantic_discovery\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SemanticDiscoveryIntent {
    #[doc = "The minimum cosine similarity required to authorize a capability mount."]
    pub min_isometry_score: f64,
    #[doc = "The latent vector representation of the epistemic deficit the agent is trying to solve."]
    pub query_vector: VectorEmbeddingState,
    #[doc = "The strict array of strings defining topological limits on the discovered tools."]
    pub required_structural_types: ::std::vec::Vec<RequiredStructuralTypesItem>,
    #[doc = "Discriminator for geometric boundary of latent tool discovery."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl SemanticDiscoveryIntent {
    pub fn builder() -> builder::SemanticDiscoveryIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A mathematical tensor bridging two SemanticNodeStates, executing\nJudea Pearl's Structural Causal Models (SCMs) to explicitly formalize causality,\ncorrelation, or confounding relationships across the Knowledge Graph. As a ...State\nsuffix, this is a frozen N-dimensional coordinate.\n\nCAUSAL AFFORDANCE: Empowers the orchestrator's traversal engine to execute directed\ngraph algorithms (e.g., Random Walk with Restart) via subject_node_cid and\nobject_node_cid (both 128-char CIDs), utilizing the continuous confidence_score\n(optional, ge=0.0, le=1.0, default=None) to probabilistically prune uncertain paths.\nThe predicate (max_length=2000) carries the semantic relationship label.\n\nEPISTEMIC BOUNDS: Causal directionality is restricted to a strict Literal automaton\n[\"causes\", \"confounds\", \"correlates_with\", \"undirected\"] (default=\"undirected\").\nOptional typed fields (embedding: VectorEmbeddingState, provenance:\nEpistemicProvenanceReceipt, temporal_bounds: TemporalBoundsProfile) extend the edge\ngeometry without mandatory overhead.\n\nMCP ROUTING TRIGGERS: Structural Causal Models, Pearlian Directed Edge, Semantic\nTriplet, Adjacency Matrix, Epistemic Link"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SemanticEdgeState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A mathematical tensor bridging two SemanticNodeStates, executing\\nJudea Pearl's Structural Causal Models (SCMs) to explicitly formalize causality,\\ncorrelation, or confounding relationships across the Knowledge Graph. As a ...State\\nsuffix, this is a frozen N-dimensional coordinate.\\n\\nCAUSAL AFFORDANCE: Empowers the orchestrator's traversal engine to execute directed\\ngraph algorithms (e.g., Random Walk with Restart) via subject_node_cid and\\nobject_node_cid (both 128-char CIDs), utilizing the continuous confidence_score\\n(optional, ge=0.0, le=1.0, default=None) to probabilistically prune uncertain paths.\\nThe predicate (max_length=2000) carries the semantic relationship label.\\n\\nEPISTEMIC BOUNDS: Causal directionality is restricted to a strict Literal automaton\\n[\\\"causes\\\", \\\"confounds\\\", \\\"correlates_with\\\", \\\"undirected\\\"] (default=\\\"undirected\\\").\\nOptional typed fields (embedding: VectorEmbeddingState, provenance:\\nEpistemicProvenanceReceipt, temporal_bounds: TemporalBoundsProfile) extend the edge\\ngeometry without mandatory overhead.\\n\\nMCP ROUTING TRIGGERS: Structural Causal Models, Pearlian Directed Edge, Semantic\\nTriplet, Adjacency Matrix, Epistemic Link\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"edge_cid\","]
#[doc = "    \"object_node_cid\","]
#[doc = "    \"predicate_curie\","]
#[doc = "    \"subject_node_cid\","]
#[doc = "    \"temporal_bounds\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"belief_vector\": {"]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/DempsterShaferBeliefVector\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"causal_relationship\": {"]
#[doc = "      \"title\": \"Causal Relationship\","]
#[doc = "      \"description\": \"The Pearlian directionality of the semantic relationship.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"causes\","]
#[doc = "        \"confounds\","]
#[doc = "        \"correlates_with\","]
#[doc = "        \"undirected\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"edge_cid\": {"]
#[doc = "      \"title\": \"Edge Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this semantic edge to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"embedding\": {"]
#[doc = "      \"description\": \"Topologically Bounded Latent Spaces used to calculate exact geometric distance and preserve structural Isometry.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/VectorEmbeddingState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"grounding_sla\": {"]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EvidentiaryGroundingSLA\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"object_node_cid\": {"]
#[doc = "      \"title\": \"Object Node Cid\","]
#[doc = "      \"description\": \"The destination SemanticNodeState Content Identifier (CID).\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"predicate_curie\": {"]
#[doc = "      \"title\": \"Predicate Curie\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$\","]
#[doc = "      \"rdf_edge_property\": true"]
#[doc = "    },"]
#[doc = "    \"provenance\": {"]
#[doc = "      \"description\": \"Optional distinct provenance if the relationship was inferred separately from the nodes.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EpistemicProvenanceReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"subject_node_cid\": {"]
#[doc = "      \"title\": \"Subject Node Cid\","]
#[doc = "      \"description\": \"The origin SemanticNodeState Content Identifier (CID).\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"temporal_bounds\": {"]
#[doc = "      \"description\": \"The strict time window during which this relationship holds true.\","]
#[doc = "      \"$ref\": \"#/$defs/TemporalBoundsProfile\""]
#[doc = "    },"]
#[doc = "    \"volumetric_geometry\": {"]
#[doc = "      \"description\": \"The continuous parametric spline defining the physical connection manifold.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/VolumetricEdgeProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SemanticEdgeState {
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub belief_vector: ::std::option::Option<DempsterShaferBeliefVector>,
    #[doc = "The Pearlian directionality of the semantic relationship."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub causal_relationship: ::std::option::Option<CausalRelationship>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this semantic edge to the Merkle-DAG."]
    pub edge_cid: EdgeCid,
    #[doc = "Topologically Bounded Latent Spaces used to calculate exact geometric distance and preserve structural Isometry."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub embedding: ::std::option::Option<VectorEmbeddingState>,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub grounding_sla: ::std::option::Option<EvidentiaryGroundingSla>,
    #[doc = "The destination SemanticNodeState Content Identifier (CID)."]
    pub object_node_cid: ObjectNodeCid,
    pub predicate_curie: PredicateCurie,
    #[doc = "Optional distinct provenance if the relationship was inferred separately from the nodes."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub provenance: ::std::option::Option<EpistemicProvenanceReceipt>,
    #[doc = "The origin SemanticNodeState Content Identifier (CID)."]
    pub subject_node_cid: SubjectNodeCid,
    #[doc = "The strict time window during which this relationship holds true."]
    pub temporal_bounds: TemporalBoundsProfile,
    #[doc = "The continuous parametric spline defining the physical connection manifold."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub volumetric_geometry: ::std::option::Option<VolumetricEdgeProfile>,
}
impl SemanticEdgeState {
    pub fn builder() -> builder::SemanticEdgeState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements an execution-layer Semantic Firewall guarding against\nadversarial control-flow overrides and prompt injection attacks. As a ...Policy suffix,\nthis object defines rigid mathematical boundaries that the orchestrator must enforce\nglobally.\n\nCAUSAL AFFORDANCE: Intercepts and physically severs incoming observation topologies if\ntheir classification matches forbidden_intents, executing the deterministic\naction_on_violation (Literal[\"drop\", \"quarantine\", \"redact\"]).\n\nEPISTEMIC BOUNDS: VRAM exhaustion is mathematically prevented by capping max_input_tokens\n(gt=0, le=18446744073709551615). The forbidden_intents array is deterministically sorted by the\n@model_validator to preserve RFC 8785 canonical hashing.\n\nMCP ROUTING TRIGGERS: Semantic Firewall, Prompt Injection Defense, Adversarial Override,\nZero-Trust Perimeter, Control-Flow Hijacking"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SemanticFirewallPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements an execution-layer Semantic Firewall guarding against\\nadversarial control-flow overrides and prompt injection attacks. As a ...Policy suffix,\\nthis object defines rigid mathematical boundaries that the orchestrator must enforce\\nglobally.\\n\\nCAUSAL AFFORDANCE: Intercepts and physically severs incoming observation topologies if\\ntheir classification matches forbidden_intents, executing the deterministic\\naction_on_violation (Literal[\\\"drop\\\", \\\"quarantine\\\", \\\"redact\\\"]).\\n\\nEPISTEMIC BOUNDS: VRAM exhaustion is mathematically prevented by capping max_input_tokens\\n(gt=0, le=18446744073709551615). The forbidden_intents array is deterministically sorted by the\\n@model_validator to preserve RFC 8785 canonical hashing.\\n\\nMCP ROUTING TRIGGERS: Semantic Firewall, Prompt Injection Defense, Adversarial Override,\\nZero-Trust Perimeter, Control-Flow Hijacking\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"action_on_violation\","]
#[doc = "    \"max_input_tokens\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"action_on_violation\": {"]
#[doc = "      \"title\": \"Action On Violation\","]
#[doc = "      \"description\": \"The deterministic action the orchestrator must take if a firewall rule is violated.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"drop\","]
#[doc = "        \"quarantine\","]
#[doc = "        \"redact\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"forbidden_intents\": {"]
#[doc = "      \"title\": \"Forbidden Intents\","]
#[doc = "      \"description\": \"A strict array of semantic intents (e.g., 'role_override', 'system_prompt_leak') that trigger immediate quarantine.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"max_input_tokens\": {"]
#[doc = "      \"title\": \"Max Input Tokens\","]
#[doc = "      \"description\": \"The absolute physical ceiling of tokens allowed in a single ingress payload.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SemanticFirewallPolicy {
    #[doc = "The deterministic action the orchestrator must take if a firewall rule is violated."]
    pub action_on_violation: ActionOnViolation,
    #[doc = "A strict array of semantic intents (e.g., 'role_override', 'system_prompt_leak') that trigger immediate quarantine."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub forbidden_intents: ::std::vec::Vec<ForbiddenIntentsItem>,
    #[doc = "The absolute physical ceiling of tokens allowed in a single ingress payload."]
    pub max_input_tokens: ::std::num::NonZeroU64,
}
impl SemanticFirewallPolicy {
    pub fn builder() -> builder::SemanticFirewallPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes the macroscopic Payload Loss Prevention (PLP) and\nLattice-Based Information Flow Control (IFC) bounds across the entire execution graph.\nAs a ...Policy suffix, this object defines rigid mathematical boundaries that the\norchestrator must enforce globally.\n\nCAUSAL AFFORDANCE: Projects a unified defensive mesh that aggregates RedactionPolicy\nrules, an optional SemanticFirewallPolicy intercept, and tensor-level SaeLatentPolicy\nfirewalls to comprehensively sanitize all graph edges. The active toggle controls\nwhether enforcement is live.\n\nEPISTEMIC BOUNDS: Ensures absolute deterministic evaluation by utilizing a\n@model_validator to physically sort the rules array by rule_cid and the latent_firewalls\narray by target_feature_index, guaranteeing an invariant Merkle root.\n\nMCP ROUTING TRIGGERS: Information Flow Control, Payload Loss Prevention, Lattice-Based\nSecurity, Biba Integrity Model, Defense-in-Depth"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SemanticFlowPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes the macroscopic Payload Loss Prevention (PLP) and\\nLattice-Based Information Flow Control (IFC) bounds across the entire execution graph.\\nAs a ...Policy suffix, this object defines rigid mathematical boundaries that the\\norchestrator must enforce globally.\\n\\nCAUSAL AFFORDANCE: Projects a unified defensive mesh that aggregates RedactionPolicy\\nrules, an optional SemanticFirewallPolicy intercept, and tensor-level SaeLatentPolicy\\nfirewalls to comprehensively sanitize all graph edges. The active toggle controls\\nwhether enforcement is live.\\n\\nEPISTEMIC BOUNDS: Ensures absolute deterministic evaluation by utilizing a\\n@model_validator to physically sort the rules array by rule_cid and the latent_firewalls\\narray by target_feature_index, guaranteeing an invariant Merkle root.\\n\\nMCP ROUTING TRIGGERS: Information Flow Control, Payload Loss Prevention, Lattice-Based\\nSecurity, Biba Integrity Model, Defense-in-Depth\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"policy_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"active\": {"]
#[doc = "      \"title\": \"Active\","]
#[doc = "      \"description\": \"Whether this policy is currently enforcing data sanitization.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"latent_firewalls\": {"]
#[doc = "      \"title\": \"Latent Firewalls\","]
#[doc = "      \"description\": \"The strict array of tensor-level mechanistic firewalls monitoring the forward pass for adversarial intent.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/SaeLatentPolicy\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"policy_cid\": {"]
#[doc = "      \"title\": \"Policy Cid\","]
#[doc = "      \"description\": \"Unique identifier for this macroscopic flow control policy.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"semantic_firewall\": {"]
#[doc = "      \"description\": \"The active cognitive defense perimeter against adversarial control-flow overrides.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticFirewallPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SemanticFlowPolicy {
    #[doc = "Whether this policy is currently enforcing data sanitization."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub active: ::std::option::Option<bool>,
    #[doc = "The strict array of tensor-level mechanistic firewalls monitoring the forward pass for adversarial intent."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub latent_firewalls: ::std::vec::Vec<SaeLatentPolicy>,
    #[doc = "Unique identifier for this macroscopic flow control policy."]
    pub policy_cid: PolicyCid,
    #[doc = "The active cognitive defense perimeter against adversarial control-flow overrides."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_firewall: ::std::option::Option<SemanticFirewallPolicy>,
}
impl SemanticFlowPolicy {
    pub fn builder() -> builder::SemanticFlowPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Synchronous Epistemic Signaling within a Mixed-Initiative Control paradigm. Indicates that the presented manifold requires acknowledgment without reciprocal causal action.\n\nCAUSAL AFFORDANCE: Conditionally suspends the continuous execution DAG to project a read-only observational state manifold to the human operator. Resumption is dynamically governed by the deterministic `timeout_action`.\n\nEPISTEMIC BOUNDS: The semantic payload (`message`) is physically clamped to `max_length=2000` to prevent UI dictionary bombing. The `timeout_action` is locked to a strict Finite State Machine Literal `[\"rollback\", \"proceed_default\", \"terminate\"]`.\n\nMCP ROUTING TRIGGERS: Synchronous Epistemic Signaling, Mixed-Initiative Control, Finite State Machine, Oracle Projection, Halting Problem"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SemanticIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Synchronous Epistemic Signaling within a Mixed-Initiative Control paradigm. Indicates that the presented manifold requires acknowledgment without reciprocal causal action.\\n\\nCAUSAL AFFORDANCE: Conditionally suspends the continuous execution DAG to project a read-only observational state manifold to the human operator. Resumption is dynamically governed by the deterministic `timeout_action`.\\n\\nEPISTEMIC BOUNDS: The semantic payload (`message`) is physically clamped to `max_length=2000` to prevent UI dictionary bombing. The `timeout_action` is locked to a strict Finite State Machine Literal `[\\\"rollback\\\", \\\"proceed_default\\\", \\\"terminate\\\"]`.\\n\\nMCP ROUTING TRIGGERS: Synchronous Epistemic Signaling, Mixed-Initiative Control, Finite State Machine, Oracle Projection, Halting Problem\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"message\","]
#[doc = "    \"timeout_action\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"message\": {"]
#[doc = "      \"title\": \"Message\","]
#[doc = "      \"description\": \"The context or summary to display to the human operator.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"timeout_action\": {"]
#[doc = "      \"title\": \"Timeout Action\","]
#[doc = "      \"description\": \"The orchestrator's automatic fallback if the human does not acknowledge the intent in time.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"rollback\","]
#[doc = "        \"proceed_default\","]
#[doc = "        \"terminate\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The discriminative topological boundary for read-only informational handoffs.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"informational\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SemanticIntent {
    #[doc = "The context or summary to display to the human operator."]
    pub message: Message,
    #[doc = "The orchestrator's automatic fallback if the human does not acknowledge the intent in time."]
    pub timeout_action: TimeoutAction,
    #[doc = "The discriminative topological boundary for read-only informational handoffs."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl SemanticIntent {
    pub fn builder() -> builder::SemanticIntent {
        Default::default()
    }
}
#[doc = "The human-legible, dynamically synthesized categorical label (e.g., 'High Risk Policies')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Semantic Label\","]
#[doc = "  \"description\": \"The human-legible, dynamically synthesized categorical label (e.g., 'High Risk Policies').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SemanticLabel(::std::string::String);
impl ::std::ops::Deref for SemanticLabel {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SemanticLabel> for ::std::string::String {
    fn from(value: SemanticLabel) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SemanticLabel {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SemanticLabel {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SemanticLabel {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SemanticLabel {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SemanticLabel {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A formal cryptographic petition submitted by an agent to update the swarm's internal graph logic. Compiles discovered literature and external API responses into a mathematically verifiable semantic mapping rule (e.g., SWRL).\n\n    CAUSAL AFFORDANCE: Physically authorizes the orchestrator to inject a new heuristic into the swarm's global hypothesis space.\n\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\n\n    MCP ROUTING TRIGGERS: Semantic Mapping, Heuristic Injection, Cryptographic Petition, Swarm Logic"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SemanticMappingHeuristicIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A formal cryptographic petition submitted by an agent to update the swarm's internal graph logic. Compiles discovered literature and external API responses into a mathematically verifiable semantic mapping rule (e.g., SWRL).\\n\\n    CAUSAL AFFORDANCE: Physically authorizes the orchestrator to inject a new heuristic into the swarm's global hypothesis space.\\n\\n    EPISTEMIC BOUNDS: Bounded to strict JSON schema validation constraints defined in the manifest.\\n\\n    MCP ROUTING TRIGGERS: Semantic Mapping, Heuristic Injection, Cryptographic Petition, Swarm Logic\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"formal_logic_clauses\","]
#[doc = "    \"justification_evidence_cids\","]
#[doc = "    \"proposal_cid\","]
#[doc = "    \"source_ontology_namespace\","]
#[doc = "    \"target_ontology_namespace\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"formal_logic_clauses\": {"]
#[doc = "      \"title\": \"Formal Logic Clauses\","]
#[doc = "      \"description\": \"The exact topological logic required to execute the crosswalk, strictly written as a flat, executable formal logic string (e.g., SWRL, ASP, or Prolog syntax) rather than a nested dictionary.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 65536"]
#[doc = "    },"]
#[doc = "    \"justification_evidence_cids\": {"]
#[doc = "      \"title\": \"Justification Evidence Cids\","]
#[doc = "      \"description\": \"Explicit pointers to the AtomicPropositionState or OntologicalReificationReceipt nodes that causally justify this new mapping rule.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"proposal_cid\": {"]
#[doc = "      \"title\": \"Proposal Cid\","]
#[doc = "      \"description\": \"The cryptographic Merkle-DAG anchor for the proposal.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"source_ontology_namespace\": {"]
#[doc = "      \"title\": \"Source Ontology Namespace\","]
#[doc = "      \"description\": \"The origin namespace (e.g., ICD-10, USC).\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"target_ontology_namespace\": {"]
#[doc = "      \"title\": \"Target Ontology Namespace\","]
#[doc = "      \"description\": \"The destination namespace (e.g., SNOMED-CT, CFR).\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for semantic heuristic proposals.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"semantic_mapping_proposal\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SemanticMappingHeuristicIntent {
    #[doc = "The exact topological logic required to execute the crosswalk, strictly written as a flat, executable formal logic string (e.g., SWRL, ASP, or Prolog syntax) rather than a nested dictionary."]
    pub formal_logic_clauses: FormalLogicClauses,
    #[doc = "Explicit pointers to the AtomicPropositionState or OntologicalReificationReceipt nodes that causally justify this new mapping rule."]
    pub justification_evidence_cids: ::std::vec::Vec<NodeCidState>,
    #[doc = "The cryptographic Merkle-DAG anchor for the proposal."]
    pub proposal_cid: ProposalCid,
    #[doc = "The origin namespace (e.g., ICD-10, USC)."]
    pub source_ontology_namespace: SourceOntologyNamespace,
    #[doc = "The destination namespace (e.g., SNOMED-CT, CFR)."]
    pub target_ontology_namespace: TargetOntologyNamespace,
    #[doc = "Discriminator for semantic heuristic proposals."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl SemanticMappingHeuristicIntent {
    pub fn builder() -> builder::SemanticMappingHeuristicIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative, frozen N-dimensional coordinate representing a\ndiscrete entity vertex within a Resource Description Framework (RDF) or continuous\nProperty Graph. As a ...State suffix, this is a mathematically immutable snapshot.\n\nCAUSAL AFFORDANCE: Unlocks privacy-preserving mathematical operations on encrypted\nstate via fhe_profile (HomomorphicEncryptionProfile, optional) and enables zero-shot\nsemantic routing based on dense vector distances (embedding: VectorEmbeddingState,\noptional). Provenance (EpistemicProvenanceReceipt) is required.\n\nEPISTEMIC BOUNDS: The vertex geometry is physically anchored by node_cid (128-char CID\nregex). The internal representation (text_chunk) is capped at max_length=50000. The\nscope Literal [\"global\", \"tenant\", \"session\"] (default=\"session\") partitions the\ncryptographic namespace. The tier (CognitiveTierProfile, default=\"semantic\") and\nsalience (SalienceProfile, optional) govern structural pruning.\n\nMCP ROUTING TRIGGERS: Resource Description Framework, Property Graph, Fully\nHomomorphic Encryption, Semantic Coordinate, Vector Embedding"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SemanticNodeState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative, frozen N-dimensional coordinate representing a\\ndiscrete entity vertex within a Resource Description Framework (RDF) or continuous\\nProperty Graph. As a ...State suffix, this is a mathematically immutable snapshot.\\n\\nCAUSAL AFFORDANCE: Unlocks privacy-preserving mathematical operations on encrypted\\nstate via fhe_profile (HomomorphicEncryptionProfile, optional) and enables zero-shot\\nsemantic routing based on dense vector distances (embedding: VectorEmbeddingState,\\noptional). Provenance (EpistemicProvenanceReceipt) is required.\\n\\nEPISTEMIC BOUNDS: The vertex geometry is physically anchored by node_cid (128-char CID\\nregex). The internal representation (text_chunk) is capped at max_length=50000. The\\nscope Literal [\\\"global\\\", \\\"tenant\\\", \\\"session\\\"] (default=\\\"session\\\") partitions the\\ncryptographic namespace. The tier (CognitiveTierProfile, default=\\\"semantic\\\") and\\nsalience (SalienceProfile, optional) govern structural pruning.\\n\\nMCP ROUTING TRIGGERS: Resource Description Framework, Property Graph, Fully\\nHomomorphic Encryption, Semantic Coordinate, Vector Embedding\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"label\","]
#[doc = "    \"node_cid\","]
#[doc = "    \"provenance\","]
#[doc = "    \"temporal_bounds\","]
#[doc = "    \"text_chunk\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"canonical_uri\": {"]
#[doc = "      \"title\": \"Canonical Uri\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\","]
#[doc = "          \"format\": \"uri\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ],"]
#[doc = "      \"rdf_predicate\": \"owl:sameAs\""]
#[doc = "    },"]
#[doc = "    \"embedding\": {"]
#[doc = "      \"description\": \"Topologically Bounded Latent Spaces used to calculate exact geometric distance and preserve structural Isometry.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/VectorEmbeddingState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"fhe_profile\": {"]
#[doc = "      \"description\": \"The cryptographic envelope enabling privacy-preserving computation directly on this node's encrypted state.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/HomomorphicEncryptionProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"label\": {"]
#[doc = "      \"title\": \"Label\","]
#[doc = "      \"description\": \"The categorical label of the node (e.g., 'Person', 'Concept').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000,"]
#[doc = "      \"rdf_predicate\": \"rdfs:label\""]
#[doc = "    },"]
#[doc = "    \"node_cid\": {"]
#[doc = "      \"title\": \"Node Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this semantic node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\","]
#[doc = "      \"rdf_subject\": true"]
#[doc = "    },"]
#[doc = "    \"provenance\": {"]
#[doc = "      \"description\": \"The cryptographic chain of custody for this semantic state.\","]
#[doc = "      \"$ref\": \"#/$defs/EpistemicProvenanceReceipt\""]
#[doc = "    },"]
#[doc = "    \"salience\": {"]
#[doc = "      \"description\": \"The mathematical importance profile governing structural pruning.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SalienceProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"scope\": {"]
#[doc = "      \"title\": \"Scope\","]
#[doc = "      \"description\": \"The cryptographic namespace partitioning boundary. Global is public, Tenant is corporate, Session is ephemeral.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"global\","]
#[doc = "        \"tenant\","]
#[doc = "        \"session\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"spatial_manifold_mappings\": {"]
#[doc = "      \"title\": \"Spatial Manifold Mappings\","]
#[doc = "      \"description\": \"Optional geometric projections binding this discrete node to a continuous spatial rendering environment.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/ContinuousManifoldMappingContract\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"temporal_bounds\": {"]
#[doc = "      \"description\": \"The strict time window during which this node is considered valid.\","]
#[doc = "      \"$ref\": \"#/$defs/TemporalBoundsProfile\""]
#[doc = "    },"]
#[doc = "    \"text_chunk\": {"]
#[doc = "      \"title\": \"Text Chunk\","]
#[doc = "      \"description\": \"The raw natural language representation of the semantic node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 50000,"]
#[doc = "      \"rdf_predicate\": \"schema:description\""]
#[doc = "    },"]
#[doc = "    \"tier\": {"]
#[doc = "      \"description\": \"The cognitive tier this latent state resides in.\","]
#[doc = "      \"$ref\": \"#/$defs/CognitiveTierProfile\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SemanticNodeState {
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub canonical_uri: ::std::option::Option<::std::string::String>,
    #[doc = "Topologically Bounded Latent Spaces used to calculate exact geometric distance and preserve structural Isometry."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub embedding: ::std::option::Option<VectorEmbeddingState>,
    #[doc = "The cryptographic envelope enabling privacy-preserving computation directly on this node's encrypted state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub fhe_profile: ::std::option::Option<HomomorphicEncryptionProfile>,
    #[doc = "The categorical label of the node (e.g., 'Person', 'Concept')."]
    pub label: Label,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this semantic node to the Merkle-DAG."]
    pub node_cid: NodeCid,
    #[doc = "The cryptographic chain of custody for this semantic state."]
    pub provenance: EpistemicProvenanceReceipt,
    #[doc = "The mathematical importance profile governing structural pruning."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub salience: ::std::option::Option<SalienceProfile>,
    #[doc = "The cryptographic namespace partitioning boundary. Global is public, Tenant is corporate, Session is ephemeral."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub scope: ::std::option::Option<Scope>,
    #[doc = "Optional geometric projections binding this discrete node to a continuous spatial rendering environment."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub spatial_manifold_mappings: ::std::vec::Vec<ContinuousManifoldMappingContract>,
    #[doc = "The strict time window during which this node is considered valid."]
    pub temporal_bounds: TemporalBoundsProfile,
    #[doc = "The raw natural language representation of the semantic node."]
    pub text_chunk: TextChunk,
    #[doc = "The cognitive tier this latent state resides in."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub tier: ::std::option::Option<CognitiveTierProfile>,
}
impl SemanticNodeState {
    pub fn builder() -> builder::SemanticNodeState {
        Default::default()
    }
}
#[doc = "The core semantic instruction for the blind LLM planner."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Semantic Planning Task\","]
#[doc = "  \"description\": \"The core semantic instruction for the blind LLM planner.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 4096"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SemanticPlanningTask(::std::string::String);
impl ::std::ops::Deref for SemanticPlanningTask {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SemanticPlanningTask> for ::std::string::String {
    fn from(value: SemanticPlanningTask) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SemanticPlanningTask {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 4096usize {
            return Err("longer than 4096 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SemanticPlanningTask {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SemanticPlanningTask {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SemanticPlanningTask {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SemanticPlanningTask {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents the untyped payload injection zone for harmonized structured telemetry.\n\n    CAUSAL AFFORDANCE: Permits specialized downstream agents to project and decode specific industry payloads (e.g., OMOP CDM, FIX protocol) while preserving universal mathematical traversal of the graph.\n\n    EPISTEMIC BOUNDS: The payload_injection_zone is routed through the volumetric hardware guillotine.\n\n    MCP ROUTING TRIGGERS: Semantic Relational Record, Payload Injection, Hardware Guillotine, Structured Telemetry"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SemanticRelationalVectorState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents the untyped payload injection zone for harmonized structured telemetry.\\n\\n    CAUSAL AFFORDANCE: Permits specialized downstream agents to project and decode specific industry payloads (e.g., OMOP CDM, FIX protocol) while preserving universal mathematical traversal of the graph.\\n\\n    EPISTEMIC BOUNDS: The payload_injection_zone is routed through the volumetric hardware guillotine.\\n\\n    MCP ROUTING TRIGGERS: Semantic Relational Record, Payload Injection, Hardware Guillotine, Structured Telemetry\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"ontology_class\","]
#[doc = "    \"payload_injection_zone\","]
#[doc = "    \"temporal_bounds\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"formal_schema_urn\": {"]
#[doc = "      \"title\": \"Formal Schema Urn\","]
#[doc = "      \"description\": \"The formal URN mathematically binding the untyped payload_injection_zone to a verified external standard (e.g., 'urn:coreason:schema:omop_cdm_v5').\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"multivariate_latent_projection\": {"]
#[doc = "      \"description\": \"The high-dimensional tabular embedding resolving the entire multivariate row into a holistic event meaning.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/VectorEmbeddingState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"ontology_class\": {"]
#[doc = "      \"description\": \"The domain-independent structural classification of the record.\","]
#[doc = "      \"$ref\": \"#/$defs/UpperOntologyClassProfile\""]
#[doc = "    },"]
#[doc = "    \"payload_injection_zone\": {"]
#[doc = "      \"title\": \"Payload Injection Zone\","]
#[doc = "      \"description\": \"The domain-specific payload, structurally governed by the formal_schema_urn to prevent semantic hallucinations.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The RFC 8785 Canonical hash of the immediate causal ancestor, securing the Merkle-DAG.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"temporal_bounds\": {"]
#[doc = "      \"description\": \"The temporal mapping of the event.\","]
#[doc = "      \"$ref\": \"#/$defs/TemporalBoundsProfile\""]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"The precise temporal coordinate of the event realization.\","]
#[doc = "      \"type\": \"number\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"semantic_relational_record\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SemanticRelationalVectorState {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The formal URN mathematically binding the untyped payload_injection_zone to a verified external standard (e.g., 'urn:coreason:schema:omop_cdm_v5')."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub formal_schema_urn: ::std::option::Option<::std::string::String>,
    #[doc = "The high-dimensional tabular embedding resolving the entire multivariate row into a holistic event meaning."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub multivariate_latent_projection: ::std::option::Option<VectorEmbeddingState>,
    #[doc = "The domain-independent structural classification of the record."]
    pub ontology_class: UpperOntologyClassProfile,
    #[doc = "The domain-specific payload, structurally governed by the formal_schema_urn to prevent semantic hallucinations."]
    pub payload_injection_zone:
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "The RFC 8785 Canonical hash of the immediate causal ancestor, securing the Merkle-DAG."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The temporal mapping of the event."]
    pub temporal_bounds: TemporalBoundsProfile,
    #[doc = "The precise temporal coordinate of the event realization."]
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl SemanticRelationalVectorState {
    pub fn builder() -> builder::SemanticRelationalVectorState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Mandatory Access Control (MAC) and Cognitive Load Theory to aggressively cull context window topologies and prevent VRAM exhaustion.\n\nCAUSAL AFFORDANCE: Forces the attention mechanism to physically ignore state representations that lack the whitelisted `required_semantic_labels` or exceed the `permitted_classification_tiers`.\n\nEPISTEMIC BOUNDS: VRAM exhaustion is clamped by `context_window_token_ceiling` (`gt=0, le=2000000`). The validation pipeline mechanically sorts the tier arrays via `@model_validator` for invariant RFC 8785 canonical determinism.\n\nMCP ROUTING TRIGGERS: Mandatory Access Control, Zero-Trust Execution, Context Window Partitioning, Cognitive Load Theory, Epistemic Firewall"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SemanticSlicingPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Mandatory Access Control (MAC) and Cognitive Load Theory to aggressively cull context window topologies and prevent VRAM exhaustion.\\n\\nCAUSAL AFFORDANCE: Forces the attention mechanism to physically ignore state representations that lack the whitelisted `required_semantic_labels` or exceed the `permitted_classification_tiers`.\\n\\nEPISTEMIC BOUNDS: VRAM exhaustion is clamped by `context_window_token_ceiling` (`gt=0, le=2000000`). The validation pipeline mechanically sorts the tier arrays via `@model_validator` for invariant RFC 8785 canonical determinism.\\n\\nMCP ROUTING TRIGGERS: Mandatory Access Control, Zero-Trust Execution, Context Window Partitioning, Cognitive Load Theory, Epistemic Firewall\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"context_window_token_ceiling\","]
#[doc = "    \"permitted_classification_tiers\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"context_window_token_ceiling\": {"]
#[doc = "      \"title\": \"Context Window Token Ceiling\","]
#[doc = "      \"description\": \"The mathematical physical limit of the active context partition to prevent VRAM exhaustion.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 2000000.0,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"permitted_classification_tiers\": {"]
#[doc = "      \"title\": \"Permitted Classification Tiers\","]
#[doc = "      \"description\": \"The explicit whitelist of sensitivity bounds allowed into context.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"enum\": ["]
#[doc = "          \"public\","]
#[doc = "          \"internal\","]
#[doc = "          \"confidential\","]
#[doc = "          \"restricted\""]
#[doc = "        ]"]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"required_semantic_labels\": {"]
#[doc = "      \"title\": \"Required Semantic Labels\","]
#[doc = "      \"description\": \"The declarative whitelist of strictly typed ontological node labels authorized for context projection.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"array\","]
#[doc = "          \"items\": {"]
#[doc = "            \"type\": \"string\","]
#[doc = "            \"maxLength\": 255"]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SemanticSlicingPolicy {
    #[doc = "The mathematical physical limit of the active context partition to prevent VRAM exhaustion."]
    pub context_window_token_ceiling: ::std::num::NonZeroU64,
    #[doc = "The explicit whitelist of sensitivity bounds allowed into context."]
    pub permitted_classification_tiers: ::std::vec::Vec<PermittedClassificationTiersItem>,
    #[doc = "The declarative whitelist of strictly typed ontological node labels authorized for context projection."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub required_semantic_labels:
        ::std::option::Option<::std::vec::Vec<SemanticSlicingPolicyRequiredSemanticLabelsItem>>,
}
impl SemanticSlicingPolicy {
    pub fn builder() -> builder::SemanticSlicingPolicy {
        Default::default()
    }
}
#[doc = "`SemanticSlicingPolicyRequiredSemanticLabelsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SemanticSlicingPolicyRequiredSemanticLabelsItem(::std::string::String);
impl ::std::ops::Deref for SemanticSlicingPolicyRequiredSemanticLabelsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SemanticSlicingPolicyRequiredSemanticLabelsItem>
    for ::std::string::String
{
    fn from(value: SemanticSlicingPolicyRequiredSemanticLabelsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SemanticSlicingPolicyRequiredSemanticLabelsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SemanticSlicingPolicyRequiredSemanticLabelsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String>
    for SemanticSlicingPolicyRequiredSemanticLabelsItem
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String>
    for SemanticSlicingPolicyRequiredSemanticLabelsItem
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SemanticSlicingPolicyRequiredSemanticLabelsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "An Immutable structural checkpoint."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"description\": \"An Immutable structural checkpoint.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^\\\\d+\\\\.\\\\d+\\\\.\\\\d+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SemanticVersionState(::std::string::String);
impl ::std::ops::Deref for SemanticVersionState {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SemanticVersionState> for ::std::string::String {
    fn from(value: SemanticVersionState) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SemanticVersionState {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^\\d+\\.\\d+\\.\\d+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^\\d+\\.\\d+\\.\\d+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SemanticVersionState {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SemanticVersionState {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SemanticVersionState {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SemanticVersionState {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes the Information Bottleneck principle to execute Semantic Zooming. It defines the exact Euclidean distance thresholds at which a node's semantic payload deterministically degrades to preserve computational entropy.\n\nCAUSAL AFFORDANCE: Instructs the spatial projection engine to dynamically collapse high-entropy unstructured text into low-entropy scalars or categorical labels as the observer's SE(3) camera recedes.\n\nEPISTEMIC BOUNDS: The thresholds are bounded to continuous physical distance in meters (`ge=0.0`). A strict mathematical invariant guaranteed by a `@model_validator` enforces spatial monotonicity: micro < meso < macro.\n\nMCP ROUTING TRIGGERS: Information Bottleneck, Semantic Compression, Euclidean Distance, Level of Detail, Entropy Degradation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SemanticZoomProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes the Information Bottleneck principle to execute Semantic Zooming. It defines the exact Euclidean distance thresholds at which a node's semantic payload deterministically degrades to preserve computational entropy.\\n\\nCAUSAL AFFORDANCE: Instructs the spatial projection engine to dynamically collapse high-entropy unstructured text into low-entropy scalars or categorical labels as the observer's SE(3) camera recedes.\\n\\nEPISTEMIC BOUNDS: The thresholds are bounded to continuous physical distance in meters (`ge=0.0`). A strict mathematical invariant guaranteed by a `@model_validator` enforces spatial monotonicity: micro < meso < macro.\\n\\nMCP ROUTING TRIGGERS: Information Bottleneck, Semantic Compression, Euclidean Distance, Level of Detail, Entropy Degradation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"macro_distance_threshold\","]
#[doc = "    \"meso_distance_threshold\","]
#[doc = "    \"micro_distance_threshold\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"macro_distance_threshold\": {"]
#[doc = "      \"title\": \"Macro Distance Threshold\","]
#[doc = "      \"description\": \"The Euclidean distance in meters at which the node collapses into a pure scalar or color-coded coordinate representation.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"meso_distance_threshold\": {"]
#[doc = "      \"title\": \"Meso Distance Threshold\","]
#[doc = "      \"description\": \"The distance at which the node displays only its localized taxonomic label and boundary, stripping raw textual payloads.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"micro_distance_threshold\": {"]
#[doc = "      \"title\": \"Micro Distance Threshold\","]
#[doc = "      \"description\": \"The close-proximity boundary where full N-dimensional tensors and unstructured text blocks are mathematically hydrated into the observer's plane.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SemanticZoomProfile {
    #[doc = "The Euclidean distance in meters at which the node collapses into a pure scalar or color-coded coordinate representation."]
    pub macro_distance_threshold: f64,
    #[doc = "The distance at which the node displays only its localized taxonomic label and boundary, stripping raw textual payloads."]
    pub meso_distance_threshold: f64,
    #[doc = "The close-proximity boundary where full N-dimensional tensors and unstructured text blocks are mathematically hydrated into the observer's plane."]
    pub micro_distance_threshold: f64,
}
impl SemanticZoomProfile {
    pub fn builder() -> builder::SemanticZoomProfile {
        Default::default()
    }
}
#[doc = "Multimodal Sensor Fusion and Spatial-Temporal Bindings representing Proprioceptive State and Exteroceptive Vectors."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Sensory Modality\","]
#[doc = "  \"description\": \"Multimodal Sensor Fusion and Spatial-Temporal Bindings representing Proprioceptive State and Exteroceptive Vectors.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"video\","]
#[doc = "    \"audio\","]
#[doc = "    \"spatial_telemetry\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum SensoryModality {
    #[serde(rename = "video")]
    Video,
    #[serde(rename = "audio")]
    Audio,
    #[serde(rename = "spatial_telemetry")]
    SpatialTelemetry,
}
impl ::std::fmt::Display for SensoryModality {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Video => f.write_str("video"),
            Self::Audio => f.write_str("audio"),
            Self::SpatialTelemetry => f.write_str("spatial_telemetry"),
        }
    }
}
impl ::std::str::FromStr for SensoryModality {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "video" => Ok(Self::Video),
            "audio" => Ok(Self::Audio),
            "spatial_telemetry" => Ok(Self::SpatialTelemetry),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for SensoryModality {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SensoryModality {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SensoryModality {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The deterministic capability pointer representing the MCP server providing this prompt."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Server Cid\","]
#[doc = "  \"description\": \"The deterministic capability pointer representing the MCP server providing this prompt.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ServerCid(::std::string::String);
impl ::std::ops::Deref for ServerCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ServerCid> for ::std::string::String {
    fn from(value: ServerCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ServerCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ServerCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ServerCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ServerCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ServerCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Unique identifier for the secure session."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Session Cid\","]
#[doc = "  \"description\": \"Unique identifier for the secure session.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SessionCid(::std::string::String);
impl ::std::ops::Deref for SessionCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SessionCid> for ::std::string::String {
    fn from(value: SessionCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SessionCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SessionCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SessionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SessionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SessionCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`SeveredEdgeCidsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SeveredEdgeCidsItem(::std::string::String);
impl ::std::ops::Deref for SeveredEdgeCidsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SeveredEdgeCidsItem> for ::std::string::String {
    fn from(value: SeveredEdgeCidsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SeveredEdgeCidsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SeveredEdgeCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SeveredEdgeCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SeveredEdgeCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SeveredEdgeCidsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The categorical magnitude of the systemic breach enacted upon rule violation."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Severity\","]
#[doc = "  \"description\": \"The categorical magnitude of the systemic breach enacted upon rule violation.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"low\","]
#[doc = "    \"medium\","]
#[doc = "    \"high\","]
#[doc = "    \"critical\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum Severity {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "critical")]
    Critical,
}
impl ::std::fmt::Display for Severity {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Low => f.write_str("low"),
            Self::Medium => f.write_str("medium"),
            Self::High => f.write_str("high"),
            Self::Critical => f.write_str("critical"),
        }
    }
}
impl ::std::str::FromStr for Severity {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "low" => Ok(Self::Low),
            "medium" => Ok(Self::Medium),
            "high" => Ok(Self::High),
            "critical" => Ok(Self::Critical),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for Severity {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Severity {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Severity {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`Sha256GraphHash`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Sha256 Graph Hash\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Sha256GraphHash(::std::string::String);
impl ::std::ops::Deref for Sha256GraphHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Sha256GraphHash> for ::std::string::String {
    fn from(value: Sha256GraphHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Sha256GraphHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Sha256GraphHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Sha256GraphHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Sha256GraphHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Sha256GraphHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the strict SHACL shape validation pass required before RDF egress.\n\nCAUSAL AFFORDANCE: Unlocks formal enterprise evaluation of emitted graphs against a verified shape.\n\nEPISTEMIC BOUNDS: The violation action bounds the exact deterministic penalty for triple non-conformance.\n\nMCP ROUTING TRIGGERS: SHACL, Topological Validation, Schema Evaluation, Triplestore"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SHACLValidationSLA\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the strict SHACL shape validation pass required before RDF egress.\\n\\nCAUSAL AFFORDANCE: Unlocks formal enterprise evaluation of emitted graphs against a verified shape.\\n\\nEPISTEMIC BOUNDS: The violation action bounds the exact deterministic penalty for triple non-conformance.\\n\\nMCP ROUTING TRIGGERS: SHACL, Topological Validation, Schema Evaluation, Triplestore\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"shacl_shape_graph_uri\","]
#[doc = "    \"violation_action\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"shacl_shape_graph_uri\": {"]
#[doc = "      \"title\": \"Shacl Shape Graph Uri\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"format\": \"uri\","]
#[doc = "      \"minLength\": 1"]
#[doc = "    },"]
#[doc = "    \"violation_action\": {"]
#[doc = "      \"title\": \"Violation Action\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"DROP_GRAPH\","]
#[doc = "        \"STRIP_TRIPLES\","]
#[doc = "        \"HALT_EXECUTION\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ShaclValidationSla {
    pub shacl_shape_graph_uri: ::std::string::String,
    pub violation_action: ViolationAction,
}
impl ShaclValidationSla {
    pub fn builder() -> builder::ShaclValidationSla {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Cooperative Game Theory to compute the exact Shapley\nvalue ($\\phi_i$) for a specific agent's marginal contribution to a collective outcome.\nAs a ...Receipt suffix, this is an append-only coordinate on the Merkle-DAG.\n\nCAUSAL AFFORDANCE: Unlocks deterministic credit assignment and thermodynamic reward\ndistribution, allowing the orchestrator to equitably distribute escrow payouts or\npolicy gradient updates to the participating target_node_cid (NodeCIDState).\n\nEPISTEMIC BOUNDS: normalized_contribution_percentage is strictly clamped (ge=0.0,\nle=1.0). The causal_attribution_score has only le=1.0 (no ge bound). The Monte Carlo\napproximation confidence bounds (confidence_interval_lower/upper) are capped at\nle=18446744073709551615.0.\n\nMCP ROUTING TRIGGERS: Cooperative Game Theory, Shapley Value, Credit Assignment,\nMarginal Contribution, Monte Carlo Approximation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ShapleyAttributionReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Cooperative Game Theory to compute the exact Shapley\\nvalue ($\\\\phi_i$) for a specific agent's marginal contribution to a collective outcome.\\nAs a ...Receipt suffix, this is an append-only coordinate on the Merkle-DAG.\\n\\nCAUSAL AFFORDANCE: Unlocks deterministic credit assignment and thermodynamic reward\\ndistribution, allowing the orchestrator to equitably distribute escrow payouts or\\npolicy gradient updates to the participating target_node_cid (NodeCIDState).\\n\\nEPISTEMIC BOUNDS: normalized_contribution_percentage is strictly clamped (ge=0.0,\\nle=1.0). The causal_attribution_score has only le=1.0 (no ge bound). The Monte Carlo\\napproximation confidence bounds (confidence_interval_lower/upper) are capped at\\nle=18446744073709551615.0.\\n\\nMCP ROUTING TRIGGERS: Cooperative Game Theory, Shapley Value, Credit Assignment,\\nMarginal Contribution, Monte Carlo Approximation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"causal_attribution_score\","]
#[doc = "    \"confidence_interval_lower\","]
#[doc = "    \"confidence_interval_upper\","]
#[doc = "    \"normalized_contribution_percentage\","]
#[doc = "    \"target_node_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"causal_attribution_score\": {"]
#[doc = "      \"title\": \"Causal Attribution Score\","]
#[doc = "      \"description\": \"The exact Shapley value (\\\\phi_i) satisfying efficiency, symmetry, and additivity axioms.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"confidence_interval_lower\": {"]
#[doc = "      \"title\": \"Confidence Interval Lower\","]
#[doc = "      \"description\": \"The bootstrap confidence bounds of the Monte Carlo approximation (lower bound).\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"confidence_interval_upper\": {"]
#[doc = "      \"title\": \"Confidence Interval Upper\","]
#[doc = "      \"description\": \"The bootstrap confidence bounds of the Monte Carlo approximation (upper bound).\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"normalized_contribution_percentage\": {"]
#[doc = "      \"title\": \"Normalized Contribution Percentage\","]
#[doc = "      \"description\": \"The relative fractional contribution bounded between 0.0 and 1.0.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"description\": \"The agent whose causal influence is being measured.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ShapleyAttributionReceipt {
    #[doc = "The exact Shapley value (\\phi_i) satisfying efficiency, symmetry, and additivity axioms."]
    pub causal_attribution_score: f64,
    #[doc = "The bootstrap confidence bounds of the Monte Carlo approximation (lower bound)."]
    pub confidence_interval_lower: f64,
    #[doc = "The bootstrap confidence bounds of the Monte Carlo approximation (upper bound)."]
    pub confidence_interval_upper: f64,
    #[doc = "The relative fractional contribution bounded between 0.0 and 1.0."]
    pub normalized_contribution_percentage: f64,
    #[doc = "The agent whose causal influence is being measured."]
    pub target_node_cid: NodeCidState,
}
impl ShapleyAttributionReceipt {
    pub fn builder() -> builder::ShapleyAttributionReceipt {
        Default::default()
    }
}
#[doc = "Cryptographic identifier for the Black Swan event."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Shock Cid\","]
#[doc = "  \"description\": \"Cryptographic identifier for the Black Swan event.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ShockCid(::std::string::String);
impl ::std::ops::Deref for ShockCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ShockCid> for ::std::string::String {
    fn from(value: ShockCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ShockCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ShockCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ShockCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ShockCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ShockCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Lambda Calculus principles of referential transparency and state isolation by rigidly categorizing tool capabilities.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator's graph traversal engine (e.g., MCTS) whether a tool can be safely re-evaluated concurrently (`is_idempotent`) or if it induces irreversible kinetic entropy (`mutates_state`).\n\nEPISTEMIC BOUNDS: Constrained entirely to strict Pydantic boolean logic to mathematically sever ambiguity in side-effect classifications, preventing uncontrolled state mutation.\n\nMCP ROUTING TRIGGERS: Referential Transparency, Lambda Calculus, Idempotence, State Monad, Causal Actuator"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SideEffectProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Lambda Calculus principles of referential transparency and state isolation by rigidly categorizing tool capabilities.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator's graph traversal engine (e.g., MCTS) whether a tool can be safely re-evaluated concurrently (`is_idempotent`) or if it induces irreversible kinetic entropy (`mutates_state`).\\n\\nEPISTEMIC BOUNDS: Constrained entirely to strict Pydantic boolean logic to mathematically sever ambiguity in side-effect classifications, preventing uncontrolled state mutation.\\n\\nMCP ROUTING TRIGGERS: Referential Transparency, Lambda Calculus, Idempotence, State Monad, Causal Actuator\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"is_idempotent\","]
#[doc = "    \"mutates_state\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"is_idempotent\": {"]
#[doc = "      \"title\": \"Is Idempotent\","]
#[doc = "      \"description\": \"True if the tool can be safely retried multiple times without altering state beyond the first call.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"mutates_state\": {"]
#[doc = "      \"title\": \"Mutates State\","]
#[doc = "      \"description\": \"True if the tool performs write operations or side-effects.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SideEffectProfile {
    #[doc = "True if the tool can be safely retried multiple times without altering state beyond the first call."]
    pub is_idempotent: bool,
    #[doc = "True if the tool performs write operations or side-effects."]
    pub mutates_state: bool,
}
impl SideEffectProfile {
    pub fn builder() -> builder::SideEffectProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Optimal Stopping Theory for Monte Carlo Tree Search (MCTS)\nand sandbox simulations. As an ...SLA suffix, this defines rigid mathematical boundaries\nthat the orchestrator must enforce globally.\n\nCAUSAL AFFORDANCE: Triggers early probability wave collapse when the statistical variance\nof the simulation rollouts falls below the tolerance, conserving GPU VRAM and halting\nunnecessary compute expansion.\n\nEPISTEMIC BOUNDS: Physically constrained by max_monte_carlo_rollouts (gt=0,\nle=18446744073709551615) to prevent infinite branching. Statistical confidence is mathematically\nclamped by variance_tolerance to a probability distribution between [ge=0.0, le=1.0].\n\nMCP ROUTING TRIGGERS: Optimal Stopping Theory, Monte Carlo Tree Search, Variance\nReduction, Probability Wave Collapse, Simulation Convergence"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SimulationConvergenceSLA\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Optimal Stopping Theory for Monte Carlo Tree Search (MCTS)\\nand sandbox simulations. As an ...SLA suffix, this defines rigid mathematical boundaries\\nthat the orchestrator must enforce globally.\\n\\nCAUSAL AFFORDANCE: Triggers early probability wave collapse when the statistical variance\\nof the simulation rollouts falls below the tolerance, conserving GPU VRAM and halting\\nunnecessary compute expansion.\\n\\nEPISTEMIC BOUNDS: Physically constrained by max_monte_carlo_rollouts (gt=0,\\nle=18446744073709551615) to prevent infinite branching. Statistical confidence is mathematically\\nclamped by variance_tolerance to a probability distribution between [ge=0.0, le=1.0].\\n\\nMCP ROUTING TRIGGERS: Optimal Stopping Theory, Monte Carlo Tree Search, Variance\\nReduction, Probability Wave Collapse, Simulation Convergence\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_monte_carlo_rollouts\","]
#[doc = "    \"variance_tolerance\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_monte_carlo_rollouts\": {"]
#[doc = "      \"title\": \"Max Monte Carlo Rollouts\","]
#[doc = "      \"description\": \"The absolute physical limit on how many alternate futures the system is allowed to render.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"variance_tolerance\": {"]
#[doc = "      \"title\": \"Variance Tolerance\","]
#[doc = "      \"description\": \"The statistical confidence required to collapse the probability wave early and save GPU VRAM.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SimulationConvergenceSla {
    #[doc = "The absolute physical limit on how many alternate futures the system is allowed to render."]
    pub max_monte_carlo_rollouts: ::std::num::NonZeroU64,
    #[doc = "The statistical confidence required to collapse the probability wave early and save GPU VRAM."]
    pub variance_tolerance: f64,
}
impl SimulationConvergenceSla {
    pub fn builder() -> builder::SimulationConvergenceSla {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes a Proof-of-Stake (PoS) cryptographic boundary to fund\nsandbox simulations and exogenous shocks. As a ...Contract suffix, this object defines\nrigid economic requirements that must be met prior to execution.\n\nCAUSAL AFFORDANCE: Unlocks the authorization for the orchestrator to execute\nresource-intensive chaos experiments by mathematically reserving thermodynamic compute\nupfront.\n\nEPISTEMIC BOUNDS: Physically bounded by locked_magnitude, which must be strictly positive\n(gt=0, le=18446744073709551615) to mathematically prevent zero-cost Sybil griefing attacks against\nthe swarm's compute resources.\n\nMCP ROUTING TRIGGERS: Proof-of-Stake, Economic Escrow, Sybil Resistance, Thermodynamic\nCost, Sandbox Funding"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SimulationEscrowContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes a Proof-of-Stake (PoS) cryptographic boundary to fund\\nsandbox simulations and exogenous shocks. As a ...Contract suffix, this object defines\\nrigid economic requirements that must be met prior to execution.\\n\\nCAUSAL AFFORDANCE: Unlocks the authorization for the orchestrator to execute\\nresource-intensive chaos experiments by mathematically reserving thermodynamic compute\\nupfront.\\n\\nEPISTEMIC BOUNDS: Physically bounded by locked_magnitude, which must be strictly positive\\n(gt=0, le=18446744073709551615) to mathematically prevent zero-cost Sybil griefing attacks against\\nthe swarm's compute resources.\\n\\nMCP ROUTING TRIGGERS: Proof-of-Stake, Economic Escrow, Sybil Resistance, Thermodynamic\\nCost, Sandbox Funding\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"locked_magnitude\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"locked_magnitude\": {"]
#[doc = "      \"title\": \"Locked Magnitude\","]
#[doc = "      \"description\": \"The strictly typed boundary requiring locked magnitude to prevent zero-cost griefing of the swarm.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SimulationEscrowContract {
    #[doc = "The strictly typed boundary requiring locked magnitude to prevent zero-cost griefing of the swarm."]
    pub locked_magnitude: ::std::num::NonZeroU64,
}
impl SimulationEscrowContract {
    pub fn builder() -> builder::SimulationEscrowContract {
        Default::default()
    }
}
#[doc = "The exact cryptographic P2P protocol the nodes must use to evaluate the function."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Smpc Protocol\","]
#[doc = "  \"description\": \"The exact cryptographic P2P protocol the nodes must use to evaluate the function.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"garbled_circuits\","]
#[doc = "    \"secret_sharing\","]
#[doc = "    \"oblivious_transfer\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum SmpcProtocol {
    #[serde(rename = "garbled_circuits")]
    GarbledCircuits,
    #[serde(rename = "secret_sharing")]
    SecretSharing,
    #[serde(rename = "oblivious_transfer")]
    ObliviousTransfer,
}
impl ::std::fmt::Display for SmpcProtocol {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::GarbledCircuits => f.write_str("garbled_circuits"),
            Self::SecretSharing => f.write_str("secret_sharing"),
            Self::ObliviousTransfer => f.write_str("oblivious_transfer"),
        }
    }
}
impl ::std::str::FromStr for SmpcProtocol {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "garbled_circuits" => Ok(Self::GarbledCircuits),
            "secret_sharing" => Ok(Self::SecretSharing),
            "oblivious_transfer" => Ok(Self::ObliviousTransfer),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for SmpcProtocol {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SmpcProtocol {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SmpcProtocol {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative, frozen snapshot establishing a Secure Multi-Party Computation (SMPC) ring, leveraging cryptographic privacy-preserving protocols to evaluate a joint function over decentralized inputs.\n\nCAUSAL AFFORDANCE: Authorizes the decentralized orchestrator to route zero-trust traffic via specific mathematical logic (`garbled_circuits`, `secret_sharing`, `oblivious_transfer`), allowing mutually distrustful agents to synthesize a shared output.\n\nEPISTEMIC BOUNDS: The topology physically mandates a minimum of two participants (`participant_node_cids` `min_length=2`) to satisfy the multi-party invariant. The `joint_function_uri` is bounded to `max_length=2000`. Nodes are deterministically sorted.\n\nMCP ROUTING TRIGGERS: Secure Multi-Party Computation, Garbled Circuits, Secret Sharing, Oblivious Transfer, Zero-Trust Cryptography"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SMPCTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative, frozen snapshot establishing a Secure Multi-Party Computation (SMPC) ring, leveraging cryptographic privacy-preserving protocols to evaluate a joint function over decentralized inputs.\\n\\nCAUSAL AFFORDANCE: Authorizes the decentralized orchestrator to route zero-trust traffic via specific mathematical logic (`garbled_circuits`, `secret_sharing`, `oblivious_transfer`), allowing mutually distrustful agents to synthesize a shared output.\\n\\nEPISTEMIC BOUNDS: The topology physically mandates a minimum of two participants (`participant_node_cids` `min_length=2`) to satisfy the multi-party invariant. The `joint_function_uri` is bounded to `max_length=2000`. Nodes are deterministically sorted.\\n\\nMCP ROUTING TRIGGERS: Secure Multi-Party Computation, Garbled Circuits, Secret Sharing, Oblivious Transfer, Zero-Trust Cryptography\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"joint_function_uri\","]
#[doc = "    \"nodes\","]
#[doc = "    \"participant_node_cids\","]
#[doc = "    \"smpc_protocol\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"epistemic_enforcement\": {"]
#[doc = "      \"description\": \"Ties the topology to the Truth Maintenance layer.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TruthMaintenancePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"joint_function_uri\": {"]
#[doc = "      \"title\": \"Joint Function Uri\","]
#[doc = "      \"description\": \"The URI or hash pointing to the exact math circuit or polynomial function the ring will collaboratively compute.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this topology's configuration.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"lifecycle_phase\": {"]
#[doc = "      \"title\": \"Lifecycle Phase\","]
#[doc = "      \"description\": \"The execution phase of the graph. 'draft' allows incomplete structural state.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"draft\","]
#[doc = "        \"live\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"nodes\": {"]
#[doc = "      \"title\": \"Nodes\","]
#[doc = "      \"description\": \"Flat registry of all nodes in this topology.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyNodeProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"observability\": {"]
#[doc = "      \"description\": \"The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ObservabilityLODPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"ontological_alignment\": {"]
#[doc = "      \"description\": \"The pre-flight execution gate forcing agents to mathematically align their latent semantics before participating in the topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/OntologicalAlignmentPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"participant_node_cids\": {"]
#[doc = "      \"title\": \"Participant Node Cids\","]
#[doc = "      \"description\": \"The strict ordered array of NodeIdentifierStates participating in the Secure Multi-Party Computation ring.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1"]
#[doc = "      },"]
#[doc = "      \"minItems\": 2"]
#[doc = "    },"]
#[doc = "    \"semantic_flow\": {"]
#[doc = "      \"description\": \"The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticFlowPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"shared_state_contract\": {"]
#[doc = "      \"description\": \"The schema-on-write contract governing the internal state of this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StateContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"smpc_protocol\": {"]
#[doc = "      \"title\": \"Smpc Protocol\","]
#[doc = "      \"description\": \"The exact cryptographic P2P protocol the nodes must use to evaluate the function.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"garbled_circuits\","]
#[doc = "        \"secret_sharing\","]
#[doc = "        \"oblivious_transfer\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for SMPC Topology.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"smpc\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SmpcTopologyManifest {
    #[doc = "The AI's declarative rationale for selecting this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "Ties the topology to the Truth Maintenance layer."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_enforcement: ::std::option::Option<TruthMaintenancePolicy>,
    #[doc = "The URI or hash pointing to the exact math circuit or polynomial function the ring will collaboratively compute."]
    pub joint_function_uri: JointFunctionUri,
    #[doc = "Cryptographic/audit justification for this topology's configuration."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The execution phase of the graph. 'draft' allows incomplete structural state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub lifecycle_phase: ::std::option::Option<LifecyclePhase>,
    #[doc = "Flat registry of all nodes in this topology."]
    pub nodes: ::std::collections::HashMap<::std::string::String, AnyNodeProfile>,
    #[doc = "The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub observability: ::std::option::Option<ObservabilityLodPolicy>,
    #[doc = "The pre-flight execution gate forcing agents to mathematically align their latent semantics before participating in the topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub ontological_alignment: ::std::option::Option<OntologicalAlignmentPolicy>,
    #[doc = "The strict ordered array of NodeIdentifierStates participating in the Secure Multi-Party Computation ring."]
    pub participant_node_cids: ::std::vec::Vec<ParticipantNodeCidsItem>,
    #[doc = "The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_flow: ::std::option::Option<SemanticFlowPolicy>,
    #[doc = "The schema-on-write contract governing the internal state of this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub shared_state_contract: ::std::option::Option<StateContract>,
    #[doc = "The exact cryptographic P2P protocol the nodes must use to evaluate the function."]
    pub smpc_protocol: SmpcProtocol,
    #[doc = "Discriminator for SMPC Topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl SmpcTopologyManifest {
    pub fn builder() -> builder::SmpcTopologyManifest {
        Default::default()
    }
}
#[doc = "The target deterministic math/logic engine."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Solver Protocol\","]
#[doc = "  \"description\": \"The target deterministic math/logic engine.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"lean4\","]
#[doc = "    \"z3\","]
#[doc = "    \"clingo\","]
#[doc = "    \"swi_prolog\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum SolverProtocol {
    #[serde(rename = "lean4")]
    Lean4,
    #[serde(rename = "z3")]
    Z3,
    #[serde(rename = "clingo")]
    Clingo,
    #[serde(rename = "swi_prolog")]
    SwiProlog,
}
impl ::std::fmt::Display for SolverProtocol {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Lean4 => f.write_str("lean4"),
            Self::Z3 => f.write_str("z3"),
            Self::Clingo => f.write_str("clingo"),
            Self::SwiProlog => f.write_str("swi_prolog"),
        }
    }
}
impl ::std::str::FromStr for SolverProtocol {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "lean4" => Ok(Self::Lean4),
            "z3" => Ok(Self::Z3),
            "clingo" => Ok(Self::Clingo),
            "swi_prolog" => Ok(Self::SwiProlog),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for SolverProtocol {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SolverProtocol {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SolverProtocol {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The fully qualified URN of the solver agent that performed the execution."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Solver Urn\","]
#[doc = "  \"description\": \"The fully qualified URN of the solver agent that performed the execution.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^urn:coreason:solver:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SolverUrn(::std::string::String);
impl ::std::ops::Deref for SolverUrn {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SolverUrn> for ::std::string::String {
    fn from(value: SolverUrn) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SolverUrn {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| {
                ::regress::Regex::new("^urn:coreason:solver:.*$").unwrap()
            });
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^urn:coreason:solver:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SolverUrn {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SolverUrn {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SolverUrn {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SolverUrn {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) for the Standard Operating Procedure."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Sop Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) for the Standard Operating Procedure.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SopCid(::std::string::String);
impl ::std::ops::Deref for SopCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SopCid> for ::std::string::String {
    fn from(value: SopCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SopCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SopCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SopCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SopCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SopCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`SourceArtifactCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Artifact Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceArtifactCid(::std::string::String);
impl ::std::ops::Deref for SourceArtifactCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceArtifactCid> for ::std::string::String {
    fn from(value: SourceArtifactCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceArtifactCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceArtifactCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceArtifactCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceArtifactCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceArtifactCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`SourceChainCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Chain Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceChainCid(::std::string::String);
impl ::std::ops::Deref for SourceChainCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceChainCid> for ::std::string::String {
    fn from(value: SourceChainCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceChainCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceChainCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceChainCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceChainCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceChainCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the claim mounting the attack."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Claim Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the claim mounting the attack.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceClaimCid(::std::string::String);
impl ::std::ops::Deref for SourceClaimCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceClaimCid> for ::std::string::String {
    fn from(value: SourceClaimCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceClaimCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceClaimCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceClaimCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceClaimCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceClaimCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The globally unique decentralized identifier (DID) anchoring the origin node."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Concept Cid\","]
#[doc = "  \"description\": \"The globally unique decentralized identifier (DID) anchoring the origin node.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceConceptCid(::std::string::String);
impl ::std::ops::Deref for SourceConceptCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceConceptCid> for ::std::string::String {
    fn from(value: SourceConceptCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceConceptCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceConceptCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceConceptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceConceptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceConceptCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The undeniable SHA-256 hash of the pre-transmutation artifact, unstructured text chunk, or telemetry row."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Data Hash\","]
#[doc = "  \"description\": \"The undeniable SHA-256 hash of the pre-transmutation artifact, unstructured text chunk, or telemetry row.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceDataHash(::std::string::String);
impl ::std::ops::Deref for SourceDataHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceDataHash> for ::std::string::String {
    fn from(value: SourceDataHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceDataHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceDataHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceDataHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceDataHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceDataHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The unrelated abstract concept space (e.g., 'thermodynamics', 'mycelial networks')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Domain\","]
#[doc = "  \"description\": \"The unrelated abstract concept space (e.g., 'thermodynamics', 'mycelial networks').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceDomain(::std::string::String);
impl ::std::ops::Deref for SourceDomain {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceDomain> for ::std::string::String {
    fn from(value: SourceDomain) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceDomain {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceDomain {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceDomain {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceDomain {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceDomain {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`SourceEpisodicEventCidsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceEpisodicEventCidsItem(::std::string::String);
impl ::std::ops::Deref for SourceEpisodicEventCidsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceEpisodicEventCidsItem> for ::std::string::String {
    fn from(value: SourceEpisodicEventCidsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceEpisodicEventCidsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceEpisodicEventCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceEpisodicEventCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceEpisodicEventCidsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceEpisodicEventCidsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the source event in the Merkle-DAG."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Event Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the source event in the Merkle-DAG.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceEventCid(::std::string::String);
impl ::std::ops::Deref for SourceEventCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceEventCid> for ::std::string::String {
    fn from(value: SourceEventCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceEventCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceEventCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceEventCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The structural 128-char DID boundary pointing to the foundational semantic deficit vector."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Intent Cid\","]
#[doc = "  \"description\": \"The structural 128-char DID boundary pointing to the foundational semantic deficit vector.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceIntentCid(::std::string::String);
impl ::std::ops::Deref for SourceIntentCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceIntentCid> for ::std::string::String {
    fn from(value: SourceIntentCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceIntentCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceIntentCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceIntentCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceIntentCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceIntentCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The execution node that emitted the original payload."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Node Cid\","]
#[doc = "  \"description\": \"The execution node that emitted the original payload.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceNodeCid(::std::string::String);
impl ::std::ops::Deref for SourceNodeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceNodeCid> for ::std::string::String {
    fn from(value: SourceNodeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceNodeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceNodeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The origin namespace (e.g., ICD-10, USC)."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Ontology Namespace\","]
#[doc = "  \"description\": \"The origin namespace (e.g., ICD-10, USC).\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceOntologyNamespace(::std::string::String);
impl ::std::ops::Deref for SourceOntologyNamespace {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceOntologyNamespace> for ::std::string::String {
    fn from(value: SourceOntologyNamespace) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceOntologyNamespace {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceOntologyNamespace {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceOntologyNamespace {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceOntologyNamespace {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceOntologyNamespace {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The RFC 6902 JSON Pointer extracting the Covariant output."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Pointer\","]
#[doc = "  \"description\": \"The RFC 6902 JSON Pointer extracting the Covariant output.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourcePointer(::std::string::String);
impl ::std::ops::Deref for SourcePointer {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourcePointer> for ::std::string::String {
    fn from(value: SourcePointer) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourcePointer {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourcePointer {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourcePointer {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourcePointer {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourcePointer {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`SourcePredictionCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Prediction Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourcePredictionCid(::std::string::String);
impl ::std::ops::Deref for SourcePredictionCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourcePredictionCid> for ::std::string::String {
    fn from(value: SourcePredictionCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourcePredictionCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourcePredictionCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourcePredictionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourcePredictionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourcePredictionCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The EpistemicTopologicalProofManifest CID this trace is mathematically anchored to."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Proof Cid\","]
#[doc = "  \"description\": \"The EpistemicTopologicalProofManifest CID this trace is mathematically anchored to.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceProofCid(::std::string::String);
impl ::std::ops::Deref for SourceProofCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceProofCid> for ::std::string::String {
    fn from(value: SourceProofCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceProofCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceProofCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceProofCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceProofCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceProofCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "An explicit cryptographic pointer to the raw SemanticRelationalVectorState pending resolution."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Record Cid\","]
#[doc = "  \"description\": \"An explicit cryptographic pointer to the raw SemanticRelationalVectorState pending resolution.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceRecordCid(::std::string::String);
impl ::std::ops::Deref for SourceRecordCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceRecordCid> for ::std::string::String {
    fn from(value: SourceRecordCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceRecordCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceRecordCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceRecordCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceRecordCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceRecordCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`SourceStringsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceStringsItem(::std::string::String);
impl ::std::ops::Deref for SourceStringsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceStringsItem> for ::std::string::String {
    fn from(value: SourceStringsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceStringsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceStringsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceStringsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceStringsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceStringsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`SourceSuperpositionCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Superposition Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceSuperpositionCid(::std::string::String);
impl ::std::ops::Deref for SourceSuperpositionCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceSuperpositionCid> for ::std::string::String {
    fn from(value: SourceSuperpositionCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceSuperpositionCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceSuperpositionCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceSuperpositionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceSuperpositionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceSuperpositionCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The globally unique decentralized identifier (DID) anchoring the partial CognitiveReasoningTraceState."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Trajectory Cid\","]
#[doc = "  \"description\": \"The globally unique decentralized identifier (DID) anchoring the partial CognitiveReasoningTraceState.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceTrajectoryCid(::std::string::String);
impl ::std::ops::Deref for SourceTrajectoryCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceTrajectoryCid> for ::std::string::String {
    fn from(value: SourceTrajectoryCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceTrajectoryCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceTrajectoryCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceTrajectoryCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceTrajectoryCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceTrajectoryCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The independent variable $X$."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Source Variable\","]
#[doc = "  \"description\": \"The independent variable $X$.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SourceVariable(::std::string::String);
impl ::std::ops::Deref for SourceVariable {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SourceVariable> for ::std::string::String {
    fn from(value: SourceVariable) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SourceVariable {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SourceVariable {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SourceVariable {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SourceVariable {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SourceVariable {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The formal algebraic Big-O notation representing the asymptotic structural memory geometry."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Space Complexity Class\","]
#[doc = "  \"description\": \"The formal algebraic Big-O notation representing the asymptotic structural memory geometry.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255,"]
#[doc = "  \"pattern\": \"^O\\\\([a-zA-Z0-9_+\\\\^ \\\\-\\\\*]+\\\\)$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SpaceComplexityClass(::std::string::String);
impl ::std::ops::Deref for SpaceComplexityClass {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SpaceComplexityClass> for ::std::string::String {
    fn from(value: SpaceComplexityClass) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SpaceComplexityClass {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| {
                ::regress::Regex::new("^O\\([a-zA-Z0-9_+\\^ \\-\\*]+\\)$").unwrap()
            });
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^O\\([a-zA-Z0-9_+\\^ \\-\\*]+\\)$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SpaceComplexityClass {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SpaceComplexityClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SpaceComplexityClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SpaceComplexityClass {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Unique identifier for the specific execution of this actionSpaceCId. Must be a ULID or UUIDv7."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Span Cid\","]
#[doc = "  \"description\": \"Unique identifier for the specific execution of this actionSpaceCId. Must be a ULID or UUIDv7.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 36,"]
#[doc = "  \"minLength\": 26,"]
#[doc = "  \"pattern\": \"^[0-9A-HJKMNP-TV-Z]{26}$|^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SpanCid(::std::string::String);
impl ::std::ops::Deref for SpanCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SpanCid> for ::std::string::String {
    fn from(value: SpanCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SpanCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 36usize {
            return Err("longer than 36 characters".into());
        }
        if value.chars().count() < 26usize {
            return Err("shorter than 26 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> = ::std::sync::LazyLock::new(
            || {
                :: regress :: Regex :: new ("^[0-9A-HJKMNP-TV-Z]{26}$|^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$") . unwrap ()
            },
        );
        if PATTERN.find(value).is_none() {
            return Err ("doesn't match pattern \"^[0-9A-HJKMNP-TV-Z]{26}$|^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$\"" . into ()) ;
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SpanCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SpanCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SpanCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SpanCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Instructs the Semantic Web Archivist to execute a strict, volumetrically bounded query against an enterprise triplestore.\n\nCAUSAL AFFORDANCE: Unlocks read-only retrieval of Semantic Web data.\n\nEPISTEMIC BOUNDS: The target_endpoint is a strictly typed HttpUrl.\n\nMCP ROUTING TRIGGERS: SPARQL, Semantic Web Query, Triplestore Query, Network Boundary"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SPARQLQueryIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Instructs the Semantic Web Archivist to execute a strict, volumetrically bounded query against an enterprise triplestore.\\n\\nCAUSAL AFFORDANCE: Unlocks read-only retrieval of Semantic Web data.\\n\\nEPISTEMIC BOUNDS: The target_endpoint is a strictly typed HttpUrl.\\n\\nMCP ROUTING TRIGGERS: SPARQL, Semantic Web Query, Triplestore Query, Network Boundary\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"query_string\","]
#[doc = "    \"target_endpoint\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"query_string\": {"]
#[doc = "      \"title\": \"Query String\","]
#[doc = "      \"type\": \"string\""]
#[doc = "    },"]
#[doc = "    \"target_endpoint\": {"]
#[doc = "      \"title\": \"Target Endpoint\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"format\": \"uri\","]
#[doc = "      \"maxLength\": 2083,"]
#[doc = "      \"minLength\": 1"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"sparql_query\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SparqlQueryIntent {
    pub query_string: ::std::string::String,
    pub target_endpoint: ::std::string::String,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl SparqlQueryIntent {
    pub fn builder() -> builder::SparqlQueryIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: The immutable, cryptographically frozen result of a SPARQL query, projecting returned RDF bindings into the swarm's working memory.\n\nCAUSAL AFFORDANCE: Commits external Semantic Web knowledge into the Epistemic Ledger, mathematically binding the result set to the intent that authorized it.\n\nEPISTEMIC BOUNDS: The `returned_bindings` dictionary is violently truncated/evaluated by the `_validate_payload_bounds` hardware guillotine to prevent massive data returns from causing VRAM exhaustion.\n\nMCP ROUTING TRIGGERS: SPARQL Result, RDF Bindings, Epistemic Projection, Payload Bounding, Ledger Commit"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SPARQLQueryResultReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: The immutable, cryptographically frozen result of a SPARQL query, projecting returned RDF bindings into the swarm's working memory.\\n\\nCAUSAL AFFORDANCE: Commits external Semantic Web knowledge into the Epistemic Ledger, mathematically binding the result set to the intent that authorized it.\\n\\nEPISTEMIC BOUNDS: The `returned_bindings` dictionary is violently truncated/evaluated by the `_validate_payload_bounds` hardware guillotine to prevent massive data returns from causing VRAM exhaustion.\\n\\nMCP ROUTING TRIGGERS: SPARQL Result, RDF Bindings, Epistemic Projection, Payload Bounding, Ledger Commit\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"execution_time_ms\","]
#[doc = "    \"query_intent_cid\","]
#[doc = "    \"returned_bindings\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"execution_time_ms\": {"]
#[doc = "      \"title\": \"Execution Time Ms\","]
#[doc = "      \"description\": \"A temporal integer capturing the physical cost of the query.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"query_intent_cid\": {"]
#[doc = "      \"title\": \"Query Intent Cid\","]
#[doc = "      \"description\": \"A pointer back to the SPARQLQueryIntent that authorized this execution.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"returned_bindings\": {"]
#[doc = "      \"title\": \"Returned Bindings\","]
#[doc = "      \"description\": \"The localized subset of data retrieved, structurally restricted by the hardware guillotine.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"sparql_query_result\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SparqlQueryResultReceipt {
    pub event_cid: EventCid,
    #[doc = "A temporal integer capturing the physical cost of the query."]
    pub execution_time_ms: u64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "A pointer back to the SPARQLQueryIntent that authorized this execution."]
    pub query_intent_cid: QueryIntentCid,
    #[doc = "The localized subset of data retrieved, structurally restricted by the hardware guillotine."]
    pub returned_bindings: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    pub timestamp: f64,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl SparqlQueryResultReceipt {
    pub fn builder() -> builder::SparqlQueryResultReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes a kinematic constraint binding a 2D typographic or geometric matrix to a 3D SE(3) coordinate mesh.\n\nCAUSAL AFFORDANCE: Authorizes the spatial renderer to project 2D semantics over a 3D topology, mathematically guaranteeing invariant visual alignment relative to the observer's view frustum.\n\nEPISTEMIC BOUNDS: Strictly bounded by boolean physics gates (`always_face_camera`, `occlude_behind_meshes`) defining Z-buffer collision behavior. `distance_scaling_factor` is bounded `[0.0, 10.0]` to control orthographic size invariance.\n\nMCP ROUTING TRIGGERS: Spherical Billboarding, View Frustum Alignment, Z-Buffer Occlusion, Projective Geometry, UI Anchoring"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SpatialBillboardContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes a kinematic constraint binding a 2D typographic or geometric matrix to a 3D SE(3) coordinate mesh.\\n\\nCAUSAL AFFORDANCE: Authorizes the spatial renderer to project 2D semantics over a 3D topology, mathematically guaranteeing invariant visual alignment relative to the observer's view frustum.\\n\\nEPISTEMIC BOUNDS: Strictly bounded by boolean physics gates (`always_face_camera`, `occlude_behind_meshes`) defining Z-buffer collision behavior. `distance_scaling_factor` is bounded `[0.0, 10.0]` to control orthographic size invariance.\\n\\nMCP ROUTING TRIGGERS: Spherical Billboarding, View Frustum Alignment, Z-Buffer Occlusion, Projective Geometry, UI Anchoring\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"anchoring_node_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"always_face_camera\": {"]
#[doc = "      \"title\": \"Always Face Camera\","]
#[doc = "      \"description\": \"Forces the normal vector of the 2D matrix to continuously align with the observer's camera.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"anchoring_node_cid\": {"]
#[doc = "      \"description\": \"The target 3D SE(3) vertex to which the 2D matrix is mathematically bound.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"distance_scaling_factor\": {"]
#[doc = "      \"title\": \"Distance Scaling Factor\","]
#[doc = "      \"description\": \"Controls orthographic size invariance; scaling the matrix inversely to camera distance.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 10.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"occlude_behind_meshes\": {"]
#[doc = "      \"title\": \"Occlude Behind Meshes\","]
#[doc = "      \"description\": \"If true, subjects the 2D plane to depth-testing, allowing 3D geometry to block line-of-sight.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"spherical_cylindrical_lock\": {"]
#[doc = "      \"title\": \"Spherical Cylindrical Lock\","]
#[doc = "      \"description\": \"Dictates whether the UI panel rotates freely on all axes (spherical) or locks to the Y-axis (cylindrical).\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"spherical\","]
#[doc = "        \"cylindrical_y\","]
#[doc = "        \"none\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SpatialBillboardContract {
    #[doc = "Forces the normal vector of the 2D matrix to continuously align with the observer's camera."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub always_face_camera: ::std::option::Option<bool>,
    #[doc = "The target 3D SE(3) vertex to which the 2D matrix is mathematically bound."]
    pub anchoring_node_cid: NodeCidState,
    #[doc = "Controls orthographic size invariance; scaling the matrix inversely to camera distance."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub distance_scaling_factor: ::std::option::Option<f64>,
    #[doc = "If true, subjects the 2D plane to depth-testing, allowing 3D geometry to block line-of-sight."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub occlude_behind_meshes: ::std::option::Option<bool>,
    #[doc = "Dictates whether the UI panel rotates freely on all axes (spherical) or locks to the Y-axis (cylindrical)."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub spherical_cylindrical_lock: ::std::option::Option<SphericalCylindricalLock>,
}
impl SpatialBillboardContract {
    pub fn builder() -> builder::SpatialBillboardContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative, frozen snapshot of the physical hardware boundaries and thermodynamic constraints required to instantiate this node. As a ...Profile suffix, this defines a rigid mathematical boundary.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator's provisioning layer to allocate exact silicon resources (Compute Tier, VRAM, and Accelerator Type) before allowing the node to execute generative operations.\n\nEPISTEMIC BOUNDS: VRAM allocation is physically bounded by min_vram_gb (gt=0.0). The URN-patterned compute_tier and accelerator_type fields provide extensible silicon identification without ephemeral enumeration coupling. The provider_whitelist is deterministically sorted for invariant RFC 8785 hashing.\n\nMCP ROUTING TRIGGERS: Thermodynamic Bounding, VRAM Allocation, Spot Market Routing, Hardware Provisioning, Silicon Constraints"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SpatialHardwareProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative, frozen snapshot of the physical hardware boundaries and thermodynamic constraints required to instantiate this node. As a ...Profile suffix, this defines a rigid mathematical boundary.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator's provisioning layer to allocate exact silicon resources (Compute Tier, VRAM, and Accelerator Type) before allowing the node to execute generative operations.\\n\\nEPISTEMIC BOUNDS: VRAM allocation is physically bounded by min_vram_gb (gt=0.0). The URN-patterned compute_tier and accelerator_type fields provide extensible silicon identification without ephemeral enumeration coupling. The provider_whitelist is deterministically sorted for invariant RFC 8785 hashing.\\n\\nMCP ROUTING TRIGGERS: Thermodynamic Bounding, VRAM Allocation, Spot Market Routing, Hardware Provisioning, Silicon Constraints\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"properties\": {"]
#[doc = "    \"accelerator_type\": {"]
#[doc = "      \"title\": \"Accelerator Type\","]
#[doc = "      \"description\": \"The rigid silicon precision format required to execute this node's neural circuits.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "    },"]
#[doc = "    \"compute_tier\": {"]
#[doc = "      \"title\": \"Compute Tier\","]
#[doc = "      \"description\": \"The discrete architectural boundary of the node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "    },"]
#[doc = "    \"coreason_network_mode\": {"]
#[doc = "      \"title\": \"Coreason Network Mode\","]
#[doc = "      \"description\": \"The networking mode defining the P2P boundary for enterprise compliance.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"P2P\","]
#[doc = "        \"STRICT_GENESIS\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"min_vram_gb\": {"]
#[doc = "      \"title\": \"Min Vram Gb\","]
#[doc = "      \"description\": \"The absolute physical minimum Video RAM required to load this node's latent space.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"provider_whitelist\": {"]
#[doc = "      \"title\": \"Provider Whitelist\","]
#[doc = "      \"description\": \"The explicit array of cloud infrastructure providers authorized to run this node.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SpatialHardwareProfile {
    #[doc = "The rigid silicon precision format required to execute this node's neural circuits."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub accelerator_type: ::std::option::Option<AcceleratorType>,
    #[doc = "The discrete architectural boundary of the node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub compute_tier: ::std::option::Option<ComputeTier>,
    #[doc = "The networking mode defining the P2P boundary for enterprise compliance."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub coreason_network_mode: ::std::option::Option<CoreasonNetworkMode>,
    #[doc = "The absolute physical minimum Video RAM required to load this node's latent space."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub min_vram_gb: ::std::option::Option<f64>,
    #[doc = "The explicit array of cloud infrastructure providers authorized to run this node."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub provider_whitelist: ::std::vec::Vec<ProviderWhitelistItem>,
}
impl ::std::default::Default for SpatialHardwareProfile {
    fn default() -> Self {
        Self {
            accelerator_type: Default::default(),
            compute_tier: Default::default(),
            coreason_network_mode: Default::default(),
            min_vram_gb: Default::default(),
            provider_whitelist: Default::default(),
        }
    }
}
impl SpatialHardwareProfile {
    pub fn builder() -> builder::SpatialHardwareProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Employs Mathematical Kinematics and Fitts's Law to project precise, non-linear physical interactions across an exogenous UI manifold.\n\nCAUSAL AFFORDANCE: Authorizes the translation of latent spatial targets into OS-level actuation, utilizing bezier_control_points to construct continuous polynomial trajectories that simulate human motor control and bypass bot-evasive heuristics.\n\nEPISTEMIC BOUNDS: Spatial execution is clamped to SE3 dimensional boundaries via the nested SE3TransformProfile. Execution liveness is temporally guillotined by trajectory_duration_ms (le=18446744073709551615).\n\nMCP ROUTING TRIGGERS: Mathematical Kinematics, Bezier Geometry, Fitts's Law, OS-Level Actuation, Non-Linear Trajectory"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SpatialKinematicActionIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Employs Mathematical Kinematics and Fitts's Law to project precise, non-linear physical interactions across an exogenous UI manifold.\\n\\nCAUSAL AFFORDANCE: Authorizes the translation of latent spatial targets into OS-level actuation, utilizing bezier_control_points to construct continuous polynomial trajectories that simulate human motor control and bypass bot-evasive heuristics.\\n\\nEPISTEMIC BOUNDS: Spatial execution is clamped to SE3 dimensional boundaries via the nested SE3TransformProfile. Execution liveness is temporally guillotined by trajectory_duration_ms (le=18446744073709551615).\\n\\nMCP ROUTING TRIGGERS: Mathematical Kinematics, Bezier Geometry, Fitts's Law, OS-Level Actuation, Non-Linear Trajectory\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"action_class\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"action_class\": {"]
#[doc = "      \"title\": \"Action Class\","]
#[doc = "      \"description\": \"The specific kinematic interaction paradigm.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"click\","]
#[doc = "        \"double_click\","]
#[doc = "        \"drag_and_drop\","]
#[doc = "        \"scroll\","]
#[doc = "        \"hover\","]
#[doc = "        \"keystroke\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"bezier_control_points\": {"]
#[doc = "      \"title\": \"Bezier Control Points\","]
#[doc = "      \"description\": \"Waypoints for constructing non-linear, bot-evasive movement curves.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/SE3TransformProfile\""]
#[doc = "      },"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"expected_visual_concept\": {"]
#[doc = "      \"title\": \"Expected Visual Concept\","]
#[doc = "      \"description\": \"The visual anchor (e.g., 'Submit Button'). The orchestrator must verify this semantic concept exists at the target_coordinate before executing the macro, preventing blind clicks.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_coordinate\": {"]
#[doc = "      \"description\": \"The primary spatial terminus for clicks or hovers.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SE3TransformProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a spatial kinematic action.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"spatial_kinematic\""]
#[doc = "    },"]
#[doc = "    \"trajectory_duration_ms\": {"]
#[doc = "      \"title\": \"Trajectory Duration Ms\","]
#[doc = "      \"description\": \"The exact temporal duration of the movement, simulating human kinematics.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19,"]
#[doc = "          \"exclusiveMinimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SpatialKinematicActionIntent {
    #[doc = "The specific kinematic interaction paradigm."]
    pub action_class: ActionClass,
    #[doc = "Waypoints for constructing non-linear, bot-evasive movement curves."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub bezier_control_points: ::std::vec::Vec<Se3TransformProfile>,
    #[doc = "The visual anchor (e.g., 'Submit Button'). The orchestrator must verify this semantic concept exists at the target_coordinate before executing the macro, preventing blind clicks."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub expected_visual_concept: ::std::option::Option<::std::string::String>,
    #[doc = "The primary spatial terminus for clicks or hovers."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub target_coordinate: ::std::option::Option<Se3TransformProfile>,
    #[doc = "Discriminator for a spatial kinematic action."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The exact temporal duration of the movement, simulating human kinematics."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub trajectory_duration_ms: ::std::option::Option<::std::num::NonZeroU64>,
}
impl SpatialKinematicActionIntent {
    pub fn builder() -> builder::SpatialKinematicActionIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes a Federated Pose Graph anchor. Establishes a deterministic localized origin point (e.g., a physical room geometry or SLAM feature map) allowing disjoint spatial topologies to mathematically synchronize.\n\nCAUSAL AFFORDANCE: Instructs the spatial orchestrator to align the tracking coordinate systems of multiple observer devices by computing the affine transformation matrix between this shared cryptographic anchor and their local origins.\n\nEPISTEMIC BOUNDS: The semantic locus is cryptographically locked to a 128-char CID (`frame_cid`). The alignment math is strictly bounded to the `anchor_protocol` literal automaton. An optional `physical_room_hash` prevents holographic spoofing across zero-trust domains.\n\nMCP ROUTING TRIGGERS: Federated Pose Graph, Spatial Reference Frame, SLAM Anchor, Relative Coordinate Geometry, Origin Point"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SpatialReferenceFrameManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes a Federated Pose Graph anchor. Establishes a deterministic localized origin point (e.g., a physical room geometry or SLAM feature map) allowing disjoint spatial topologies to mathematically synchronize.\\n\\nCAUSAL AFFORDANCE: Instructs the spatial orchestrator to align the tracking coordinate systems of multiple observer devices by computing the affine transformation matrix between this shared cryptographic anchor and their local origins.\\n\\nEPISTEMIC BOUNDS: The semantic locus is cryptographically locked to a 128-char CID (`frame_cid`). The alignment math is strictly bounded to the `anchor_protocol` literal automaton. An optional `physical_room_hash` prevents holographic spoofing across zero-trust domains.\\n\\nMCP ROUTING TRIGGERS: Federated Pose Graph, Spatial Reference Frame, SLAM Anchor, Relative Coordinate Geometry, Origin Point\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"anchor_protocol\","]
#[doc = "    \"frame_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"anchor_protocol\": {"]
#[doc = "      \"title\": \"Anchor Protocol\","]
#[doc = "      \"description\": \"The scientific tracking standard utilized to establish this reference frame.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"openxr_spatial_anchor\","]
#[doc = "        \"apple_world_anchor\","]
#[doc = "        \"slam_feature_map\","]
#[doc = "        \"relative_virtual\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"frame_cid\": {"]
#[doc = "      \"title\": \"Frame Cid\","]
#[doc = "      \"description\": \"The unique cryptographic identifier for this local spatial volume.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"physical_room_hash\": {"]
#[doc = "      \"title\": \"Physical Room Hash\","]
#[doc = "      \"description\": \"Optional SHA-256 hash of the environment's point-cloud or geometry signature.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SpatialReferenceFrameManifest {
    #[doc = "The scientific tracking standard utilized to establish this reference frame."]
    pub anchor_protocol: AnchorProtocol,
    #[doc = "The unique cryptographic identifier for this local spatial volume."]
    pub frame_cid: FrameCid,
    #[doc = "Optional SHA-256 hash of the environment's point-cloud or geometry signature."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub physical_room_hash: ::std::option::Option<::std::string::String>,
}
impl SpatialReferenceFrameManifest {
    pub fn builder() -> builder::SpatialReferenceFrameManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A mathematically pure, physics-agnostic material reference for spatial rendering.\n\nCAUSAL AFFORDANCE: Instructs the frontend client (e.g., coreason-vscode) to apply a specific visual identity or compiled shader to a spatial coordinate, delegating all photon and rasterization physics to the client's GPU.\n\nEPISTEMIC BOUNDS: Bounded to a strict URN pattern or cryptographic CID, severing the AST from transient WebGL/WebXR implementations.\n\nMCP ROUTING TRIGGERS: Material Reference, Shader Artifact, Spatial Rendering, Visual Identity"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SpatialRenderMaterial\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A mathematically pure, physics-agnostic material reference for spatial rendering.\\n\\nCAUSAL AFFORDANCE: Instructs the frontend client (e.g., coreason-vscode) to apply a specific visual identity or compiled shader to a spatial coordinate, delegating all photon and rasterization physics to the client's GPU.\\n\\nEPISTEMIC BOUNDS: Bounded to a strict URN pattern or cryptographic CID, severing the AST from transient WebGL/WebXR implementations.\\n\\nMCP ROUTING TRIGGERS: Material Reference, Shader Artifact, Spatial Rendering, Visual Identity\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"properties\": {"]
#[doc = "    \"compiled_shader_cid\": {"]
#[doc = "      \"title\": \"Compiled Shader Cid\","]
#[doc = "      \"description\": \"An optional cryptographic pointer to a pre-compiled shader artifact.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"material_urn\": {"]
#[doc = "      \"title\": \"Material Urn\","]
#[doc = "      \"description\": \"The abstract material identifier (e.g., 'urn:coreason:material:glass_refractive').\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SpatialRenderMaterial {
    #[doc = "An optional cryptographic pointer to a pre-compiled shader artifact."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub compiled_shader_cid: ::std::option::Option<::std::string::String>,
    #[doc = "The abstract material identifier (e.g., 'urn:coreason:material:glass_refractive')."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub material_urn: ::std::option::Option<::std::string::String>,
}
impl ::std::default::Default for SpatialRenderMaterial {
    fn default() -> Self {
        Self {
            compiled_shader_cid: Default::default(),
            material_urn: Default::default(),
        }
    }
}
impl SpatialRenderMaterial {
    pub fn builder() -> builder::SpatialRenderMaterial {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the discrete formalization of a Gibsonian Affordance within the agent's Reinforcement Learning Action Space ($A$). As a ...Manifest suffix, this is a declarative, frozen N-dimensional coordinate of a capability.\n\nCAUSAL AFFORDANCE: Unlocks a specific, localized Pearlian Do-Operator intervention ($do(X=x)$) mapped to an external kinetic capability. Governed by side_effects, permissions, and an optional execution SLA.\n\nEPISTEMIC BOUNDS: The operational perimeter is rigidly confined by `input_schema` and `output_schema` (dictionaries bounded to `max_length=1000` properties). The `is_preemptible` boolean (default=False) establishes a physical Halting Problem limit by authorizing the orchestrator to abort execution mid-flight.\n\nMCP ROUTING TRIGGERS: Gibsonian Affordance, MDP Action Space, Pearlian Do-Operator, Capability-Based Security, Halting Problem"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SpatialToolManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the discrete formalization of a Gibsonian Affordance within the agent's Reinforcement Learning Action Space ($A$). As a ...Manifest suffix, this is a declarative, frozen N-dimensional coordinate of a capability.\\n\\nCAUSAL AFFORDANCE: Unlocks a specific, localized Pearlian Do-Operator intervention ($do(X=x)$) mapped to an external kinetic capability. Governed by side_effects, permissions, and an optional execution SLA.\\n\\nEPISTEMIC BOUNDS: The operational perimeter is rigidly confined by `input_schema` and `output_schema` (dictionaries bounded to `max_length=1000` properties). The `is_preemptible` boolean (default=False) establishes a physical Halting Problem limit by authorizing the orchestrator to abort execution mid-flight.\\n\\nMCP ROUTING TRIGGERS: Gibsonian Affordance, MDP Action Space, Pearlian Do-Operator, Capability-Based Security, Halting Problem\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"description\","]
#[doc = "    \"input_schema\","]
#[doc = "    \"permissions\","]
#[doc = "    \"side_effects\","]
#[doc = "    \"tool_name\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"asymptotic_complexity\": {"]
#[doc = "      \"description\": \"Big-O computational bounds.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/AsymptoticComplexityReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"description\": {"]
#[doc = "      \"title\": \"Description\","]
#[doc = "      \"description\": \"The mathematically bounded semantic projection defining the tool's causal affordances.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"hoare_proof\": {"]
#[doc = "      \"description\": \"Formal mathematical proof of pre/post conditions.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/HoareLogicProofReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"input_schema\": {"]
#[doc = "      \"title\": \"Input Schema\","]
#[doc = "      \"description\": \"The strict JSON Schema dictionary defining the pure domain-specific arguments ($T$). The framework orchestrator will automatically wrap this in the ExecutionEnvelopeState at runtime.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"is_preemptible\": {"]
#[doc = "      \"title\": \"Is Preemptible\","]
#[doc = "      \"description\": \"If True, the orchestrator is authorized to send a SIGINT to abort this tool's execution mid-flight if a BargeInInterruptEvent occurs.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"output_schema\": {"]
#[doc = "      \"title\": \"Output Schema\","]
#[doc = "      \"description\": \"The strict JSON Schema dictionary defining the pure domain-specific arguments ($T$). The framework orchestrator will automatically wrap this in the ExecutionEnvelopeState at runtime.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"object\","]
#[doc = "          \"maxProperties\": 1000,"]
#[doc = "          \"additionalProperties\": {"]
#[doc = "            \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"permissions\": {"]
#[doc = "      \"description\": \"The zero-trust security boundaries for the tool's execution.\","]
#[doc = "      \"$ref\": \"#/$defs/PermissionBoundaryPolicy\""]
#[doc = "    },"]
#[doc = "    \"side_effects\": {"]
#[doc = "      \"description\": \"The declarative side-effect and idempotency profile of the tool.\","]
#[doc = "      \"$ref\": \"#/$defs/SideEffectProfile\""]
#[doc = "    },"]
#[doc = "    \"sla\": {"]
#[doc = "      \"description\": \"Execution limits for the tool.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ExecutionSLA\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"tool_name\": {"]
#[doc = "      \"title\": \"Tool Name\","]
#[doc = "      \"description\": \"The deterministically bounded structural identifier mapping this capability within the zero-trust manifold.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for a native tool.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"native_tool\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SpatialToolManifest {
    #[doc = "Big-O computational bounds."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub asymptotic_complexity: ::std::option::Option<AsymptoticComplexityReceipt>,
    #[doc = "The mathematically bounded semantic projection defining the tool's causal affordances."]
    pub description: Description,
    #[doc = "Formal mathematical proof of pre/post conditions."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub hoare_proof: ::std::option::Option<HoareLogicProofReceipt>,
    #[doc = "The strict JSON Schema dictionary defining the pure domain-specific arguments ($T$). The framework orchestrator will automatically wrap this in the ExecutionEnvelopeState at runtime."]
    pub input_schema: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "If True, the orchestrator is authorized to send a SIGINT to abort this tool's execution mid-flight if a BargeInInterruptEvent occurs."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub is_preemptible: ::std::option::Option<bool>,
    #[doc = "The strict JSON Schema dictionary defining the pure domain-specific arguments ($T$). The framework orchestrator will automatically wrap this in the ExecutionEnvelopeState at runtime."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub output_schema: ::std::option::Option<
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    >,
    #[doc = "The zero-trust security boundaries for the tool's execution."]
    pub permissions: PermissionBoundaryPolicy,
    #[doc = "The declarative side-effect and idempotency profile of the tool."]
    pub side_effects: SideEffectProfile,
    #[doc = "Execution limits for the tool."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub sla: ::std::option::Option<ExecutionSla>,
    #[doc = "The deterministically bounded structural identifier mapping this capability within the zero-trust manifold."]
    pub tool_name: ToolName,
    #[doc = "Discriminator type for a native tool."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl SpatialToolManifest {
    pub fn builder() -> builder::SpatialToolManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the structural boundary for executing graph nodes probabilistically, enabling speculative execution branches and time-rewinding geometry.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator's traversal engine to fork the execution context, probabilistically committing or reversing the subgraph based on downstream verification results.\n\nEPISTEMIC BOUNDS: The `commit_probability` strictly clamped (`ge=0.0, le=1.0`). Graph physically bounded by `boundary_cid` (128-char CID). The `rollback_pointers` and `competing_hypotheses` arrays deterministically sorted via `@model_validator`.\n\nMCP ROUTING TRIGGERS: Speculative Topology, Time-Rewinding Geometry, Probabilistic Divergence, Subgraph Fork, Execution Boundary"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SpeculativeExecutionPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the structural boundary for executing graph nodes probabilistically, enabling speculative execution branches and time-rewinding geometry.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator's traversal engine to fork the execution context, probabilistically committing or reversing the subgraph based on downstream verification results.\\n\\nEPISTEMIC BOUNDS: The `commit_probability` strictly clamped (`ge=0.0, le=1.0`). Graph physically bounded by `boundary_cid` (128-char CID). The `rollback_pointers` and `competing_hypotheses` arrays deterministically sorted via `@model_validator`.\\n\\nMCP ROUTING TRIGGERS: Speculative Topology, Time-Rewinding Geometry, Probabilistic Divergence, Subgraph Fork, Execution Boundary\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"boundary_cid\","]
#[doc = "    \"commit_probability\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"boundary_cid\": {"]
#[doc = "      \"title\": \"Boundary Cid\","]
#[doc = "      \"description\": \"The unique CID anchoring the start of the speculative execution branch.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"commit_probability\": {"]
#[doc = "      \"title\": \"Commit Probability\","]
#[doc = "      \"description\": \"The assigned mathematical likelihood that the speculative branch will merge successfully.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"competing_hypotheses\": {"]
#[doc = "      \"title\": \"Competing Hypotheses\","]
#[doc = "      \"description\": \"CIDs for concurrent alternative paths generated during speculation.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1,"]
#[doc = "        \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "      },"]
#[doc = "      \"maxItems\": 10000"]
#[doc = "    },"]
#[doc = "    \"is_speculative\": {"]
#[doc = "      \"title\": \"Is Speculative\","]
#[doc = "      \"description\": \"Strict boolean indicating whether the boundary forces probabilistic execution paths.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"rollback_pointers\": {"]
#[doc = "      \"title\": \"Rollback Pointers\","]
#[doc = "      \"description\": \"CIDs referencing the deterministic states the orchestrator must rewind to upon branch falsification.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1,"]
#[doc = "        \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "      },"]
#[doc = "      \"maxItems\": 10000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SpeculativeExecutionPolicy {
    #[doc = "The unique CID anchoring the start of the speculative execution branch."]
    pub boundary_cid: BoundaryCid,
    #[doc = "The assigned mathematical likelihood that the speculative branch will merge successfully."]
    pub commit_probability: f64,
    #[doc = "CIDs for concurrent alternative paths generated during speculation."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub competing_hypotheses: ::std::vec::Vec<CompetingHypothesesItem>,
    #[doc = "Strict boolean indicating whether the boundary forces probabilistic execution paths."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub is_speculative: ::std::option::Option<bool>,
    #[doc = "CIDs referencing the deterministic states the orchestrator must rewind to upon branch falsification."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub rollback_pointers: ::std::vec::Vec<RollbackPointersItem>,
}
impl SpeculativeExecutionPolicy {
    pub fn builder() -> builder::SpeculativeExecutionPolicy {
        Default::default()
    }
}
#[doc = "Dictates whether the UI panel rotates freely on all axes (spherical) or locks to the Y-axis (cylindrical)."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Spherical Cylindrical Lock\","]
#[doc = "  \"description\": \"Dictates whether the UI panel rotates freely on all axes (spherical) or locks to the Y-axis (cylindrical).\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"spherical\","]
#[doc = "    \"cylindrical_y\","]
#[doc = "    \"none\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum SphericalCylindricalLock {
    #[serde(rename = "spherical")]
    Spherical,
    #[serde(rename = "cylindrical_y")]
    CylindricalY,
    #[serde(rename = "none")]
    None,
}
impl ::std::fmt::Display for SphericalCylindricalLock {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Spherical => f.write_str("spherical"),
            Self::CylindricalY => f.write_str("cylindrical_y"),
            Self::None => f.write_str("none"),
        }
    }
}
impl ::std::str::FromStr for SphericalCylindricalLock {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "spherical" => Ok(Self::Spherical),
            "cylindrical_y" => Ok(Self::CylindricalY),
            "none" => Ok(Self::None),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for SphericalCylindricalLock {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SphericalCylindricalLock {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SphericalCylindricalLock {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements an Asynchronous Event-Driven Architecture leveraging Server-Sent Events (SSE) to map a unidirectional, continuous topology of Server-to-Client state transitions.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator to maintain a persistent, long-lived TCP connection, processing incoming JSON-RPC streams without the thermodynamic overhead of continuous polling.\n\nEPISTEMIC BOUNDS: The `headers` are strictly limited via `StringConstraints` (`max_length=255/2000`).\n\nMCP ROUTING TRIGGERS: Event-Driven Architecture, Server-Sent Events, Unidirectional Stream, Asynchronous Message Passing, TCP Persistence"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SSETransportProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements an Asynchronous Event-Driven Architecture leveraging Server-Sent Events (SSE) to map a unidirectional, continuous topology of Server-to-Client state transitions.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator to maintain a persistent, long-lived TCP connection, processing incoming JSON-RPC streams without the thermodynamic overhead of continuous polling.\\n\\nEPISTEMIC BOUNDS: The `headers` are strictly limited via `StringConstraints` (`max_length=255/2000`).\\n\\nMCP ROUTING TRIGGERS: Event-Driven Architecture, Server-Sent Events, Unidirectional Stream, Asynchronous Message Passing, TCP Persistence\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"uri\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"headers\": {"]
#[doc = "      \"title\": \"Headers\","]
#[doc = "      \"description\": \"HTTP headers, e.g., for authentication.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Type of transport.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"sse\""]
#[doc = "    },"]
#[doc = "    \"uri\": {"]
#[doc = "      \"title\": \"Uri\","]
#[doc = "      \"description\": \"The HTTP URL endpoint for the SSE connection.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"format\": \"uri\","]
#[doc = "      \"maxLength\": 2083,"]
#[doc = "      \"minLength\": 1"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SseTransportProfile {
    #[doc = "HTTP headers, e.g., for authentication."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub headers:
        ::std::collections::HashMap<::std::string::String, SseTransportProfileHeadersValue>,
    #[doc = "Type of transport."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The HTTP URL endpoint for the SSE connection."]
    pub uri: ::std::string::String,
}
impl SseTransportProfile {
    pub fn builder() -> builder::SseTransportProfile {
        Default::default()
    }
}
#[doc = "`SseTransportProfileHeadersValue`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SseTransportProfileHeadersValue(::std::string::String);
impl ::std::ops::Deref for SseTransportProfileHeadersValue {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SseTransportProfileHeadersValue> for ::std::string::String {
    fn from(value: SseTransportProfileHeadersValue) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SseTransportProfileHeadersValue {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SseTransportProfileHeadersValue {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SseTransportProfileHeadersValue {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SseTransportProfileHeadersValue {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SseTransportProfileHeadersValue {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The mathematical curve applied to stakes. Quadratic enforces Sybil resistance."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Staking Function\","]
#[doc = "  \"description\": \"The mathematical curve applied to stakes. Quadratic enforces Sybil resistance.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"linear\","]
#[doc = "    \"quadratic\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum StakingFunction {
    #[serde(rename = "linear")]
    Linear,
    #[serde(rename = "quadratic")]
    Quadratic,
}
impl ::std::fmt::Display for StakingFunction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Linear => f.write_str("linear"),
            Self::Quadratic => f.write_str("quadratic"),
        }
    }
}
impl ::std::str::FromStr for StakingFunction {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "linear" => Ok(Self::Linear),
            "quadratic" => Ok(Self::Quadratic),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for StakingFunction {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for StakingFunction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for StakingFunction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The cryptographic pointer to the specific edge that failed empirical grounding."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Starved Edge Cid\","]
#[doc = "  \"description\": \"The cryptographic pointer to the specific edge that failed empirical grounding.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct StarvedEdgeCid(::std::string::String);
impl ::std::ops::Deref for StarvedEdgeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<StarvedEdgeCid> for ::std::string::String {
    fn from(value: StarvedEdgeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for StarvedEdgeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for StarvedEdgeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for StarvedEdgeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for StarvedEdgeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for StarvedEdgeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements a Cryptographic Tuple Space (Blackboard Pattern)\nserving as the strictly typed epistemic synchronization layer for multi-agent\nmanifolds. As a ...Contract suffix, this enforces rigid mathematical boundaries\nglobally.\n\nCAUSAL AFFORDANCE: Physically restricts all state mutations within the topology\nto conform to the explicit schema_definition (JSON Schema dict, key\nmax_length=255), acting as a deterministic Schema-on-Write validation gate.\n\nEPISTEMIC BOUNDS: The strict_validation boolean (default=True) acts as a\nphysical barrier against stochastic drift, forcing the orchestrator to reject\nany state mutation that fails the schema definition. Property names are capped\nat max_length=255 to prevent dictionary bombing.\n\nMCP ROUTING TRIGGERS: Tuple Space, Blackboard Architecture, Schema-on-Write,\nFinite State Automaton, Epistemic Synchronization"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"StateContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements a Cryptographic Tuple Space (Blackboard Pattern)\\nserving as the strictly typed epistemic synchronization layer for multi-agent\\nmanifolds. As a ...Contract suffix, this enforces rigid mathematical boundaries\\nglobally.\\n\\nCAUSAL AFFORDANCE: Physically restricts all state mutations within the topology\\nto conform to the explicit schema_definition (JSON Schema dict, key\\nmax_length=255), acting as a deterministic Schema-on-Write validation gate.\\n\\nEPISTEMIC BOUNDS: The strict_validation boolean (default=True) acts as a\\nphysical barrier against stochastic drift, forcing the orchestrator to reject\\nany state mutation that fails the schema definition. Property names are capped\\nat max_length=255 to prevent dictionary bombing.\\n\\nMCP ROUTING TRIGGERS: Tuple Space, Blackboard Architecture, Schema-on-Write,\\nFinite State Automaton, Epistemic Synchronization\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"schema_definition\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"decoding_policy\": {"]
#[doc = "      \"description\": \"The optional hardware-level execution limits for token masking.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ConstrainedDecodingPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"formal_schema_urn\": {"]
#[doc = "      \"title\": \"Formal Schema Urn\","]
#[doc = "      \"description\": \"The formal URN pointing to a verified external standard, supplementing or replacing the raw schema_definition dictionary.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"schema_definition\": {"]
#[doc = "      \"title\": \"Schema Definition\","]
#[doc = "      \"description\": \"A strict JSON Schema dictionary defining the required shape of the shared epistemic blackboard.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"strict_validation\": {"]
#[doc = "      \"title\": \"Strict Validation\","]
#[doc = "      \"description\": \"If True, the orchestrator must reject any state mutation that fails the schema definition.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct StateContract {
    #[doc = "The optional hardware-level execution limits for token masking."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub decoding_policy: ::std::option::Option<ConstrainedDecodingPolicy>,
    #[doc = "The formal URN pointing to a verified external standard, supplementing or replacing the raw schema_definition dictionary."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub formal_schema_urn: ::std::option::Option<::std::string::String>,
    #[doc = "A strict JSON Schema dictionary defining the required shape of the shared epistemic blackboard."]
    pub schema_definition: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "If True, the orchestrator must reject any state mutation that fails the schema definition."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub strict_validation: ::std::option::Option<bool>,
}
impl StateContract {
    pub fn builder() -> builder::StateContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Conflict-free Replicated Data Types (CRDTs) using Lamport\nlogical clocks and Vector Clocks to guarantee Eventual Consistency. As a ...Manifest\nsuffix, this defines a frozen, declarative coordinate of a state transition matrix.\n\nCAUSAL AFFORDANCE: Enables lock-free, decentralized state synchronization across the\nswarm. Forces the orchestrator to resolve Last-Writer-Wins (LWW) topological conflicts\nbefore flushing the patches (list[StateMutationIntent]) to the immutable Epistemic\nLedger. The vector_clock dict maps node CIDs to their ge=0 integer mutation counts.\n\nEPISTEMIC BOUNDS: Cryptographically anchored by diff_cid and author_node_cid (both\nstrict 128-char CID regex). The synchronization math is clamped by lamport_timestamp\n(ge=0, le=18446744073709551615), physically preventing logical clock integer overflow during\nprolonged swarm execution cycles.\n\nMCP ROUTING TRIGGERS: Conflict-Free Replicated Data Types, Lamport Logical Clock,\nVector Clock, Eventual Consistency, Last-Writer-Wins"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"StateDifferentialManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Conflict-free Replicated Data Types (CRDTs) using Lamport\\nlogical clocks and Vector Clocks to guarantee Eventual Consistency. As a ...Manifest\\nsuffix, this defines a frozen, declarative coordinate of a state transition matrix.\\n\\nCAUSAL AFFORDANCE: Enables lock-free, decentralized state synchronization across the\\nswarm. Forces the orchestrator to resolve Last-Writer-Wins (LWW) topological conflicts\\nbefore flushing the patches (list[StateMutationIntent]) to the immutable Epistemic\\nLedger. The vector_clock dict maps node CIDs to their ge=0 integer mutation counts.\\n\\nEPISTEMIC BOUNDS: Cryptographically anchored by diff_cid and author_node_cid (both\\nstrict 128-char CID regex). The synchronization math is clamped by lamport_timestamp\\n(ge=0, le=18446744073709551615), physically preventing logical clock integer overflow during\\nprolonged swarm execution cycles.\\n\\nMCP ROUTING TRIGGERS: Conflict-Free Replicated Data Types, Lamport Logical Clock,\\nVector Clock, Eventual Consistency, Last-Writer-Wins\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"author_node_cid\","]
#[doc = "    \"diff_cid\","]
#[doc = "    \"lamport_timestamp\","]
#[doc = "    \"vector_clock\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"author_node_cid\": {"]
#[doc = "      \"title\": \"Author Node Cid\","]
#[doc = "      \"description\": \"The exact Lineage Watermark of the agent or system that authored this state mutation.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"diff_cid\": {"]
#[doc = "      \"title\": \"Diff Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this state differential.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"lamport_timestamp\": {"]
#[doc = "      \"title\": \"Lamport Timestamp\","]
#[doc = "      \"description\": \"Strict scalar logical clock governing deterministic LWW (Last-Writer-Wins) conflict resolution.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"patches\": {"]
#[doc = "      \"title\": \"Patches\","]
#[doc = "      \"description\": \"The exact, ordered sequence of deterministic state vector mutations.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/StateMutationIntent\""]
#[doc = "      },"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"vector_clock\": {"]
#[doc = "      \"title\": \"Vector Clock\","]
#[doc = "      \"description\": \"Causal history mapping of all known Lineage Watermarks to their latest logical mutation count at the time of authoring.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"integer\","]
#[doc = "        \"minimum\": 0.0"]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false,"]
#[doc = "  \"x-domain-cluster\": \"epistemic_ledger\","]
#[doc = "  \"x-synergistic-classes\": ["]
#[doc = "    \"EpistemicLedgerState\","]
#[doc = "    \"ObservationEvent\","]
#[doc = "    \"BeliefMutationEvent\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct StateDifferentialManifest {
    #[doc = "The exact Lineage Watermark of the agent or system that authored this state mutation."]
    pub author_node_cid: AuthorNodeCid,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for this state differential."]
    pub diff_cid: DiffCid,
    #[doc = "Strict scalar logical clock governing deterministic LWW (Last-Writer-Wins) conflict resolution."]
    pub lamport_timestamp: u64,
    #[doc = "The exact, ordered sequence of deterministic state vector mutations."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub patches: ::std::vec::Vec<StateMutationIntent>,
    #[doc = "Causal history mapping of all known Lineage Watermarks to their latest logical mutation count at the time of authoring."]
    pub vector_clock: ::std::collections::HashMap<::std::string::String, u64>,
}
impl StateDifferentialManifest {
    pub fn builder() -> builder::StateDifferentialManifest {
        Default::default()
    }
}
#[doc = "The canonical RFC 8785 SHA-256 hash of the entire topology at this exact index."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"State Hash\","]
#[doc = "  \"description\": \"The canonical RFC 8785 SHA-256 hash of the entire topology at this exact index.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct StateHash(::std::string::String);
impl ::std::ops::Deref for StateHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<StateHash> for ::std::string::String {
    fn from(value: StateHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for StateHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for StateHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for StateHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for StateHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for StateHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Manages the Epistemic Hydration of an agent's active context\npartition from cold storage, bridging immutable EpistemicLedgerState checkpoints and\nephemeral working memory. As a ...Manifest suffix, this defines a frozen configuration\nstate.\n\nCAUSAL AFFORDANCE: Authorizes the physical injection of serialized semantic data\n(working_context_variables) into the LLM's forward-pass generation window, seeding\nthe context prior to probability wave collapse. The crystallized_ledger_cids (SHA-256\npointers) bind to past immutable ledger blocks.\n\nEPISTEMIC BOUNDS: VRAM exhaustion is prevented by max_retained_tokens (gt=0,\nle=18446744073709551615). The @field_validator enforce_payload_topology calls\n_validate_payload_bounds to prevent Dictionary Bombing on working_context_variables.\nThe @model_validator sort_arrays deterministically sorts crystallized_ledger_cids for\nRFC 8785 canonical hashing.\n\nMCP ROUTING TRIGGERS: Epistemic Hydration, Working Memory Injection, Context Window\nPartitioning, VRAM Bounding, Serialization Geometry"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"StateHydrationManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Manages the Epistemic Hydration of an agent's active context\\npartition from cold storage, bridging immutable EpistemicLedgerState checkpoints and\\nephemeral working memory. As a ...Manifest suffix, this defines a frozen configuration\\nstate.\\n\\nCAUSAL AFFORDANCE: Authorizes the physical injection of serialized semantic data\\n(working_context_variables) into the LLM's forward-pass generation window, seeding\\nthe context prior to probability wave collapse. The crystallized_ledger_cids (SHA-256\\npointers) bind to past immutable ledger blocks.\\n\\nEPISTEMIC BOUNDS: VRAM exhaustion is prevented by max_retained_tokens (gt=0,\\nle=18446744073709551615). The @field_validator enforce_payload_topology calls\\n_validate_payload_bounds to prevent Dictionary Bombing on working_context_variables.\\nThe @model_validator sort_arrays deterministically sorts crystallized_ledger_cids for\\nRFC 8785 canonical hashing.\\n\\nMCP ROUTING TRIGGERS: Epistemic Hydration, Working Memory Injection, Context Window\\nPartitioning, VRAM Bounding, Serialization Geometry\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"crystallized_ledger_cids\","]
#[doc = "    \"epistemic_coordinate\","]
#[doc = "    \"max_retained_tokens\","]
#[doc = "    \"working_context_variables\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"crystallized_ledger_cids\": {"]
#[doc = "      \"title\": \"Crystallized Ledger Cids\","]
#[doc = "      \"description\": \"The explicit array of cryptographic pointers to past immutable EpistemicLedgerState blocks.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"epistemic_coordinate\": {"]
#[doc = "      \"title\": \"Epistemic Coordinate\","]
#[doc = "      \"description\": \"A string ID representing the session or specific spatial trace binding.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"max_retained_tokens\": {"]
#[doc = "      \"title\": \"Max Retained Tokens\","]
#[doc = "      \"description\": \"An integer representing the physical limit of the context window.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"unfolding_policy\": {"]
#[doc = "      \"description\": \"The mathematical bounds for lazy state unfolding.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EpistemicHydrationPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"working_context_variables\": {"]
#[doc = "      \"title\": \"Working Context Variables\","]
#[doc = "      \"description\": \"A strictly typed dictionary for ephemeral context variables injected at runtime. AGENT INSTRUCTION: This matrix is deterministically sorted by CoreasonBaseState natively. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct StateHydrationManifest {
    #[doc = "The explicit array of cryptographic pointers to past immutable EpistemicLedgerState blocks."]
    pub crystallized_ledger_cids: ::std::vec::Vec<CrystallizedLedgerCidsItem>,
    #[doc = "A string ID representing the session or specific spatial trace binding."]
    pub epistemic_coordinate: EpistemicCoordinate,
    #[doc = "An integer representing the physical limit of the context window."]
    pub max_retained_tokens: ::std::num::NonZeroU64,
    #[doc = "The mathematical bounds for lazy state unfolding."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub unfolding_policy: ::std::option::Option<EpistemicHydrationPolicy>,
    #[doc = "A strictly typed dictionary for ephemeral context variables injected at runtime. AGENT INSTRUCTION: This matrix is deterministically sorted by CoreasonBaseState natively. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    pub working_context_variables:
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
}
impl StateHydrationManifest {
    pub fn builder() -> builder::StateHydrationManifest {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"StateMutationIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"op\","]
#[doc = "    \"path\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"from\": {"]
#[doc = "      \"title\": \"From\","]
#[doc = "      \"description\": \"The JSON pointer from which to copy or move the state vector, if applicable.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"op\": {"]
#[doc = "      \"description\": \"The strict RFC 6902 JSON Patch operation, acting as a deterministic state vector mutation.\","]
#[doc = "      \"$ref\": \"#/$defs/PatchOperationProfile\""]
#[doc = "    },"]
#[doc = "    \"path\": {"]
#[doc = "      \"title\": \"Path\","]
#[doc = "      \"description\": \"The JSON pointer indicating the exact state vector to mutate deterministically.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"state_mutation_intent\""]
#[doc = "    },"]
#[doc = "    \"value\": {"]
#[doc = "      \"description\": \"The payload to insert or test, if applicable, for this deterministic state vector mutation. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"zero_trust_receipt_cid\": {"]
#[doc = "      \"title\": \"Zero Trust Receipt Cid\","]
#[doc = "      \"description\": \"Cryptographic proof that this mutation was sanitized by the Symbolic Firewall.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct StateMutationIntent {
    #[doc = "The JSON pointer from which to copy or move the state vector, if applicable."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub from: ::std::option::Option<::std::string::String>,
    #[doc = "The strict RFC 6902 JSON Patch operation, acting as a deterministic state vector mutation."]
    pub op: PatchOperationProfile,
    #[doc = "The JSON pointer indicating the exact state vector to mutate deterministically."]
    pub path: Path,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The payload to insert or test, if applicable, for this deterministic state vector mutation. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub value: ::std::option::Option<JsonPrimitiveState>,
    #[doc = "Cryptographic proof that this mutation was sanitized by the Symbolic Firewall."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub zero_trust_receipt_cid: ::std::option::Option<::std::string::String>,
}
impl StateMutationIntent {
    pub fn builder() -> builder::StateMutationIntent {
        Default::default()
    }
}
#[doc = "The cryptographic material the agents must sign to submit a valid vote."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"State Validation Metric\","]
#[doc = "  \"description\": \"The cryptographic material the agents must sign to submit a valid vote.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"ledger_hash\","]
#[doc = "    \"zk_proof\","]
#[doc = "    \"semantic_embedding\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum StateValidationMetric {
    #[serde(rename = "ledger_hash")]
    LedgerHash,
    #[serde(rename = "zk_proof")]
    ZkProof,
    #[serde(rename = "semantic_embedding")]
    SemanticEmbedding,
}
impl ::std::fmt::Display for StateValidationMetric {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::LedgerHash => f.write_str("ledger_hash"),
            Self::ZkProof => f.write_str("zk_proof"),
            Self::SemanticEmbedding => f.write_str("semantic_embedding"),
        }
    }
}
impl ::std::str::FromStr for StateValidationMetric {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "ledger_hash" => Ok(Self::LedgerHash),
            "zk_proof" => Ok(Self::ZkProof),
            "semantic_embedding" => Ok(Self::SemanticEmbedding),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for StateValidationMetric {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for StateValidationMetric {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for StateValidationMetric {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Labeled Transition System (LTS) Determinism to track continuous agent Markov states.\n\n    CAUSAL AFFORDANCE: Forces all hidden LLM contexts into an explicitly typed data structure, making the agent a Markov Process with Full Observability.\n\n    EPISTEMIC BOUNDS: Memory boundaries are strictly mapped to maximum recursive depth topologies to prevent hardware CPU/VRAM exhaustion via the _validate_payload_bounds orchestrator.\n\n    MCP ROUTING TRIGGERS: Labeled Transition System, Markov Process, Full Observability, State Vector, Memory Boundary"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"StateVectorProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Labeled Transition System (LTS) Determinism to track continuous agent Markov states.\\n\\n    CAUSAL AFFORDANCE: Forces all hidden LLM contexts into an explicitly typed data structure, making the agent a Markov Process with Full Observability.\\n\\n    EPISTEMIC BOUNDS: Memory boundaries are strictly mapped to maximum recursive depth topologies to prevent hardware CPU/VRAM exhaustion via the _validate_payload_bounds orchestrator.\\n\\n    MCP ROUTING TRIGGERS: Labeled Transition System, Markov Process, Full Observability, State Vector, Memory Boundary\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"properties\": {"]
#[doc = "    \"immutable_matrix\": {"]
#[doc = "      \"title\": \"Immutable Matrix\","]
#[doc = "      \"description\": \"Immutable behavior directives (e.g., global personas, fixed dataset schemas, boundary rules).\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"is_delta\": {"]
#[doc = "      \"title\": \"Is Delta\","]
#[doc = "      \"description\": \"A flag allowing the output to only return the keys in mutable_matrix that changed, rather than forcing the entire array back up the network.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"mutable_matrix\": {"]
#[doc = "      \"title\": \"Mutable Matrix\","]
#[doc = "      \"description\": \"The agent's scratchpad, chat history, and any writable states.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"object\","]
#[doc = "          \"additionalProperties\": {"]
#[doc = "            \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "          }"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct StateVectorProfile {
    #[doc = "Immutable behavior directives (e.g., global personas, fixed dataset schemas, boundary rules)."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub immutable_matrix: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "A flag allowing the output to only return the keys in mutable_matrix that changed, rather than forcing the entire array back up the network."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub is_delta: ::std::option::Option<bool>,
    #[doc = "The agent's scratchpad, chat history, and any writable states."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub mutable_matrix: ::std::option::Option<
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    >,
}
impl ::std::default::Default for StateVectorProfile {
    fn default() -> Self {
        Self {
            immutable_matrix: Default::default(),
            is_delta: Default::default(),
            mutable_matrix: Default::default(),
        }
    }
}
impl StateVectorProfile {
    pub fn builder() -> builder::StateVectorProfile {
        Default::default()
    }
}
#[doc = "The current validity state of this hypothesis in the EpistemicLedgerState."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Status\","]
#[doc = "  \"description\": \"The current validity state of this hypothesis in the EpistemicLedgerState.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"active\","]
#[doc = "    \"falsified\","]
#[doc = "    \"verified\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum Status {
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "falsified")]
    Falsified,
    #[serde(rename = "verified")]
    Verified,
}
impl ::std::fmt::Display for Status {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Active => f.write_str("active"),
            Self::Falsified => f.write_str("falsified"),
            Self::Verified => f.write_str("verified"),
        }
    }
}
impl ::std::str::FromStr for Status {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "active" => Ok(Self::Active),
            "falsified" => Ok(Self::Falsified),
            "verified" => Ok(Self::Verified),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for Status {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Status {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Status {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The semantic 1D string projection representing the active kinetic execution state."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Status Message\","]
#[doc = "  \"description\": \"The semantic 1D string projection representing the active kinetic execution state.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct StatusMessage(::std::string::String);
impl ::std::ops::Deref for StatusMessage {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<StatusMessage> for ::std::string::String {
    fn from(value: StatusMessage) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for StatusMessage {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for StatusMessage {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for StatusMessage {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for StatusMessage {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for StatusMessage {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SHA-256 hash tracking structural deviation anomalies."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Stderr Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash tracking structural deviation anomalies.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct StderrHash(::std::string::String);
impl ::std::ops::Deref for StderrHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<StderrHash> for ::std::string::String {
    fn from(value: StderrHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for StderrHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for StderrHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for StderrHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for StderrHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for StderrHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Inter-Process Communication (IPC) utilizing POSIX standard streams to execute highly isolated, local binary sandboxing.\n\nCAUSAL AFFORDANCE: Physically spawns a child process restricted to the host's operating system namespace, mapping remote procedure calls directly into the binary's stdin/stdout descriptors via `command` (`max_length=2000`).\n\nEPISTEMIC BOUNDS: To prevent buffer overflow and command injection, `args` are structurally constrained (`max_length=1000`, string `max_length=2000`) and `env_vars` keys/values are strictly delimited via `StringConstraints` (`max_length=255` and `2000`).\n\nMCP ROUTING TRIGGERS: Inter-Process Communication, POSIX Standard Streams, Local Sandboxing, Binary Execution, Subprocess Spawn"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"StdioTransportProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Inter-Process Communication (IPC) utilizing POSIX standard streams to execute highly isolated, local binary sandboxing.\\n\\nCAUSAL AFFORDANCE: Physically spawns a child process restricted to the host's operating system namespace, mapping remote procedure calls directly into the binary's stdin/stdout descriptors via `command` (`max_length=2000`).\\n\\nEPISTEMIC BOUNDS: To prevent buffer overflow and command injection, `args` are structurally constrained (`max_length=1000`, string `max_length=2000`) and `env_vars` keys/values are strictly delimited via `StringConstraints` (`max_length=255` and `2000`).\\n\\nMCP ROUTING TRIGGERS: Inter-Process Communication, POSIX Standard Streams, Local Sandboxing, Binary Execution, Subprocess Spawn\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"command\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"args\": {"]
#[doc = "      \"title\": \"Args\","]
#[doc = "      \"description\": \"The explicit array of arguments to pass to the command.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000,"]
#[doc = "      \"coreason_topological_exemption\": true"]
#[doc = "    },"]
#[doc = "    \"command\": {"]
#[doc = "      \"title\": \"Command\","]
#[doc = "      \"description\": \"The command executable to run (e.g., 'node', 'python').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"env_vars\": {"]
#[doc = "      \"title\": \"Env Vars\","]
#[doc = "      \"description\": \"Environment variables required by the transport.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Type of transport.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"stdio\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct StdioTransportProfile {
    #[doc = "The explicit array of arguments to pass to the command."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub args: ::std::vec::Vec<ArgsItem>,
    #[doc = "The command executable to run (e.g., 'node', 'python')."]
    pub command: Command,
    #[doc = "Environment variables required by the transport."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub env_vars:
        ::std::collections::HashMap<::std::string::String, StdioTransportProfileEnvVarsValue>,
    #[doc = "Type of transport."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl StdioTransportProfile {
    pub fn builder() -> builder::StdioTransportProfile {
        Default::default()
    }
}
#[doc = "`StdioTransportProfileEnvVarsValue`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct StdioTransportProfileEnvVarsValue(::std::string::String);
impl ::std::ops::Deref for StdioTransportProfileEnvVarsValue {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<StdioTransportProfileEnvVarsValue> for ::std::string::String {
    fn from(value: StdioTransportProfileEnvVarsValue) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for StdioTransportProfileEnvVarsValue {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for StdioTransportProfileEnvVarsValue {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for StdioTransportProfileEnvVarsValue {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for StdioTransportProfileEnvVarsValue {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for StdioTransportProfileEnvVarsValue {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SHA-256 hash of the Exogenous Perturbations captured."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Stdout Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the Exogenous Perturbations captured.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct StdoutHash(::std::string::String);
impl ::std::ops::Deref for StdoutHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<StdoutHash> for ::std::string::String {
    fn from(value: StdoutHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for StdoutHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for StdoutHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for StdoutHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for StdoutHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for StdoutHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The SHA-256 hash of the extracted RepE control tensor (e.g., the 'caution' vector)."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Steering Vector Hash\","]
#[doc = "  \"description\": \"The SHA-256 hash of the extracted RepE control tensor (e.g., the 'caution' vector).\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SteeringVectorHash(::std::string::String);
impl ::std::ops::Deref for SteeringVectorHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SteeringVectorHash> for ::std::string::String {
    fn from(value: SteeringVectorHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SteeringVectorHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SteeringVectorHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SteeringVectorHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SteeringVectorHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SteeringVectorHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`StochasticMutationGradient`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Stochastic Mutation Gradient\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct StochasticMutationGradient(::std::string::String);
impl ::std::ops::Deref for StochasticMutationGradient {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<StochasticMutationGradient> for ::std::string::String {
    fn from(value: StochasticMutationGradient) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for StochasticMutationGradient {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for StochasticMutationGradient {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for StochasticMutationGradient {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for StochasticMutationGradient {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for StochasticMutationGradient {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A single discrete latent coordinate (a generated hypothesis or critique) inside an unverified stochastic diffusion search space.\n\nCAUSAL AFFORDANCE: Used by the ensemble as a vertex to map out Monte Carlo Tree Search (MCTS) exploration before manifold collapse.\n\nEPISTEMIC BOUNDS: epistemic_entropy is mathematically clamped to `[0.0, 1.0]` bounds (Shannon entropy).\n\nMCP ROUTING TRIGGERS: Latent Space Coordinates, MCTS Nodes, Shannon Entropy Bounding"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"StochasticNodeState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A single discrete latent coordinate (a generated hypothesis or critique) inside an unverified stochastic diffusion search space.\\n\\nCAUSAL AFFORDANCE: Used by the ensemble as a vertex to map out Monte Carlo Tree Search (MCTS) exploration before manifold collapse.\\n\\nEPISTEMIC BOUNDS: epistemic_entropy is mathematically clamped to `[0.0, 1.0]` bounds (Shannon entropy).\\n\\nMCP ROUTING TRIGGERS: Latent Space Coordinates, MCTS Nodes, Shannon Entropy Bounding\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"agent_role\","]
#[doc = "    \"epistemic_entropy\","]
#[doc = "    \"node_cid\","]
#[doc = "    \"stochastic_tensor\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"agent_role\": {"]
#[doc = "      \"title\": \"Agent Role\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"generator\","]
#[doc = "        \"critic\","]
#[doc = "        \"synthesizer\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"epistemic_entropy\": {"]
#[doc = "      \"title\": \"Epistemic Entropy\","]
#[doc = "      \"type\": \"number\""]
#[doc = "    },"]
#[doc = "    \"node_cid\": {"]
#[doc = "      \"title\": \"Node Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"parent_node_cid\": {"]
#[doc = "      \"title\": \"Parent Node Cid\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"stochastic_tensor\": {"]
#[doc = "      \"title\": \"Stochastic Tensor\","]
#[doc = "      \"description\": \"Unbounded semantic payload\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct StochasticNodeState {
    pub agent_role: AgentRole,
    pub epistemic_entropy: f64,
    pub node_cid: NodeCid,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub parent_node_cid: ::std::option::Option<::std::string::String>,
    #[doc = "Unbounded semantic payload"]
    pub stochastic_tensor: StochasticTensor,
}
impl StochasticNodeState {
    pub fn builder() -> builder::StochasticNodeState {
        Default::default()
    }
}
#[doc = "Unbounded semantic payload"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Stochastic Tensor\","]
#[doc = "  \"description\": \"Unbounded semantic payload\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct StochasticTensor(::std::string::String);
impl ::std::ops::Deref for StochasticTensor {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<StochasticTensor> for ::std::string::String {
    fn from(value: StochasticTensor) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for StochasticTensor {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for StochasticTensor {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for StochasticTensor {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for StochasticTensor {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for StochasticTensor {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: The structurally unbounded root container modeling multi-agent generative reasoning as a Topological DAG.\n\nCAUSAL AFFORDANCE: Holds unverified, high-variance semantic coordinates and manages MCTS execution.\n\nEPISTEMIC BOUNDS: Inherently enforces referential integrity for acyclic DAG sorting via `verify_acyclic_dag_integrity`. `epistemic_status` is locked strictly to 'stochastically_unbounded'.\n\nMCP ROUTING TRIGGERS: Directed Acyclic Graphs, Topological MCTS Container, Epistemic Immutability, Acyclic Integrity"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"StochasticTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: The structurally unbounded root container modeling multi-agent generative reasoning as a Topological DAG.\\n\\nCAUSAL AFFORDANCE: Holds unverified, high-variance semantic coordinates and manages MCTS execution.\\n\\nEPISTEMIC BOUNDS: Inherently enforces referential integrity for acyclic DAG sorting via `verify_acyclic_dag_integrity`. `epistemic_status` is locked strictly to 'stochastically_unbounded'.\\n\\nMCP ROUTING TRIGGERS: Directed Acyclic Graphs, Topological MCTS Container, Epistemic Immutability, Acyclic Integrity\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"phase\","]
#[doc = "    \"stochastic_graph\","]
#[doc = "    \"topology_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"epistemic_status\": {"]
#[doc = "      \"title\": \"Epistemic Status\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"stochastically_unbounded\""]
#[doc = "    },"]
#[doc = "    \"phase\": {"]
#[doc = "      \"$ref\": \"#/$defs/IdeationPhaseProfile\""]
#[doc = "    },"]
#[doc = "    \"stochastic_graph\": {"]
#[doc = "      \"title\": \"Stochastic Graph\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/StochasticNodeState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"superposition\": {"]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/HypothesisSuperpositionState\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_cid\": {"]
#[doc = "      \"title\": \"Topology Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"stochastic_ensemble\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct StochasticTopologyManifest {
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_status: ::std::option::Option<::std::string::String>,
    pub phase: IdeationPhaseProfile,
    pub stochastic_graph: ::std::vec::Vec<StochasticNodeState>,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub superposition: ::std::option::Option<HypothesisSuperpositionState>,
    pub topology_cid: TopologyCid,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl StochasticTopologyManifest {
    pub fn builder() -> builder::StochasticTopologyManifest {
        Default::default()
    }
}
#[doc = "Strict URI pointer to the physical bytes."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Storage Uri\","]
#[doc = "  \"description\": \"Strict URI pointer to the physical bytes.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct StorageUri(::std::string::String);
impl ::std::ops::Deref for StorageUri {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<StorageUri> for ::std::string::String {
    fn from(value: StorageUri) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for StorageUri {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for StorageUri {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for StorageUri {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for StorageUri {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for StorageUri {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Instantiates a single discrete node within a Monte Carlo Tree Search (MCTS) topology for long-horizon strategic planning. Emitted by the Claw Code agent during deliberation within the unconstrained `<deliberation>` envelope. The `urn:coreason:oracle:strategic_mcts` MCP evaluates these nodes via the UCT formula and returns expansion or pruning directives.\n\nCAUSAL AFFORDANCE: Connects discrete logic Premises into a fully verifiable proof tree managed by the Strategic MCTS Oracle. The `parent_node_hash` establishes the Merkle-DAG lineage to the parent thought, enabling deterministic traversal and rollback of rejected reasoning paths. The `heuristic_confidence` feeds directly into the UCT exploration-exploitation calculation.\n\nEPISTEMIC BOUNDS: The `parent_node_hash` is strictly bounded to exactly 64 hexadecimal characters (SHA-256), establishing a cryptographic chain of custody. The `heuristic_confidence` is bounded to `[0.0, 1.0]` representing a self-evaluated probability of success. The `proposed_action` and `rationale` are bounded to 10,000 characters each to prevent context window exhaustion.\n\nMCP ROUTING TRIGGERS: Monte Carlo Tree Search, UCT Formula, Strategic Planning, Claw Code Deliberation, Test-Time Compute, Thought Node, Tree of Thoughts"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"StrategicThoughtNodeIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Instantiates a single discrete node within a Monte Carlo Tree Search (MCTS) topology for long-horizon strategic planning. Emitted by the Claw Code agent during deliberation within the unconstrained `<deliberation>` envelope. The `urn:coreason:oracle:strategic_mcts` MCP evaluates these nodes via the UCT formula and returns expansion or pruning directives.\\n\\nCAUSAL AFFORDANCE: Connects discrete logic Premises into a fully verifiable proof tree managed by the Strategic MCTS Oracle. The `parent_node_hash` establishes the Merkle-DAG lineage to the parent thought, enabling deterministic traversal and rollback of rejected reasoning paths. The `heuristic_confidence` feeds directly into the UCT exploration-exploitation calculation.\\n\\nEPISTEMIC BOUNDS: The `parent_node_hash` is strictly bounded to exactly 64 hexadecimal characters (SHA-256), establishing a cryptographic chain of custody. The `heuristic_confidence` is bounded to `[0.0, 1.0]` representing a self-evaluated probability of success. The `proposed_action` and `rationale` are bounded to 10,000 characters each to prevent context window exhaustion.\\n\\nMCP ROUTING TRIGGERS: Monte Carlo Tree Search, UCT Formula, Strategic Planning, Claw Code Deliberation, Test-Time Compute, Thought Node, Tree of Thoughts\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"heuristic_confidence\","]
#[doc = "    \"parent_node_hash\","]
#[doc = "    \"proposed_action\","]
#[doc = "    \"rationale\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"heuristic_confidence\": {"]
#[doc = "      \"title\": \"Heuristic Confidence\","]
#[doc = "      \"description\": \"Self-evaluated probability of success for this proposed action, fed directly into the UCT exploration-exploitation formula by the Strategic MCTS Oracle.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"parent_node_hash\": {"]
#[doc = "      \"title\": \"Parent Node Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the parent thought node in the MCTS tree, establishing Merkle-DAG lineage. For root nodes, use the SHA-256 hash of the initial escalation intent.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"proposed_action\": {"]
#[doc = "      \"title\": \"Proposed Action\","]
#[doc = "      \"description\": \"A structured natural-language description of the proposed heuristic leap or code modification strategy.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 10000,"]
#[doc = "      \"minLength\": 1"]
#[doc = "    },"]
#[doc = "    \"rationale\": {"]
#[doc = "      \"title\": \"Rationale\","]
#[doc = "      \"description\": \"The causal reasoning chain explaining why this action is expected to resolve the epistemic deficit, including references to specific code structures or domain constraints.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 10000,"]
#[doc = "      \"minLength\": 1"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for MCTS thought nodes within the strategic planning topology.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"strategic_thought_node\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct StrategicThoughtNodeIntent {
    #[doc = "Self-evaluated probability of success for this proposed action, fed directly into the UCT exploration-exploitation formula by the Strategic MCTS Oracle."]
    pub heuristic_confidence: f64,
    #[doc = "The SHA-256 hash of the parent thought node in the MCTS tree, establishing Merkle-DAG lineage. For root nodes, use the SHA-256 hash of the initial escalation intent."]
    pub parent_node_hash: ParentNodeHash,
    #[doc = "A structured natural-language description of the proposed heuristic leap or code modification strategy."]
    pub proposed_action: ProposedAction,
    #[doc = "The causal reasoning chain explaining why this action is expected to resolve the epistemic deficit, including references to specific code structures or domain constraints."]
    pub rationale: Rationale,
    #[doc = "Discriminator for MCTS thought nodes within the strategic planning topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl StrategicThoughtNodeIntent {
    pub fn builder() -> builder::StrategicThoughtNodeIntent {
        Default::default()
    }
}
#[doc = "The mathematical rule for reaching agreement."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Strategy\","]
#[doc = "  \"description\": \"The mathematical rule for reaching agreement.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"unanimous\","]
#[doc = "    \"majority\","]
#[doc = "    \"debate_rounds\","]
#[doc = "    \"prediction_market\","]
#[doc = "    \"pbft\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum Strategy {
    #[serde(rename = "unanimous")]
    Unanimous,
    #[serde(rename = "majority")]
    Majority,
    #[serde(rename = "debate_rounds")]
    DebateRounds,
    #[serde(rename = "prediction_market")]
    PredictionMarket,
    #[serde(rename = "pbft")]
    Pbft,
}
impl ::std::fmt::Display for Strategy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Unanimous => f.write_str("unanimous"),
            Self::Majority => f.write_str("majority"),
            Self::DebateRounds => f.write_str("debate_rounds"),
            Self::PredictionMarket => f.write_str("prediction_market"),
            Self::Pbft => f.write_str("pbft"),
        }
    }
}
impl ::std::str::FromStr for Strategy {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "unanimous" => Ok(Self::Unanimous),
            "majority" => Ok(Self::Majority),
            "debate_rounds" => Ok(Self::DebateRounds),
            "prediction_market" => Ok(Self::PredictionMarket),
            "pbft" => Ok(Self::Pbft),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for Strategy {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Strategy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Strategy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "A Content Identifier (CID) for the continuous observation stream."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Stream Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) for the continuous observation stream.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct StreamCid(::std::string::String);
impl ::std::ops::Deref for StreamCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<StreamCid> for ::std::string::String {
    fn from(value: StreamCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for StreamCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for StreamCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for StreamCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for StreamCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for StreamCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements non-monotonic disfluency and \"forget gate\" triggers to repair continuous ingestion streams.\n\nCAUSAL AFFORDANCE: Triggers the orchestrator to excise or repair segments of the token stream when the `repair_marker_regex` matches, probabilistically governed by the `decay_threshold`.\n\nEPISTEMIC BOUNDS: `repair_marker_regex` is strictly capped at `max_length=2000` to prevent ReDoS CPU exhaustion. `decay_threshold` geometrically bounded (`ge=0.0, le=1.0`). Maximum temporal lookback clamped (`ge=0, le=18446744073709551615`).\n\nMCP ROUTING TRIGGERS: Streaming Disfluency, Forget Gate, Token Excise, Sequence Repair, Temporal Lookback"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"StreamingDisfluencyContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements non-monotonic disfluency and \\\"forget gate\\\" triggers to repair continuous ingestion streams.\\n\\nCAUSAL AFFORDANCE: Triggers the orchestrator to excise or repair segments of the token stream when the `repair_marker_regex` matches, probabilistically governed by the `decay_threshold`.\\n\\nEPISTEMIC BOUNDS: `repair_marker_regex` is strictly capped at `max_length=2000` to prevent ReDoS CPU exhaustion. `decay_threshold` geometrically bounded (`ge=0.0, le=1.0`). Maximum temporal lookback clamped (`ge=0, le=18446744073709551615`).\\n\\nMCP ROUTING TRIGGERS: Streaming Disfluency, Forget Gate, Token Excise, Sequence Repair, Temporal Lookback\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"decay_threshold\","]
#[doc = "    \"max_lookback_window\","]
#[doc = "    \"repair_marker_regex\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"decay_threshold\": {"]
#[doc = "      \"title\": \"Decay Threshold\","]
#[doc = "      \"description\": \"The probability boundary below which historical stream data is aggressively decayed.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"max_lookback_window\": {"]
#[doc = "      \"title\": \"Max Lookback Window\","]
#[doc = "      \"description\": \"The maximum number of sequence steps the orchestrator is permitted to rewind and repair.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"repair_marker_regex\": {"]
#[doc = "      \"title\": \"Repair Marker Regex\","]
#[doc = "      \"description\": \"The regular expression pattern identifying a structural disfluency marker in the stream.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct StreamingDisfluencyContract {
    #[doc = "The probability boundary below which historical stream data is aggressively decayed."]
    pub decay_threshold: f64,
    #[doc = "The maximum number of sequence steps the orchestrator is permitted to rewind and repair."]
    pub max_lookback_window: u64,
    #[doc = "The regular expression pattern identifying a structural disfluency marker in the stream."]
    pub repair_marker_regex: RepairMarkerRegex,
}
impl StreamingDisfluencyContract {
    pub fn builder() -> builder::StreamingDisfluencyContract {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Judea Pearl's Structural Causal Models (SCMs) by mapping the causal topology of observed and latent variables.\n\nCAUSAL AFFORDANCE: Unlocks do-calculus and interventional logic by providing the orchestrator with the explicit DAG required to identify confounders and compute causal effects.\n\nEPISTEMIC BOUNDS: Variables are constrained by strict bounds (max_length=255). The @model_validator deterministically sorts observed_variables, latent_variables, and causal_edges to mathematically guarantee zero-variance RFC 8785 canonical hashing.\n\nMCP ROUTING TRIGGERS: Structural Causal Models, Pearlian DAG, Latent Confounder, d-separation, Interventional Topology"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"StructuralCausalGraphProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Judea Pearl's Structural Causal Models (SCMs) by mapping the causal topology of observed and latent variables.\\n\\nCAUSAL AFFORDANCE: Unlocks do-calculus and interventional logic by providing the orchestrator with the explicit DAG required to identify confounders and compute causal effects.\\n\\nEPISTEMIC BOUNDS: Variables are constrained by strict bounds (max_length=255). The @model_validator deterministically sorts observed_variables, latent_variables, and causal_edges to mathematically guarantee zero-variance RFC 8785 canonical hashing.\\n\\nMCP ROUTING TRIGGERS: Structural Causal Models, Pearlian DAG, Latent Confounder, d-separation, Interventional Topology\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"causal_edges\","]
#[doc = "    \"latent_variables\","]
#[doc = "    \"observed_variables\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"causal_edges\": {"]
#[doc = "      \"title\": \"Causal Edges\","]
#[doc = "      \"description\": \"The declared topological mapping of causality.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/CausalDirectedEdgeState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"latent_variables\": {"]
#[doc = "      \"title\": \"Latent Variables\","]
#[doc = "      \"description\": \"The unobserved confounders the agent suspects exist.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000"]
#[doc = "    },"]
#[doc = "    \"observed_variables\": {"]
#[doc = "      \"title\": \"Observed Variables\","]
#[doc = "      \"description\": \"The nodes in the DAG that the agent can passively measure.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct StructuralCausalGraphProfile {
    #[doc = "The declared topological mapping of causality."]
    pub causal_edges: ::std::vec::Vec<CausalDirectedEdgeState>,
    #[doc = "The unobserved confounders the agent suspects exist."]
    pub latent_variables: ::std::vec::Vec<LatentVariablesItem>,
    #[doc = "The nodes in the DAG that the agent can passively measure."]
    pub observed_variables: ::std::vec::Vec<ObservedVariablesItem>,
}
impl StructuralCausalGraphProfile {
    pub fn builder() -> builder::StructuralCausalGraphProfile {
        Default::default()
    }
}
#[doc = "The abstract Python type representation (e.g., 'List[str]')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Structural Type\","]
#[doc = "  \"description\": \"The abstract Python type representation (e.g., 'List[str]').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct StructuralType(::std::string::String);
impl ::std::ops::Deref for StructuralType {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<StructuralType> for ::std::string::String {
    fn from(value: StructuralType) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for StructuralType {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for StructuralType {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for StructuralType {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for StructuralType {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for StructuralType {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The origin SemanticNodeState Content Identifier (CID)."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Subject Node Cid\","]
#[doc = "  \"description\": \"The origin SemanticNodeState Content Identifier (CID).\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SubjectNodeCid(::std::string::String);
impl ::std::ops::Deref for SubjectNodeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SubjectNodeCid> for ::std::string::String {
    fn from(value: SubjectNodeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SubjectNodeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SubjectNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SubjectNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SubjectNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SubjectNodeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A kinetic trigger dictating the Just-In-Time (JIT) initialization of an external execution environment.\n\nCAUSAL AFFORDANCE: Forces the Compute Plane to physically download, verify, and mount the requested software library into active memory.\n\nEPISTEMIC BOUNDS: Cryptographic checksums strictly verify loaded wheels to prevent supply-chain poisoning during dynamic module imports.\n\nMCP ROUTING TRIGGERS: Environment Initialization, Supply-Chain Verification, Dynamic Import, JIT Mounting"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SubstrateHydrationManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A kinetic trigger dictating the Just-In-Time (JIT) initialization of an external execution environment.\\n\\nCAUSAL AFFORDANCE: Forces the Compute Plane to physically download, verify, and mount the requested software library into active memory.\\n\\nEPISTEMIC BOUNDS: Cryptographic checksums strictly verify loaded wheels to prevent supply-chain poisoning during dynamic module imports.\\n\\nMCP ROUTING TRIGGERS: Environment Initialization, Supply-Chain Verification, Dynamic Import, JIT Mounting\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"substrate_profile\","]
#[doc = "    \"target_node_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"cryptographic_checksums\": {"]
#[doc = "      \"title\": \"Cryptographic Checksums\","]
#[doc = "      \"description\": \"A map of package names to SHA-256 hashes verifying the loaded wheels.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 255"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"substrate_profile\": {"]
#[doc = "      \"description\": \"The exact blueprint geometry being loaded into VRAM.\","]
#[doc = "      \"$ref\": \"#/$defs/ExecutionSubstrateProfile\""]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"description\": \"The exact deterministic node demanding the physical hydration.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for substrate hydration.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"substrate_hydration\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SubstrateHydrationManifest {
    #[doc = "A map of package names to SHA-256 hashes verifying the loaded wheels."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub cryptographic_checksums: ::std::collections::HashMap<
        ::std::string::String,
        SubstrateHydrationManifestCryptographicChecksumsValue,
    >,
    #[doc = "The exact blueprint geometry being loaded into VRAM."]
    pub substrate_profile: ExecutionSubstrateProfile,
    #[doc = "The exact deterministic node demanding the physical hydration."]
    pub target_node_cid: NodeCidState,
    #[doc = "Discriminator type for substrate hydration."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl SubstrateHydrationManifest {
    pub fn builder() -> builder::SubstrateHydrationManifest {
        Default::default()
    }
}
#[doc = "`SubstrateHydrationManifestCryptographicChecksumsValue`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SubstrateHydrationManifestCryptographicChecksumsValue(::std::string::String);
impl ::std::ops::Deref for SubstrateHydrationManifestCryptographicChecksumsValue {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SubstrateHydrationManifestCryptographicChecksumsValue>
    for ::std::string::String
{
    fn from(value: SubstrateHydrationManifestCryptographicChecksumsValue) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SubstrateHydrationManifestCryptographicChecksumsValue {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SubstrateHydrationManifestCryptographicChecksumsValue {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String>
    for SubstrateHydrationManifestCryptographicChecksumsValue
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String>
    for SubstrateHydrationManifestCryptographicChecksumsValue
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SubstrateHydrationManifestCryptographicChecksumsValue {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`SuperpositionCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Superposition Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SuperpositionCid(::std::string::String);
impl ::std::ops::Deref for SuperpositionCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SuperpositionCid> for ::std::string::String {
    fn from(value: SuperpositionCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SuperpositionCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SuperpositionCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SuperpositionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SuperpositionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SuperpositionCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`SupportedFunctionalExpertsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SupportedFunctionalExpertsItem(::std::string::String);
impl ::std::ops::Deref for SupportedFunctionalExpertsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SupportedFunctionalExpertsItem> for ::std::string::String {
    fn from(value: SupportedFunctionalExpertsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SupportedFunctionalExpertsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SupportedFunctionalExpertsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SupportedFunctionalExpertsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SupportedFunctionalExpertsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SupportedFunctionalExpertsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative, frozen snapshot defining a Complex Adaptive System representing a fluid, decentralized Swarm topology governed by Algorithmic Mechanism Design and Spot Market dynamics.\n\nCAUSAL AFFORDANCE: Unlocks dynamic agent instantiation, allowing the topology to spawn concurrent workers up to `max_concurrent_agents` and resolve consensus probabilistically via `active_prediction_markets`.\n\nEPISTEMIC BOUNDS: Horizontal compute explosion is governed by `spawning_threshold` (`ge=1, le=100`) and `max_concurrent_agents` (`le=100`). The `@model_validator` guarantees spawning threshold cannot exceed max agents. Markets are deterministically sorted by `market_cid` for RFC 8785 hashing.\n\nMCP ROUTING TRIGGERS: Complex Adaptive Systems, Swarm Intelligence, Algorithmic Mechanism Design, Spot Market Routing, Multi-Agent Reinforcement Learning"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SwarmTopologyManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative, frozen snapshot defining a Complex Adaptive System representing a fluid, decentralized Swarm topology governed by Algorithmic Mechanism Design and Spot Market dynamics.\\n\\nCAUSAL AFFORDANCE: Unlocks dynamic agent instantiation, allowing the topology to spawn concurrent workers up to `max_concurrent_agents` and resolve consensus probabilistically via `active_prediction_markets`.\\n\\nEPISTEMIC BOUNDS: Horizontal compute explosion is governed by `spawning_threshold` (`ge=1, le=100`) and `max_concurrent_agents` (`le=100`). The `@model_validator` guarantees spawning threshold cannot exceed max agents. Markets are deterministically sorted by `market_cid` for RFC 8785 hashing.\\n\\nMCP ROUTING TRIGGERS: Complex Adaptive Systems, Swarm Intelligence, Algorithmic Mechanism Design, Spot Market Routing, Multi-Agent Reinforcement Learning\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"nodes\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"active_prediction_markets\": {"]
#[doc = "      \"title\": \"Active Prediction Markets\","]
#[doc = "      \"description\": \"The live algorithmic betting markets resolving swarm consensus.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/PredictionMarketState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"architectural_intent\": {"]
#[doc = "      \"title\": \"Architectural Intent\","]
#[doc = "      \"description\": \"The AI's declarative rationale for selecting this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"auction_policy\": {"]
#[doc = "      \"description\": \"The mathematical policy governing task decentralization via Spot Markets.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/AuctionPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"epistemic_enforcement\": {"]
#[doc = "      \"description\": \"Ties the topology to the Truth Maintenance layer.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/TruthMaintenancePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"justification\": {"]
#[doc = "      \"title\": \"Justification\","]
#[doc = "      \"description\": \"Cryptographic/audit justification for this topology's configuration.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"lifecycle_phase\": {"]
#[doc = "      \"title\": \"Lifecycle Phase\","]
#[doc = "      \"description\": \"The execution phase of the graph. 'draft' allows incomplete structural state.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"draft\","]
#[doc = "        \"live\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"max_concurrent_agents\": {"]
#[doc = "      \"title\": \"Max Concurrent Agents\","]
#[doc = "      \"description\": \"The mathematically bounded limit for concurrent agent threads.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 100.0"]
#[doc = "    },"]
#[doc = "    \"nodes\": {"]
#[doc = "      \"title\": \"Nodes\","]
#[doc = "      \"description\": \"Flat registry of all nodes in this topology.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/AnyNodeProfile\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"observability\": {"]
#[doc = "      \"description\": \"The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ObservabilityLODPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"resolved_markets\": {"]
#[doc = "      \"title\": \"Resolved Markets\","]
#[doc = "      \"description\": \"The immutable records of finalized markets and reputation capital distributions.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/MarketResolutionState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"semantic_flow\": {"]
#[doc = "      \"description\": \"The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticFlowPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"shared_state_contract\": {"]
#[doc = "      \"description\": \"The schema-on-write contract governing the internal state of this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/StateContract\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"spawning_threshold\": {"]
#[doc = "      \"title\": \"Spawning Threshold\","]
#[doc = "      \"description\": \"Threshold limit for dynamic spawning of additional nodes.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 100.0,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for a Swarm topology.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"swarm\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SwarmTopologyManifest {
    #[doc = "The live algorithmic betting markets resolving swarm consensus."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub active_prediction_markets: ::std::vec::Vec<PredictionMarketState>,
    #[doc = "The AI's declarative rationale for selecting this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub architectural_intent: ::std::option::Option<::std::string::String>,
    #[doc = "The mathematical policy governing task decentralization via Spot Markets."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub auction_policy: ::std::option::Option<AuctionPolicy>,
    #[doc = "Ties the topology to the Truth Maintenance layer."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_enforcement: ::std::option::Option<TruthMaintenancePolicy>,
    #[doc = "Cryptographic/audit justification for this topology's configuration."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub justification: ::std::option::Option<::std::string::String>,
    #[doc = "The execution phase of the graph. 'draft' allows incomplete structural state."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub lifecycle_phase: ::std::option::Option<LifecyclePhase>,
    #[doc = "The mathematically bounded limit for concurrent agent threads."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_concurrent_agents: ::std::option::Option<i64>,
    #[doc = "Flat registry of all nodes in this topology."]
    pub nodes: ::std::collections::HashMap<::std::string::String, AnyNodeProfile>,
    #[doc = "The dynamic Level of Detail and Spectral Coarsening physics bound to this macroscopic execution graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub observability: ::std::option::Option<ObservabilityLodPolicy>,
    #[doc = "The immutable records of finalized markets and reputation capital distributions."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub resolved_markets: ::std::vec::Vec<MarketResolutionState>,
    #[doc = "The structural Payload Loss Prevention (PLP) contract governing all state mutations in this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub semantic_flow: ::std::option::Option<SemanticFlowPolicy>,
    #[doc = "The schema-on-write contract governing the internal state of this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub shared_state_contract: ::std::option::Option<StateContract>,
    #[doc = "Threshold limit for dynamic spawning of additional nodes."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub spawning_threshold: ::std::option::Option<::std::num::NonZeroU64>,
    #[doc = "Discriminator for a Swarm topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl SwarmTopologyManifest {
    pub fn builder() -> builder::SwarmTopologyManifest {
        Default::default()
    }
}
#[doc = "`SyntacticRootsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SyntacticRootsItem(::std::string::String);
impl ::std::ops::Deref for SyntacticRootsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SyntacticRootsItem> for ::std::string::String {
    fn from(value: SyntacticRootsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SyntacticRootsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SyntacticRootsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SyntacticRootsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SyntacticRootsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SyntacticRootsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines a formal blueprint for Model-Based Fuzzing and\nGenerative Adversarial Testing against the Universal Unified Ontology. As a\n...Profile suffix, this is a declarative, frozen snapshot of an evaluation\ngeometry.\n\nCAUSAL AFFORDANCE: Instructs exogenous fuzzing engines to synthesize\npermutations of the target_schema_ref (min_length=1), actively injecting\nstructural entropy into the system while strictly adhering to the bounding\nmanifold_sla (GenerativeManifoldSLA).\n\nEPISTEMIC BOUNDS: The profile identity is cryptographically anchored to the\nprofile_cid (128-char CID regex ^[a-zA-Z0-9_.:-]+$). The simulation scope is\nphysically restricted by the underlying manifold_sla.\n\nMCP ROUTING TRIGGERS: Model-Based Fuzzing, Generative Adversarial Testing,\nStructural Entropy, Fuzzing Blueprint, Synthetic Permutation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SyntheticGenerationProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines a formal blueprint for Model-Based Fuzzing and\\nGenerative Adversarial Testing against the Universal Unified Ontology. As a\\n...Profile suffix, this is a declarative, frozen snapshot of an evaluation\\ngeometry.\\n\\nCAUSAL AFFORDANCE: Instructs exogenous fuzzing engines to synthesize\\npermutations of the target_schema_ref (min_length=1), actively injecting\\nstructural entropy into the system while strictly adhering to the bounding\\nmanifold_sla (GenerativeManifoldSLA).\\n\\nEPISTEMIC BOUNDS: The profile identity is cryptographically anchored to the\\nprofile_cid (128-char CID regex ^[a-zA-Z0-9_.:-]+$). The simulation scope is\\nphysically restricted by the underlying manifold_sla.\\n\\nMCP ROUTING TRIGGERS: Model-Based Fuzzing, Generative Adversarial Testing,\\nStructural Entropy, Fuzzing Blueprint, Synthetic Permutation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"manifold_sla\","]
#[doc = "    \"profile_cid\","]
#[doc = "    \"target_schema_ref\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"manifold_sla\": {"]
#[doc = "      \"description\": \"The structural topological gas limit.\","]
#[doc = "      \"$ref\": \"#/$defs/GenerativeManifoldSLA\""]
#[doc = "    },"]
#[doc = "    \"profile_cid\": {"]
#[doc = "      \"title\": \"Profile Cid\","]
#[doc = "      \"description\": \"Unique identifier for this simulation profile.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_schema_ref\": {"]
#[doc = "      \"title\": \"Target Schema Ref\","]
#[doc = "      \"description\": \"The string name of the Pydantic class to synthesize.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2048,"]
#[doc = "      \"minLength\": 1"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SyntheticGenerationProfile {
    #[doc = "The structural topological gas limit."]
    pub manifold_sla: GenerativeManifoldSla,
    #[doc = "Unique identifier for this simulation profile."]
    pub profile_cid: ProfileCid,
    #[doc = "The string name of the Pydantic class to synthesize."]
    pub target_schema_ref: TargetSchemaRef,
}
impl SyntheticGenerationProfile {
    pub fn builder() -> builder::SyntheticGenerationProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Kahneman's Dual-Process Theory (System 1) to execute\nrapid, heuristic-based reflex actions without invoking deep logical search trees. As a\n...Policy suffix, this enforces a rigid computational boundary.\n\nCAUSAL AFFORDANCE: Unlocks zero-shot execution of side-effect-free capabilities when\nthe working context matches established high-probability priors, intentionally bypassing\nexpensive System 2 Monte Carlo Tree Search (MCTS).\n\nEPISTEMIC BOUNDS: Execution is mathematically gated by the confidence_threshold\n(ge=0.0, le=1.0). The allowed_passive_tools array (max_length=1000,\nStringConstraints max_length=2000) strictly bounds the agent to non-mutating\ncapabilities, deterministically sorted via @model_validator.\n\nMCP ROUTING TRIGGERS: Dual-Process Theory, System 1 Heuristics, Zero-Shot Reflex,\nMetacognition, Amygdala Hijack Prevention"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"System1ReflexPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Kahneman's Dual-Process Theory (System 1) to execute\\nrapid, heuristic-based reflex actions without invoking deep logical search trees. As a\\n...Policy suffix, this enforces a rigid computational boundary.\\n\\nCAUSAL AFFORDANCE: Unlocks zero-shot execution of side-effect-free capabilities when\\nthe working context matches established high-probability priors, intentionally bypassing\\nexpensive System 2 Monte Carlo Tree Search (MCTS).\\n\\nEPISTEMIC BOUNDS: Execution is mathematically gated by the confidence_threshold\\n(ge=0.0, le=1.0). The allowed_passive_tools array (max_length=1000,\\nStringConstraints max_length=2000) strictly bounds the agent to non-mutating\\ncapabilities, deterministically sorted via @model_validator.\\n\\nMCP ROUTING TRIGGERS: Dual-Process Theory, System 1 Heuristics, Zero-Shot Reflex,\\nMetacognition, Amygdala Hijack Prevention\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"allowed_passive_tools\","]
#[doc = "    \"confidence_threshold\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"allowed_passive_tools\": {"]
#[doc = "      \"title\": \"Allowed Passive Tools\","]
#[doc = "      \"description\": \"The explicit, bounded array of strictly non-mutating tool capabilities.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000"]
#[doc = "    },"]
#[doc = "    \"confidence_threshold\": {"]
#[doc = "      \"title\": \"Confidence Threshold\","]
#[doc = "      \"description\": \"The confidence threshold required to execute a reflex action.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct System1ReflexPolicy {
    #[doc = "The explicit, bounded array of strictly non-mutating tool capabilities."]
    pub allowed_passive_tools: ::std::vec::Vec<AllowedPassiveToolsItem>,
    #[doc = "The confidence threshold required to execute a reflex action."]
    pub confidence_threshold: f64,
}
impl System1ReflexPolicy {
    pub fn builder() -> builder::System1ReflexPolicy {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Kahneman's Dual-Process Theory by explicitly triggering a System 2 non-monotonic self-correction loop in response to a structural execution collapse. As an ...Intent suffix, this represents an authorized kinetic execution trigger.\n\nCAUSAL AFFORDANCE: Intercepts physical instantiation failures (e.g., Pydantic ValidationErrors) and redirects the generation trajectory, forcing the agent into a recursive backtracking search to rewrite the isolated subgraph via `violation_receipts`.\n\nEPISTEMIC BOUNDS: The `fault_cid` is cryptographically tied to a 128-char CID. The `violation_receipts` array is deterministically sorted by the `_enforce_canonical_sort_receipts` hook to preserve RFC 8785 canonical hashing and map exact JSON paths without ambiguity.\n\nMCP ROUTING TRIGGERS: Dual-Process Theory, Non-Monotonic Revision, System 2 Remediation, Backtracking Search, Abstract Syntax Tree"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"System2RemediationIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Kahneman's Dual-Process Theory by explicitly triggering a System 2 non-monotonic self-correction loop in response to a structural execution collapse. As an ...Intent suffix, this represents an authorized kinetic execution trigger.\\n\\nCAUSAL AFFORDANCE: Intercepts physical instantiation failures (e.g., Pydantic ValidationErrors) and redirects the generation trajectory, forcing the agent into a recursive backtracking search to rewrite the isolated subgraph via `violation_receipts`.\\n\\nEPISTEMIC BOUNDS: The `fault_cid` is cryptographically tied to a 128-char CID. The `violation_receipts` array is deterministically sorted by the `_enforce_canonical_sort_receipts` hook to preserve RFC 8785 canonical hashing and map exact JSON paths without ambiguity.\\n\\nMCP ROUTING TRIGGERS: Dual-Process Theory, Non-Monotonic Revision, System 2 Remediation, Backtracking Search, Abstract Syntax Tree\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"fault_cid\","]
#[doc = "    \"target_node_cid\","]
#[doc = "    \"violation_receipts\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"ast_gradient\": {"]
#[doc = "      \"description\": \"The structural loss vector guiding AST repair.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ASTGradientReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"fault_cid\": {"]
#[doc = "      \"title\": \"Fault Cid\","]
#[doc = "      \"description\": \"A cryptographic Lineage Watermark (CID) tracking this specific dimensional collapse.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring the agent that authored the invalid state, ensuring the fault is routed back to the exact state partition.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for System2RemediationIntent.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"system_2_remediation\""]
#[doc = "    },"]
#[doc = "    \"violation_receipts\": {"]
#[doc = "      \"title\": \"Violation Receipts\","]
#[doc = "      \"description\": \"The deterministic array of exact structural faults the agent must correct.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/ManifestViolationReceipt\""]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct System2RemediationIntent {
    #[doc = "The structural loss vector guiding AST repair."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub ast_gradient: ::std::option::Option<AstGradientReceipt>,
    #[doc = "A cryptographic Lineage Watermark (CID) tracking this specific dimensional collapse."]
    pub fault_cid: FaultCid,
    #[doc = "The globally unique decentralized identifier (DID) anchoring the agent that authored the invalid state, ensuring the fault is routed back to the exact state partition."]
    pub target_node_cid: NodeCidState,
    #[doc = "Discriminator type for System2RemediationIntent."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The deterministic array of exact structural faults the agent must correct."]
    pub violation_receipts: ::std::vec::Vec<ManifestViolationReceipt>,
}
impl System2RemediationIntent {
    pub fn builder() -> builder::System2RemediationIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Acts as a structural terminal state mapping a Byzantine Fault or catastrophic topological execution collapse within the distributed system.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator's circuit breakers to completely sever the active execution branch and quarantine the associated probability wave, preventing failure contagion.\n\nEPISTEMIC BOUNDS: Inherits strict temporal and spatial bounds from CoreasonBaseState. Its semantic geometry is permanently constrained to the strict Literal automaton `[\"system_fault\"]`.\n\nMCP ROUTING TRIGGERS: Byzantine Fault Tolerance, Circuit Breaker, Terminal State, Execution Collapse, Fault Isolation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"SystemFaultEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Acts as a structural terminal state mapping a Byzantine Fault or catastrophic topological execution collapse within the distributed system.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator's circuit breakers to completely sever the active execution branch and quarantine the associated probability wave, preventing failure contagion.\\n\\nEPISTEMIC BOUNDS: Inherits strict temporal and spatial bounds from CoreasonBaseState. Its semantic geometry is permanently constrained to the strict Literal automaton `[\\\"system_fault\\\"]`.\\n\\nMCP ROUTING TRIGGERS: Byzantine Fault Tolerance, Circuit Breaker, Terminal State, Execution Collapse, Fault Isolation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"event_cid\","]
#[doc = "    \"timestamp\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for a system fault event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"system_fault\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SystemFaultEvent {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "Discriminator type for a system fault event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl SystemFaultEvent {
    pub fn builder() -> builder::SystemFaultEvent {
        Default::default()
    }
}
#[doc = "The basal non-monotonic instruction set currently held in Epistemic Quarantine."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"System Prompt\","]
#[doc = "  \"description\": \"The basal non-monotonic instruction set currently held in Epistemic Quarantine.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct SystemPrompt(::std::string::String);
impl ::std::ops::Deref for SystemPrompt {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<SystemPrompt> for ::std::string::String {
    fn from(value: SystemPrompt) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for SystemPrompt {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for SystemPrompt {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for SystemPrompt {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for SystemPrompt {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for SystemPrompt {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative, discrete spatial vertex mapping an exact cell coordinate within a 2D relational matrix.\n\nCAUSAL AFFORDANCE: Instructs the Table Structure Recognition engine to project extracted strings into precise Cartesian coordinates, preventing semantic flattening.\n\nEPISTEMIC BOUNDS: Spatial geometry is clamped by non-negative `row_index` and `column_index` (`ge=0`). Span integers are strictly positive (`ge=1`). The payload is clamped at `max_length=10000` to prevent dictionary bombing.\n\nMCP ROUTING TRIGGERS: Tabular Matrix Geometry, Table Structure Recognition, Bipartite Graph, Cartesian Coordinate, Spatial Grid"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TabularCellState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative, discrete spatial vertex mapping an exact cell coordinate within a 2D relational matrix.\\n\\nCAUSAL AFFORDANCE: Instructs the Table Structure Recognition engine to project extracted strings into precise Cartesian coordinates, preventing semantic flattening.\\n\\nEPISTEMIC BOUNDS: Spatial geometry is clamped by non-negative `row_index` and `column_index` (`ge=0`). Span integers are strictly positive (`ge=1`). The payload is clamped at `max_length=10000` to prevent dictionary bombing.\\n\\nMCP ROUTING TRIGGERS: Tabular Matrix Geometry, Table Structure Recognition, Bipartite Graph, Cartesian Coordinate, Spatial Grid\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"cell_cid\","]
#[doc = "    \"column_index\","]
#[doc = "    \"row_index\","]
#[doc = "    \"text_payload\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"cell_cid\": {"]
#[doc = "      \"title\": \"Cell Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"column_index\": {"]
#[doc = "      \"title\": \"Column Index\","]
#[doc = "      \"description\": \"The primary Cartesian X-coordinate of the cell.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"column_span\": {"]
#[doc = "      \"title\": \"Column Span\","]
#[doc = "      \"description\": \"The horizontal geometric span of the cell.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"row_index\": {"]
#[doc = "      \"title\": \"Row Index\","]
#[doc = "      \"description\": \"The primary Cartesian Y-coordinate of the cell.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"row_span\": {"]
#[doc = "      \"title\": \"Row Span\","]
#[doc = "      \"description\": \"The vertical geometric span of the cell.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"text_payload\": {"]
#[doc = "      \"title\": \"Text Payload\","]
#[doc = "      \"description\": \"The extracted atomic data point within the cell.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 10000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TabularCellState {
    pub cell_cid: CellCid,
    #[doc = "The primary Cartesian X-coordinate of the cell."]
    pub column_index: u64,
    #[doc = "The horizontal geometric span of the cell."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub column_span: ::std::option::Option<::std::num::NonZeroU64>,
    #[doc = "The primary Cartesian Y-coordinate of the cell."]
    pub row_index: u64,
    #[doc = "The vertical geometric span of the cell."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub row_span: ::std::option::Option<::std::num::NonZeroU64>,
    #[doc = "The extracted atomic data point within the cell."]
    pub text_payload: TextPayload,
}
impl TabularCellState {
    pub fn builder() -> builder::TabularCellState {
        Default::default()
    }
}
#[doc = "AGENT INSTRUCTION: Dictates the exact algorithmic mechanism the orchestrator must use to compress an untyped payload_injection_zone into a holistic high-dimensional VectorEmbeddingState, capturing multivariate covariance."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TabularEncodingProfile\","]
#[doc = "  \"description\": \"AGENT INSTRUCTION: Dictates the exact algorithmic mechanism the orchestrator must use to compress an untyped payload_injection_zone into a holistic high-dimensional VectorEmbeddingState, capturing multivariate covariance.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"feature_wise_attention\","]
#[doc = "    \"hyperdimensional_hopfield\","]
#[doc = "    \"graph_convolutional_flattening\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TabularEncodingProfile {
    #[serde(rename = "feature_wise_attention")]
    FeatureWiseAttention,
    #[serde(rename = "hyperdimensional_hopfield")]
    HyperdimensionalHopfield,
    #[serde(rename = "graph_convolutional_flattening")]
    GraphConvolutionalFlattening,
}
impl ::std::fmt::Display for TabularEncodingProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::FeatureWiseAttention => f.write_str("feature_wise_attention"),
            Self::HyperdimensionalHopfield => f.write_str("hyperdimensional_hopfield"),
            Self::GraphConvolutionalFlattening => f.write_str("graph_convolutional_flattening"),
        }
    }
}
impl ::std::str::FromStr for TabularEncodingProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "feature_wise_attention" => Ok(Self::FeatureWiseAttention),
            "hyperdimensional_hopfield" => Ok(Self::HyperdimensionalHopfield),
            "graph_convolutional_flattening" => Ok(Self::GraphConvolutionalFlattening),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TabularEncodingProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TabularEncodingProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TabularEncodingProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative envelope defining a localized 2D bipartite tabular graph.\n\nCAUSAL AFFORDANCE: Isolates dense relational data grids from standard 1D text extraction, permitting downstream agents to execute spatial querying.\n\nEPISTEMIC BOUNDS: Total dimensions bounded `ge=1`. The `validate_matrix_physics` `@model_validator` mathematically guarantees no cell violates Euclidean space by exceeding `total_rows` or `total_columns`.\n\nMCP ROUTING TRIGGERS: TableFormer, Relational Matrix, Grid Topology, Spatial Bounding, 2D Array"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TabularMatrixProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative envelope defining a localized 2D bipartite tabular graph.\\n\\nCAUSAL AFFORDANCE: Isolates dense relational data grids from standard 1D text extraction, permitting downstream agents to execute spatial querying.\\n\\nEPISTEMIC BOUNDS: Total dimensions bounded `ge=1`. The `validate_matrix_physics` `@model_validator` mathematically guarantees no cell violates Euclidean space by exceeding `total_rows` or `total_columns`.\\n\\nMCP ROUTING TRIGGERS: TableFormer, Relational Matrix, Grid Topology, Spatial Bounding, 2D Array\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"cells\","]
#[doc = "    \"matrix_cid\","]
#[doc = "    \"total_columns\","]
#[doc = "    \"total_rows\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"cells\": {"]
#[doc = "      \"title\": \"Cells\","]
#[doc = "      \"description\": \"The complete, sorted array of constituent cell geometries.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/TabularCellState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"matrix_cid\": {"]
#[doc = "      \"title\": \"Matrix Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"total_columns\": {"]
#[doc = "      \"title\": \"Total Columns\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"total_rows\": {"]
#[doc = "      \"title\": \"Total Rows\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TabularMatrixProfile {
    #[doc = "The complete, sorted array of constituent cell geometries."]
    pub cells: ::std::vec::Vec<TabularCellState>,
    pub matrix_cid: MatrixCid,
    pub total_columns: ::std::num::NonZeroU64,
    pub total_rows: ::std::num::NonZeroU64,
}
impl TabularMatrixProfile {
    pub fn builder() -> builder::TabularMatrixProfile {
        Default::default()
    }
}
#[doc = "The overarching cryptographic hash (e.g., Merkle Root) proving the structural payload has not been laundered or structurally modified."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Tamper Evident Root\","]
#[doc = "  \"description\": \"The overarching cryptographic hash (e.g., Merkle Root) proving the structural payload has not been laundered or structurally modified.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TamperEvidentRoot(::std::string::String);
impl ::std::ops::Deref for TamperEvidentRoot {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TamperEvidentRoot> for ::std::string::String {
    fn from(value: TamperEvidentRoot) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TamperEvidentRoot {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TamperEvidentRoot {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TamperEvidentRoot {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TamperEvidentRoot {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TamperEvidentRoot {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the agent whose mind is being modeled."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Agent Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the agent whose mind is being modeled.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetAgentCid(::std::string::String);
impl ::std::ops::Deref for TargetAgentCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetAgentCid> for ::std::string::String {
    fn from(value: TargetAgentCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetAgentCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetAgentCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetAgentCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetAgentCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetAgentCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The CID pointing to the TerminalBufferState or raw intercepted byte stream."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Buffer Cid\","]
#[doc = "  \"description\": \"The CID pointing to the TerminalBufferState or raw intercepted byte stream.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetBufferCid(::std::string::String);
impl ::std::ops::Deref for TargetBufferCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetBufferCid> for ::std::string::String {
    fn from(value: TargetBufferCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetBufferCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetBufferCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetBufferCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetBufferCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetBufferCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the claim being attacked."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Claim Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the claim being attacked.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetClaimCid(::std::string::String);
impl ::std::ops::Deref for TargetClaimCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetClaimCid> for ::std::string::String {
    fn from(value: TargetClaimCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetClaimCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetClaimCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetClaimCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetClaimCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetClaimCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The destination tier where the compressed rule will be stored."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Cognitive Tier\","]
#[doc = "  \"description\": \"The destination tier where the compressed rule will be stored.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"semantic\","]
#[doc = "    \"working\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TargetCognitiveTier {
    #[serde(rename = "semantic")]
    Semantic,
    #[serde(rename = "working")]
    Working,
}
impl ::std::fmt::Display for TargetCognitiveTier {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Semantic => f.write_str("semantic"),
            Self::Working => f.write_str("working"),
        }
    }
}
impl ::std::str::FromStr for TargetCognitiveTier {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "semantic" => Ok(Self::Semantic),
            "working" => Ok(Self::Working),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TargetCognitiveTier {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetCognitiveTier {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetCognitiveTier {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The globally unique decentralized identifier (DID) anchoring destination node."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Concept Cid\","]
#[doc = "  \"description\": \"The globally unique decentralized identifier (DID) anchoring destination node.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetConceptCid(::std::string::String);
impl ::std::ops::Deref for TargetConceptCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetConceptCid> for ::std::string::String {
    fn from(value: TargetConceptCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetConceptCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetConceptCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetConceptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetConceptCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetConceptCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The specific FalsificationContract being tested."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Condition Cid\","]
#[doc = "  \"description\": \"The specific FalsificationContract being tested.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetConditionCid(::std::string::String);
impl ::std::ops::Deref for TargetConditionCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetConditionCid> for ::std::string::String {
    fn from(value: TargetConditionCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetConditionCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetConditionCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetConditionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetConditionCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetConditionCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The actual problem space currently being solved."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Domain\","]
#[doc = "  \"description\": \"The actual problem space currently being solved.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetDomain(::std::string::String);
impl ::std::ops::Deref for TargetDomain {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetDomain> for ::std::string::String {
    fn from(value: TargetDomain) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetDomain {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetDomain {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetDomain {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetDomain {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetDomain {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the active node generation cycle that was killed in the Merkle-DAG."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Event Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the active node generation cycle that was killed in the Merkle-DAG.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetEventCid(::std::string::String);
impl ::std::ops::Deref for TargetEventCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetEventCid> for ::std::string::String {
    fn from(value: TargetEventCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetEventCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetEventCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetEventCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`TargetFormat`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Format\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"turtle\","]
#[doc = "    \"xml\","]
#[doc = "    \"json-ld\","]
#[doc = "    \"ntriples\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TargetFormat {
    #[serde(rename = "turtle")]
    Turtle,
    #[serde(rename = "xml")]
    Xml,
    #[serde(rename = "json-ld")]
    JsonLd,
    #[serde(rename = "ntriples")]
    Ntriples,
}
impl ::std::fmt::Display for TargetFormat {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Turtle => f.write_str("turtle"),
            Self::Xml => f.write_str("xml"),
            Self::JsonLd => f.write_str("json-ld"),
            Self::Ntriples => f.write_str("ntriples"),
        }
    }
}
impl ::std::str::FromStr for TargetFormat {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "turtle" => Ok(Self::Turtle),
            "xml" => Ok(Self::Xml),
            "json-ld" => Ok(Self::JsonLd),
            "ntriples" => Ok(Self::Ntriples),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TargetFormat {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetFormat {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetFormat {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`TargetGraphCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Graph Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetGraphCid(::std::string::String);
impl ::std::ops::Deref for TargetGraphCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetGraphCid> for ::std::string::String {
    fn from(value: TargetGraphCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetGraphCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetGraphCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetGraphCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetGraphCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetGraphCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`TargetHookPointsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 256,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetHookPointsItem(::std::string::String);
impl ::std::ops::Deref for TargetHookPointsItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetHookPointsItem> for ::std::string::String {
    fn from(value: TargetHookPointsItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetHookPointsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 256usize {
            return Err("longer than 256 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetHookPointsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetHookPointsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetHookPointsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetHookPointsItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The HypothesisGenerationEvent this task is attempting to falsify."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Hypothesis Cid\","]
#[doc = "  \"description\": \"The HypothesisGenerationEvent this task is attempting to falsify.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetHypothesisCid(::std::string::String);
impl ::std::ops::Deref for TargetHypothesisCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetHypothesisCid> for ::std::string::String {
    fn from(value: TargetHypothesisCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetHypothesisCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetHypothesisCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetHypothesisCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetHypothesisCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetHypothesisCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The specific telemetry or execution metric to evaluate (e.g., 'latency', 'accuracy')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Metric\","]
#[doc = "  \"description\": \"The specific telemetry or execution metric to evaluate (e.g., 'latency', 'accuracy').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetMetric(::std::string::String);
impl ::std::ops::Deref for TargetMetric {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetMetric> for ::std::string::String {
    fn from(value: TargetMetric) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetMetric {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetMetric {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetMetric {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetMetric {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetMetric {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`TargetModalitiesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"text\","]
#[doc = "    \"raster_image\","]
#[doc = "    \"vector_graphics\","]
#[doc = "    \"tabular_grid\","]
#[doc = "    \"n_dimensional_tensor\","]
#[doc = "    \"semantic_graph\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TargetModalitiesItem {
    #[serde(rename = "text")]
    Text,
    #[serde(rename = "raster_image")]
    RasterImage,
    #[serde(rename = "vector_graphics")]
    VectorGraphics,
    #[serde(rename = "tabular_grid")]
    TabularGrid,
    #[serde(rename = "n_dimensional_tensor")]
    NDimensionalTensor,
    #[serde(rename = "semantic_graph")]
    SemanticGraph,
}
impl ::std::fmt::Display for TargetModalitiesItem {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Text => f.write_str("text"),
            Self::RasterImage => f.write_str("raster_image"),
            Self::VectorGraphics => f.write_str("vector_graphics"),
            Self::TabularGrid => f.write_str("tabular_grid"),
            Self::NDimensionalTensor => f.write_str("n_dimensional_tensor"),
            Self::SemanticGraph => f.write_str("semantic_graph"),
        }
    }
}
impl ::std::str::FromStr for TargetModalitiesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "text" => Ok(Self::Text),
            "raster_image" => Ok(Self::RasterImage),
            "vector_graphics" => Ok(Self::VectorGraphics),
            "tabular_grid" => Ok(Self::TabularGrid),
            "n_dimensional_tensor" => Ok(Self::NDimensionalTensor),
            "semantic_graph" => Ok(Self::SemanticGraph),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TargetModalitiesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetModalitiesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetModalitiesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`TargetModulesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetModulesItem(::std::string::String);
impl ::std::ops::Deref for TargetModulesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetModulesItem> for ::std::string::String {
    fn from(value: TargetModulesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetModulesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetModulesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetModulesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetModulesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetModulesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The standardized semantic ontology namespace the data was projected into."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Namespace\","]
#[doc = "  \"description\": \"The standardized semantic ontology namespace the data was projected into.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetNamespace(::std::string::String);
impl ::std::ops::Deref for TargetNamespace {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetNamespace> for ::std::string::String {
    fn from(value: TargetNamespace) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetNamespace {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetNamespace {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetNamespace {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetNamespace {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetNamespace {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The specific TaxonomicNodeState CID that was manipulated."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Node Cid\","]
#[doc = "  \"description\": \"The specific TaxonomicNodeState CID that was manipulated.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetNodeCid(::std::string::String);
impl ::std::ops::Deref for TargetNodeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetNodeCid> for ::std::string::String {
    fn from(value: TargetNodeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetNodeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetNodeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Regex-bound SHA-256 string targeting a specific Merkle root in the epistemic graph."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Node Hash\","]
#[doc = "  \"description\": \"Regex-bound SHA-256 string targeting a specific Merkle root in the epistemic graph.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetNodeHash(::std::string::String);
impl ::std::ops::Deref for TargetNodeHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetNodeHash> for ::std::string::String {
    fn from(value: TargetNodeHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetNodeHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetNodeHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetNodeHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetNodeHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetNodeHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The explicitly declared target node classification or structural grain."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Ontological Granularity\","]
#[doc = "  \"description\": \"The explicitly declared target node classification or structural grain.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetOntologicalGranularity(::std::string::String);
impl ::std::ops::Deref for TargetOntologicalGranularity {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetOntologicalGranularity> for ::std::string::String {
    fn from(value: TargetOntologicalGranularity) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetOntologicalGranularity {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetOntologicalGranularity {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetOntologicalGranularity {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetOntologicalGranularity {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetOntologicalGranularity {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A pointer to the specific standard vocabulary subgraph (e.g., an OMOP schema graph)."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Ontology Graph Cid\","]
#[doc = "  \"description\": \"A pointer to the specific standard vocabulary subgraph (e.g., an OMOP schema graph).\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetOntologyGraphCid(::std::string::String);
impl ::std::ops::Deref for TargetOntologyGraphCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetOntologyGraphCid> for ::std::string::String {
    fn from(value: TargetOntologyGraphCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetOntologyGraphCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetOntologyGraphCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetOntologyGraphCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetOntologyGraphCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetOntologyGraphCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The destination namespace (e.g., SNOMED-CT, CFR)."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Ontology Namespace\","]
#[doc = "  \"description\": \"The destination namespace (e.g., SNOMED-CT, CFR).\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetOntologyNamespace(::std::string::String);
impl ::std::ops::Deref for TargetOntologyNamespace {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetOntologyNamespace> for ::std::string::String {
    fn from(value: TargetOntologyNamespace) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetOntologyNamespace {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetOntologyNamespace {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetOntologyNamespace {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetOntologyNamespace {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetOntologyNamespace {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`TargetOntologyRegistriesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetOntologyRegistriesItem(::std::string::String);
impl ::std::ops::Deref for TargetOntologyRegistriesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetOntologyRegistriesItem> for ::std::string::String {
    fn from(value: TargetOntologyRegistriesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetOntologyRegistriesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetOntologyRegistriesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetOntologyRegistriesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetOntologyRegistriesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetOntologyRegistriesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The formal URN declaring the target ontological geometry for structural isomorphism."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Ontology Urn\","]
#[doc = "  \"description\": \"The formal URN declaring the target ontological geometry for structural isomorphism.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000,"]
#[doc = "  \"pattern\": \"^urn:coreason:ontology:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetOntologyUrn(::std::string::String);
impl ::std::ops::Deref for TargetOntologyUrn {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetOntologyUrn> for ::std::string::String {
    fn from(value: TargetOntologyUrn) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetOntologyUrn {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| {
                ::regress::Regex::new("^urn:coreason:ontology:.*$").unwrap()
            });
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^urn:coreason:ontology:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetOntologyUrn {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetOntologyUrn {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetOntologyUrn {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetOntologyUrn {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The globally unique decentralized identifier (DID) anchoring the collective outcome being explained."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Outcome Event Cid\","]
#[doc = "  \"description\": \"The globally unique decentralized identifier (DID) anchoring the collective outcome being explained.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetOutcomeEventCid(::std::string::String);
impl ::std::ops::Deref for TargetOutcomeEventCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetOutcomeEventCid> for ::std::string::String {
    fn from(value: TargetOutcomeEventCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetOutcomeEventCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetOutcomeEventCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetOutcomeEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetOutcomeEventCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetOutcomeEventCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The RFC 6902 JSON Pointer injecting into the Contravariant input."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Pointer\","]
#[doc = "  \"description\": \"The RFC 6902 JSON Pointer injecting into the Contravariant input.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetPointer(::std::string::String);
impl ::std::ops::Deref for TargetPointer {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetPointer> for ::std::string::String {
    fn from(value: TargetPointer) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetPointer {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetPointer {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetPointer {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetPointer {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetPointer {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The specific localized node schema key undergoing rigorous mathematical bounding."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Property\","]
#[doc = "  \"description\": \"The specific localized node schema key undergoing rigorous mathematical bounding.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetProperty(::std::string::String);
impl ::std::ops::Deref for TargetProperty {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetProperty> for ::std::string::String {
    fn from(value: TargetProperty) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetProperty {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetProperty {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetProperty {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetProperty {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetProperty {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The string name of the Pydantic class to synthesize."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Schema Ref\","]
#[doc = "  \"description\": \"The string name of the Pydantic class to synthesize.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2048,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetSchemaRef(::std::string::String);
impl ::std::ops::Deref for TargetSchemaRef {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetSchemaRef> for ::std::string::String {
    fn from(value: TargetSchemaRef) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetSchemaRef {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2048usize {
            return Err("longer than 2048 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetSchemaRef {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetSchemaRef {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetSchemaRef {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetSchemaRef {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The fully qualified URN of the heuristic solver capability to which the deficit is being escalated."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Solver Urn\","]
#[doc = "  \"description\": \"The fully qualified URN of the heuristic solver capability to which the deficit is being escalated.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^urn:coreason:solver:.*$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetSolverUrn(::std::string::String);
impl ::std::ops::Deref for TargetSolverUrn {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetSolverUrn> for ::std::string::String {
    fn from(value: TargetSolverUrn) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetSolverUrn {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| {
                ::regress::Regex::new("^urn:coreason:solver:.*$").unwrap()
            });
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^urn:coreason:solver:.*$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetSolverUrn {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetSolverUrn {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetSolverUrn {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetSolverUrn {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The Content Identifier (CID) of the heavy EpistemicSOPManifest resting in cold storage."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Sop Cid\","]
#[doc = "  \"description\": \"The Content Identifier (CID) of the heavy EpistemicSOPManifest resting in cold storage.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetSopCid(::std::string::String);
impl ::std::ops::Deref for TargetSopCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetSopCid> for ::std::string::String {
    fn from(value: TargetSopCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetSopCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetSopCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetSopCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetSopCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetSopCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`TargetSourceConcept`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Source Concept\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetSourceConcept(::std::string::String);
impl ::std::ops::Deref for TargetSourceConcept {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetSourceConcept> for ::std::string::String {
    fn from(value: TargetSourceConcept) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetSourceConcept {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetSourceConcept {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetSourceConcept {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetSourceConcept {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetSourceConcept {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The strictly bounded, un-redacted 1D string projection of the semantic artifact undergoing evaluation."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target String\","]
#[doc = "  \"description\": \"The strictly bounded, un-redacted 1D string projection of the semantic artifact undergoing evaluation.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetString(::std::string::String);
impl ::std::ops::Deref for TargetString {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetString> for ::std::string::String {
    fn from(value: TargetString) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetString {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetString {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetString {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetString {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetString {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The specific table mutated."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Table Uri\","]
#[doc = "  \"description\": \"The specific table mutated.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2048,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetTableUri(::std::string::String);
impl ::std::ops::Deref for TargetTableUri {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetTableUri> for ::std::string::String {
    fn from(value: TargetTableUri) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetTableUri {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2048usize {
            return Err("longer than 2048 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetTableUri {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetTableUri {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetTableUri {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetTableUri {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The identifier (expected to be a W3C DID) pointing to the real-world topology it is cloning."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Topology Cid\","]
#[doc = "  \"description\": \"The identifier (expected to be a W3C DID) pointing to the real-world topology it is cloning.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetTopologyCid(::std::string::String);
impl ::std::ops::Deref for TargetTopologyCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetTopologyCid> for ::std::string::String {
    fn from(value: TargetTopologyCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetTopologyCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetTopologyCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetTopologyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetTopologyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetTopologyCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`TargetTopologyProfile`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TargetTopologyProfile\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"N_DIMENSIONAL_TENSOR\","]
#[doc = "    \"MARKOV_BLANKET\","]
#[doc = "    \"ACYCLIC_DIRECTED_GRAPH\","]
#[doc = "    \"ALGEBRAIC_RING\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TargetTopologyProfile {
    #[serde(rename = "N_DIMENSIONAL_TENSOR")]
    NDimensionalTensor,
    #[serde(rename = "MARKOV_BLANKET")]
    MarkovBlanket,
    #[serde(rename = "ACYCLIC_DIRECTED_GRAPH")]
    AcyclicDirectedGraph,
    #[serde(rename = "ALGEBRAIC_RING")]
    AlgebraicRing,
}
impl ::std::fmt::Display for TargetTopologyProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::NDimensionalTensor => f.write_str("N_DIMENSIONAL_TENSOR"),
            Self::MarkovBlanket => f.write_str("MARKOV_BLANKET"),
            Self::AcyclicDirectedGraph => f.write_str("ACYCLIC_DIRECTED_GRAPH"),
            Self::AlgebraicRing => f.write_str("ALGEBRAIC_RING"),
        }
    }
}
impl ::std::str::FromStr for TargetTopologyProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "N_DIMENSIONAL_TENSOR" => Ok(Self::NDimensionalTensor),
            "MARKOV_BLANKET" => Ok(Self::MarkovBlanket),
            "ACYCLIC_DIRECTED_GRAPH" => Ok(Self::AcyclicDirectedGraph),
            "ALGEBRAIC_RING" => Ok(Self::AlgebraicRing),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TargetTopologyProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetTopologyProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetTopologyProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The dependent variable $Y$."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Target Variable\","]
#[doc = "  \"description\": \"The dependent variable $Y$.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TargetVariable(::std::string::String);
impl ::std::ops::Deref for TargetVariable {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TargetVariable> for ::std::string::String {
    fn from(value: TargetVariable) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TargetVariable {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TargetVariable {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TargetVariable {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TargetVariable {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TargetVariable {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Initiates a Request for Proposal (RFP) within a decentralized Spot Market to dynamically allocate thermodynamic compute based on task complexity.\n\nCAUSAL AFFORDANCE: Triggers an active, non-monotonic bidding phase where eligible Swarm nodes evaluate their internal Q-K matrices to formulate competitive execution bids.\n\nEPISTEMIC BOUNDS: The economic payload is physically capped by `max_budget_magnitude` (`le=18446744073709551615`). The topological routing is strictly constrained if `required_action_space_cid` is defined (optional, `max_length=128`, CID regex). Anchored by a mandatory `task_cid` CID.\n\nMCP ROUTING TRIGGERS: Decentralized Spot Market, Request for Proposal, Thermodynamic Compute Allocation, Algorithmic Mechanism Design, Kinetic Execution Trigger"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TaskAnnouncementIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Initiates a Request for Proposal (RFP) within a decentralized Spot Market to dynamically allocate thermodynamic compute based on task complexity.\\n\\nCAUSAL AFFORDANCE: Triggers an active, non-monotonic bidding phase where eligible Swarm nodes evaluate their internal Q-K matrices to formulate competitive execution bids.\\n\\nEPISTEMIC BOUNDS: The economic payload is physically capped by `max_budget_magnitude` (`le=18446744073709551615`). The topological routing is strictly constrained if `required_action_space_cid` is defined (optional, `max_length=128`, CID regex). Anchored by a mandatory `task_cid` CID.\\n\\nMCP ROUTING TRIGGERS: Decentralized Spot Market, Request for Proposal, Thermodynamic Compute Allocation, Algorithmic Mechanism Design, Kinetic Execution Trigger\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"max_budget_magnitude\","]
#[doc = "    \"task_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_budget_magnitude\": {"]
#[doc = "      \"title\": \"Max Budget Magnitude\","]
#[doc = "      \"description\": \"The absolute ceiling price the orchestrator is willing to pay.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"required_action_space_cid\": {"]
#[doc = "      \"title\": \"Required Action Space Cid\","]
#[doc = "      \"description\": \"Optional restriction forcing bidders to possess a specific toolset.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"task_cid\": {"]
#[doc = "      \"title\": \"Task Cid\","]
#[doc = "      \"description\": \"Unique identifier for the required task.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"The discriminative topological boundary for task announcement intents.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"task_announcement\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TaskAnnouncementIntent {
    #[doc = "The absolute ceiling price the orchestrator is willing to pay."]
    pub max_budget_magnitude: u64,
    #[doc = "Optional restriction forcing bidders to possess a specific toolset."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub required_action_space_cid: ::std::option::Option<::std::string::String>,
    #[doc = "Unique identifier for the required task."]
    pub task_cid: TaskCid,
    #[doc = "The discriminative topological boundary for task announcement intents."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl TaskAnnouncementIntent {
    pub fn builder() -> builder::TaskAnnouncementIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the successful clearing of an algorithmic auction and the mathematically proven allocation of compute capital.\n\nCAUSAL AFFORDANCE: Definitively terminates the auction phase and authorizes the awarded syndicate to execute their task trajectory using the locked EscrowPolicy funds.\n\nEPISTEMIC BOUNDS: Two `@model_validators` execute physical invariants: (1) Conservation of Compute (sum of `awarded_syndicate` values must exactly equal `cleared_price_magnitude` `le=18446744073709551615`); (2) Escrow Ceiling (`escrow_locked_magnitude` cannot exceed `cleared_price_magnitude`).\n\nMCP ROUTING TRIGGERS: Market Clearing, Escrow Lock, Cryptographic Provenance, Syndicate Allocation, Thermodynamic Execution"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TaskAwardReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A cryptographically frozen historical fact representing the successful clearing of an algorithmic auction and the mathematically proven allocation of compute capital.\\n\\nCAUSAL AFFORDANCE: Definitively terminates the auction phase and authorizes the awarded syndicate to execute their task trajectory using the locked EscrowPolicy funds.\\n\\nEPISTEMIC BOUNDS: Two `@model_validators` execute physical invariants: (1) Conservation of Compute (sum of `awarded_syndicate` values must exactly equal `cleared_price_magnitude` `le=18446744073709551615`); (2) Escrow Ceiling (`escrow_locked_magnitude` cannot exceed `cleared_price_magnitude`).\\n\\nMCP ROUTING TRIGGERS: Market Clearing, Escrow Lock, Cryptographic Provenance, Syndicate Allocation, Thermodynamic Execution\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"awarded_syndicate\","]
#[doc = "    \"cleared_price_magnitude\","]
#[doc = "    \"task_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"awarded_syndicate\": {"]
#[doc = "      \"title\": \"Awarded Syndicate\","]
#[doc = "      \"description\": \"Strict mapping of agent NodeIdentifierStates to their exact fractional payout in magnitude.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"integer\","]
#[doc = "        \"minimum\": 0.0"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"cleared_price_magnitude\": {"]
#[doc = "      \"title\": \"Cleared Price Magnitude\","]
#[doc = "      \"description\": \"The final cryptographic clearing price.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"escrow\": {"]
#[doc = "      \"description\": \"The conditional escrow locking the compute budget.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EscrowPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"task_cid\": {"]
#[doc = "      \"title\": \"Task Cid\","]
#[doc = "      \"description\": \"The identifier of the resolved task.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TaskAwardReceipt {
    #[doc = "Strict mapping of agent NodeIdentifierStates to their exact fractional payout in magnitude."]
    pub awarded_syndicate: ::std::collections::HashMap<::std::string::String, u64>,
    #[doc = "The final cryptographic clearing price."]
    pub cleared_price_magnitude: u64,
    #[doc = "The conditional escrow locking the compute budget."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub escrow: ::std::option::Option<EscrowPolicy>,
    #[doc = "The identifier of the resolved task."]
    pub task_cid: TaskCid,
}
impl TaskAwardReceipt {
    pub fn builder() -> builder::TaskAwardReceipt {
        Default::default()
    }
}
#[doc = "Unique identifier for this active inference execution."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Task Cid\","]
#[doc = "  \"description\": \"Unique identifier for this active inference execution.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TaskCid(::std::string::String);
impl ::std::ops::Deref for TaskCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TaskCid> for ::std::string::String {
    fn from(value: TaskCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TaskCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TaskCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TaskCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TaskCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TaskCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Hierarchical Agglomerative Clustering to project continuous,\ndense latent vector spaces into a deterministic, discrete N-ary tree structure. As a\n...State suffix, this is a declarative, frozen snapshot of a specific geometric coordinate.\n\nCAUSAL AFFORDANCE: Establishes a strictly bounded, navigable spatial coordinate within\nthe Virtual File System (VFS), allowing agents to traverse high-dimensional semantic\nspaces without consuming excessive context window tokens.\n\nEPISTEMIC BOUNDS: Spatial geometry is locked via node_cid (a strictly typed 128-character\nCID). The children_node_cids array is deterministically sorted, and the leaf_provenance\narray is sorted by source_event_cid, both via @model_validator to guarantee invariant\nRFC 8785 canonical hashing.\n\nMCP ROUTING TRIGGERS: Dimensionality Reduction, Hierarchical Clustering, N-ary Tree,\nVirtual File System, Semantic Coordinate"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TaxonomicNodeState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Hierarchical Agglomerative Clustering to project continuous,\\ndense latent vector spaces into a deterministic, discrete N-ary tree structure. As a\\n...State suffix, this is a declarative, frozen snapshot of a specific geometric coordinate.\\n\\nCAUSAL AFFORDANCE: Establishes a strictly bounded, navigable spatial coordinate within\\nthe Virtual File System (VFS), allowing agents to traverse high-dimensional semantic\\nspaces without consuming excessive context window tokens.\\n\\nEPISTEMIC BOUNDS: Spatial geometry is locked via node_cid (a strictly typed 128-character\\nCID). The children_node_cids array is deterministically sorted, and the leaf_provenance\\narray is sorted by source_event_cid, both via @model_validator to guarantee invariant\\nRFC 8785 canonical hashing.\\n\\nMCP ROUTING TRIGGERS: Dimensionality Reduction, Hierarchical Clustering, N-ary Tree,\\nVirtual File System, Semantic Coordinate\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"node_cid\","]
#[doc = "    \"semantic_label\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"children_node_cids\": {"]
#[doc = "      \"title\": \"Children Node Cids\","]
#[doc = "      \"description\": \"Explicit array of child node CIDs to enforce the Directed Acyclic Graph.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"leaf_provenance\": {"]
#[doc = "      \"title\": \"Leaf Provenance\","]
#[doc = "      \"description\": \"The mathematical chain of custody binding this virtual coordinate back to physical vectors.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EpistemicProvenanceReceipt\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"node_cid\": {"]
#[doc = "      \"title\": \"Node Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) bounding this specific taxonomic coordinate.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"render_material\": {"]
#[doc = "      \"description\": \"The physics-agnostic visual identity or shader governing the spatial rendering of this node.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SpatialRenderMaterial\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"semantic_label\": {"]
#[doc = "      \"title\": \"Semantic Label\","]
#[doc = "      \"description\": \"The human-legible, dynamically synthesized categorical label (e.g., 'High Risk Policies').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TaxonomicNodeState {
    #[doc = "Explicit array of child node CIDs to enforce the Directed Acyclic Graph."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub children_node_cids: ::std::vec::Vec<ChildrenNodeCidsItem>,
    #[doc = "The mathematical chain of custody binding this virtual coordinate back to physical vectors."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub leaf_provenance: ::std::vec::Vec<EpistemicProvenanceReceipt>,
    #[doc = "A Content Identifier (CID) bounding this specific taxonomic coordinate."]
    pub node_cid: NodeCid,
    #[doc = "The physics-agnostic visual identity or shader governing the spatial rendering of this node."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub render_material: ::std::option::Option<SpatialRenderMaterial>,
    #[doc = "The human-legible, dynamically synthesized categorical label (e.g., 'High Risk Policies')."]
    pub semantic_label: SemanticLabel,
}
impl TaxonomicNodeState {
    pub fn builder() -> builder::TaxonomicNodeState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Executes a kinetic Graph Isomorphism transformation, dynamically mutating the UI's spatial organization via heuristic regrouping without altering the underlying epistemic truth.\n\nCAUSAL AFFORDANCE: Forces the Hollow Data Plane to immediately discard the current semantic manifold and re-render the hierarchical projection according to the newly synthesized `target_taxonomy` and spatial heuristic.\n\nEPISTEMIC BOUNDS: Execution is rigidly constrained by the `restructure_heuristic`, strictly bounded to a Literal automaton `[\"chronological\", \"entity_centric\", \"semantic_cluster\", \"confidence_decay\"]`, mathematically preventing out-of-distribution UI mutations.\n\nMCP ROUTING TRIGGERS: Graph Isomorphism, UI State Mutation, Heuristic Regrouping, Dynamic Manifold, Spatial Reorganization"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TaxonomicRestructureIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Executes a kinetic Graph Isomorphism transformation, dynamically mutating the UI's spatial organization via heuristic regrouping without altering the underlying epistemic truth.\\n\\nCAUSAL AFFORDANCE: Forces the Hollow Data Plane to immediately discard the current semantic manifold and re-render the hierarchical projection according to the newly synthesized `target_taxonomy` and spatial heuristic.\\n\\nEPISTEMIC BOUNDS: Execution is rigidly constrained by the `restructure_heuristic`, strictly bounded to a Literal automaton `[\\\"chronological\\\", \\\"entity_centric\\\", \\\"semantic_cluster\\\", \\\"confidence_decay\\\"]`, mathematically preventing out-of-distribution UI mutations.\\n\\nMCP ROUTING TRIGGERS: Graph Isomorphism, UI State Mutation, Heuristic Regrouping, Dynamic Manifold, Spatial Reorganization\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"restructure_heuristic\","]
#[doc = "    \"target_taxonomy\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"restructure_heuristic\": {"]
#[doc = "      \"title\": \"Restructure Heuristic\","]
#[doc = "      \"description\": \"The SOTA mathematical heuristic used to project the new manifold.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"chronological\","]
#[doc = "        \"entity_centric\","]
#[doc = "        \"semantic_cluster\","]
#[doc = "        \"confidence_decay\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_taxonomy\": {"]
#[doc = "      \"description\": \"The newly synthesized topology projected to the frontend.\","]
#[doc = "      \"$ref\": \"#/$defs/GenerativeTaxonomyManifest\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Strict discriminator for dynamic UI regrouping.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"taxonomic_restructure\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TaxonomicRestructureIntent {
    #[doc = "The SOTA mathematical heuristic used to project the new manifold."]
    pub restructure_heuristic: RestructureHeuristic,
    #[doc = "The newly synthesized topology projected to the frontend."]
    pub target_taxonomy: GenerativeTaxonomyManifest,
    #[doc = "Strict discriminator for dynamic UI regrouping."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl TaxonomicRestructureIntent {
    pub fn builder() -> builder::TaxonomicRestructureIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements a deterministic Softmax Router Gate, leveraging Cognitive Load Theory to map high-entropy natural language intents into explicitly bounded spatial organizing frameworks.\n\nCAUSAL AFFORDANCE: Preemptively routes classified intents to optimized taxonomic layouts, mechanically preventing token exhaustion and attention dilution in downstream processing nodes before compute is allocated.\n\nEPISTEMIC BOUNDS: The `intent_to_heuristic_matrix` physically restricts state-space explosion by capping at `max_length=1000` dictionary properties. The matrix keys are strictly bounded to 255 characters via `StringConstraints` to mathematically prevent Dictionary Bombing.\n\nMCP ROUTING TRIGGERS: Softmax Gating, Cognitive Load Theory, Pre-Flight Routing, Dictionary Bombing Prevention, Token Exhaustion Mitigation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TaxonomicRoutingPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements a deterministic Softmax Router Gate, leveraging Cognitive Load Theory to map high-entropy natural language intents into explicitly bounded spatial organizing frameworks.\\n\\nCAUSAL AFFORDANCE: Preemptively routes classified intents to optimized taxonomic layouts, mechanically preventing token exhaustion and attention dilution in downstream processing nodes before compute is allocated.\\n\\nEPISTEMIC BOUNDS: The `intent_to_heuristic_matrix` physically restricts state-space explosion by capping at `max_length=1000` dictionary properties. The matrix keys are strictly bounded to 255 characters via `StringConstraints` to mathematically prevent Dictionary Bombing.\\n\\nMCP ROUTING TRIGGERS: Softmax Gating, Cognitive Load Theory, Pre-Flight Routing, Dictionary Bombing Prevention, Token Exhaustion Mitigation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"fallback_heuristic\","]
#[doc = "    \"intent_to_heuristic_matrix\","]
#[doc = "    \"policy_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"fallback_heuristic\": {"]
#[doc = "      \"title\": \"Fallback Heuristic\","]
#[doc = "      \"description\": \"The deterministic default applied if intent classification falls below the safety threshold.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"chronological\","]
#[doc = "        \"entity_centric\","]
#[doc = "        \"semantic_cluster\","]
#[doc = "        \"confidence_decay\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"intent_to_heuristic_matrix\": {"]
#[doc = "      \"title\": \"Intent To Heuristic Matrix\","]
#[doc = "      \"description\": \"Strict dictionary binding classified natural language intents to bounded spatial heuristics.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"enum\": ["]
#[doc = "          \"chronological\","]
#[doc = "          \"entity_centric\","]
#[doc = "          \"semantic_cluster\","]
#[doc = "          \"confidence_decay\""]
#[doc = "        ]"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"policy_cid\": {"]
#[doc = "      \"title\": \"Policy Cid\","]
#[doc = "      \"description\": \"Unique identifier for this pre-flight routing policy.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TaxonomicRoutingPolicy {
    #[doc = "The deterministic default applied if intent classification falls below the safety threshold."]
    pub fallback_heuristic: FallbackHeuristic,
    #[doc = "Strict dictionary binding classified natural language intents to bounded spatial heuristics."]
    pub intent_to_heuristic_matrix: ::std::collections::HashMap<
        ::std::string::String,
        TaxonomicRoutingPolicyIntentToHeuristicMatrixValue,
    >,
    #[doc = "Unique identifier for this pre-flight routing policy."]
    pub policy_cid: PolicyCid,
}
impl TaxonomicRoutingPolicy {
    pub fn builder() -> builder::TaxonomicRoutingPolicy {
        Default::default()
    }
}
#[doc = "`TaxonomicRoutingPolicyIntentToHeuristicMatrixValue`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"chronological\","]
#[doc = "    \"entity_centric\","]
#[doc = "    \"semantic_cluster\","]
#[doc = "    \"confidence_decay\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TaxonomicRoutingPolicyIntentToHeuristicMatrixValue {
    #[serde(rename = "chronological")]
    Chronological,
    #[serde(rename = "entity_centric")]
    EntityCentric,
    #[serde(rename = "semantic_cluster")]
    SemanticCluster,
    #[serde(rename = "confidence_decay")]
    ConfidenceDecay,
}
impl ::std::fmt::Display for TaxonomicRoutingPolicyIntentToHeuristicMatrixValue {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Chronological => f.write_str("chronological"),
            Self::EntityCentric => f.write_str("entity_centric"),
            Self::SemanticCluster => f.write_str("semantic_cluster"),
            Self::ConfidenceDecay => f.write_str("confidence_decay"),
        }
    }
}
impl ::std::str::FromStr for TaxonomicRoutingPolicyIntentToHeuristicMatrixValue {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "chronological" => Ok(Self::Chronological),
            "entity_centric" => Ok(Self::EntityCentric),
            "semantic_cluster" => Ok(Self::SemanticCluster),
            "confidence_decay" => Ok(Self::ConfidenceDecay),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TaxonomicRoutingPolicyIntentToHeuristicMatrixValue {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String>
    for TaxonomicRoutingPolicyIntentToHeuristicMatrixValue
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String>
    for TaxonomicRoutingPolicyIntentToHeuristicMatrixValue
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes the Observer Effect to dynamically modulate the thermodynamic flow of network egress based on the observer's spatial view frustum.\nCAUSAL AFFORDANCE: Instructs the orchestrator's telemetry manifold to aggressively shed bandwidth load by calculating the dot product of topology nodes against the observer's focal vector. It starves occluded or peripheral subgraphs of kinematic updates to preserve system liveness.\nEPISTEMIC BOUNDS: Temporal refresh velocities are strictly clamped to physical Hertz frequencies. The mathematical invariant guarantees that flow rate monotonically increases as nodes approach the focal center.\nMCP ROUTING TRIGGERS: Observer Effect, Frustum Culling, Thermodynamic Flow Control, Telemetry Backpressure, Spatial Masking"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TelemetryBackpressureContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes the Observer Effect to dynamically modulate the thermodynamic flow of network egress based on the observer's spatial view frustum.\\nCAUSAL AFFORDANCE: Instructs the orchestrator's telemetry manifold to aggressively shed bandwidth load by calculating the dot product of topology nodes against the observer's focal vector. It starves occluded or peripheral subgraphs of kinematic updates to preserve system liveness.\\nEPISTEMIC BOUNDS: Temporal refresh velocities are strictly clamped to physical Hertz frequencies. The mathematical invariant guarantees that flow rate monotonically increases as nodes approach the focal center.\\nMCP ROUTING TRIGGERS: Observer Effect, Frustum Culling, Thermodynamic Flow Control, Telemetry Backpressure, Spatial Masking\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"focal_refresh_rate_hz\","]
#[doc = "    \"peripheral_refresh_rate_hz\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"epsilon_derivative_threshold\": {"]
#[doc = "      \"title\": \"Epsilon Derivative Threshold\","]
#[doc = "      \"description\": \"Minimum spatial or state magnitude delta required to authorize network egress.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1000.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"focal_refresh_rate_hz\": {"]
#[doc = "      \"title\": \"Focal Refresh Rate Hz\","]
#[doc = "      \"description\": \"The high-velocity telemetry budget (Hz) allocated exclusively to topologies intersecting the center of the observer's view frustum.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 240.0,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"occluded_refresh_rate_hz\": {"]
#[doc = "      \"title\": \"Occluded Refresh Rate Hz\","]
#[doc = "      \"description\": \"The starvation rate (Hz) for topologies failing the depth test or falling outside clipping planes.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"peripheral_refresh_rate_hz\": {"]
#[doc = "      \"title\": \"Peripheral Refresh Rate Hz\","]
#[doc = "      \"description\": \"The degraded telemetry budget (Hz) for nodes at the edges of the optical projection.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 60.0,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TelemetryBackpressureContract {
    #[doc = "Minimum spatial or state magnitude delta required to authorize network egress."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epsilon_derivative_threshold: ::std::option::Option<f64>,
    #[doc = "The high-velocity telemetry budget (Hz) allocated exclusively to topologies intersecting the center of the observer's view frustum."]
    pub focal_refresh_rate_hz: ::std::num::NonZeroU64,
    #[doc = "The starvation rate (Hz) for topologies failing the depth test or falling outside clipping planes."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub occluded_refresh_rate_hz: ::std::option::Option<i64>,
    #[doc = "The degraded telemetry budget (Hz) for nodes at the edges of the optical projection."]
    pub peripheral_refresh_rate_hz: ::std::num::NonZeroU64,
}
impl TelemetryBackpressureContract {
    pub fn builder() -> builder::TelemetryBackpressureContract {
        Default::default()
    }
}
#[doc = "`TelemetryContextProfile`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"additionalProperties\": {"]
#[doc = "    \"anyOf\": ["]
#[doc = "      {"]
#[doc = "        \"$ref\": \"#/$defs/TelemetryScalarState\""]
#[doc = "      },"]
#[doc = "      {"]
#[doc = "        \"type\": \"array\","]
#[doc = "        \"items\": {"]
#[doc = "          \"$ref\": \"#/$defs/TelemetryScalarState\""]
#[doc = "        }"]
#[doc = "      }"]
#[doc = "    ]"]
#[doc = "  }"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(transparent)]
pub struct TelemetryContextProfile(
    pub ::std::collections::HashMap<::std::string::String, TelemetryContextProfileValue>,
);
impl ::std::ops::Deref for TelemetryContextProfile {
    type Target = ::std::collections::HashMap<::std::string::String, TelemetryContextProfileValue>;
    fn deref(
        &self,
    ) -> &::std::collections::HashMap<::std::string::String, TelemetryContextProfileValue> {
        &self.0
    }
}
impl ::std::convert::From<TelemetryContextProfile>
    for ::std::collections::HashMap<::std::string::String, TelemetryContextProfileValue>
{
    fn from(value: TelemetryContextProfile) -> Self {
        value.0
    }
}
impl
    ::std::convert::From<
        ::std::collections::HashMap<::std::string::String, TelemetryContextProfileValue>,
    > for TelemetryContextProfile
{
    fn from(
        value: ::std::collections::HashMap<::std::string::String, TelemetryContextProfileValue>,
    ) -> Self {
        Self(value)
    }
}
#[doc = "`TelemetryContextProfileValue`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"anyOf\": ["]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/TelemetryScalarState\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/TelemetryScalarState\""]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum TelemetryContextProfileValue {
    TelemetryScalarState(TelemetryScalarState),
    Array(::std::vec::Vec<TelemetryScalarState>),
}
impl ::std::convert::From<TelemetryScalarState> for TelemetryContextProfileValue {
    fn from(value: TelemetryScalarState) -> Self {
        Self::TelemetryScalarState(value)
    }
}
impl ::std::convert::From<::std::vec::Vec<TelemetryScalarState>> for TelemetryContextProfileValue {
    fn from(value: ::std::vec::Vec<TelemetryScalarState>) -> Self {
        Self::Array(value)
    }
}
#[doc = "`TelemetryScalarState`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"anyOf\": ["]
#[doc = "    {"]
#[doc = "      \"type\": \"string\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"integer\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"number\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"type\": \"null\""]
#[doc = "    }"]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum TelemetryScalarState {
    String(::std::string::String),
    Integer(i64),
    Number(f64),
    Boolean(bool),
    Null,
}
impl ::std::convert::From<i64> for TelemetryScalarState {
    fn from(value: i64) -> Self {
        Self::Integer(value)
    }
}
impl ::std::convert::From<f64> for TelemetryScalarState {
    fn from(value: f64) -> Self {
        Self::Number(value)
    }
}
impl ::std::convert::From<bool> for TelemetryScalarState {
    fn from(value: bool) -> Self {
        Self::Boolean(value)
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Teleological Isometry by measuring the exact mathematical alignment between a stated generative deficit and the empirical behavior of a forged tool.\n\n    CAUSAL AFFORDANCE: Approves or severs the final node promotion. If the cosine similarity bounds fall below the threshold, the orchestrator triggers an immediate rollback logic.\n\n    EPISTEMIC BOUNDS: Evaluated via deterministic cosine similarity constraints measuring between -1.0 and 1.0. The validator explicitly modifies the Boolean passing state if the float threshold isn't met.\n\n    MCP ROUTING TRIGGERS: Teleological Isometry, Tool Forging Validation, Cosine Similarity, Generative Deficit, Empirical Behavior"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TeleologicalIsometryReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Teleological Isometry by measuring the exact mathematical alignment between a stated generative deficit and the empirical behavior of a forged tool.\\n\\n    CAUSAL AFFORDANCE: Approves or severs the final node promotion. If the cosine similarity bounds fall below the threshold, the orchestrator triggers an immediate rollback logic.\\n\\n    EPISTEMIC BOUNDS: Evaluated via deterministic cosine similarity constraints measuring between -1.0 and 1.0. The validator explicitly modifies the Boolean passing state if the float threshold isn't met.\\n\\n    MCP ROUTING TRIGGERS: Teleological Isometry, Tool Forging Validation, Cosine Similarity, Generative Deficit, Empirical Behavior\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"alignment_threshold_passed\","]
#[doc = "    \"forged_output_vector\","]
#[doc = "    \"measured_cosine_similarity\","]
#[doc = "    \"source_intent_cid\","]
#[doc = "    \"target_intent_vector\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"alignment_threshold_passed\": {"]
#[doc = "      \"title\": \"Alignment Threshold Passed\","]
#[doc = "      \"description\": \"The absolute Boolean threshold indicating structural compliance.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"forged_output_vector\": {"]
#[doc = "      \"description\": \"The mathematical behavioral state measured after evaluating the executed node structure.\","]
#[doc = "      \"$ref\": \"#/$defs/VectorEmbeddingState\""]
#[doc = "    },"]
#[doc = "    \"measured_cosine_similarity\": {"]
#[doc = "      \"title\": \"Measured Cosine Similarity\","]
#[doc = "      \"description\": \"The deterministic cosine similarity scalar bounded within the normalized [-1.0, 1.0] mathematical range.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": -1.0"]
#[doc = "    },"]
#[doc = "    \"source_intent_cid\": {"]
#[doc = "      \"title\": \"Source Intent Cid\","]
#[doc = "      \"description\": \"The structural 128-char DID boundary pointing to the foundational semantic deficit vector.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_intent_vector\": {"]
#[doc = "      \"description\": \"The dense mathematical representation of the initial multi-dimensional epistemic deficit.\","]
#[doc = "      \"$ref\": \"#/$defs/VectorEmbeddingState\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TeleologicalIsometryReceipt {
    #[doc = "The absolute Boolean threshold indicating structural compliance."]
    pub alignment_threshold_passed: bool,
    #[doc = "The mathematical behavioral state measured after evaluating the executed node structure."]
    pub forged_output_vector: VectorEmbeddingState,
    #[doc = "The deterministic cosine similarity scalar bounded within the normalized [-1.0, 1.0] mathematical range."]
    pub measured_cosine_similarity: f64,
    #[doc = "The structural 128-char DID boundary pointing to the foundational semantic deficit vector."]
    pub source_intent_cid: SourceIntentCid,
    #[doc = "The dense mathematical representation of the initial multi-dimensional epistemic deficit."]
    pub target_intent_vector: VectorEmbeddingState,
}
impl TeleologicalIsometryReceipt {
    pub fn builder() -> builder::TeleologicalIsometryReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Allen's Interval Algebra to definitively lock a state coordinate within an exact chronological boundary on the Merkle-DAG. Enforces Graphiti Temporal Logic where chronological inception is mandatory.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator to computationally evaluate overlapping or preceding topological events to govern temporal state transitions and eviction.\n\nEPISTEMIC BOUNDS: Both `valid_from` and `valid_to` are physically clamped (`le=18446744073709551615.0`, `ge=0.0`). The `@model_validator` mathematically forbids inverted temporal geometry by guaranteeing `valid_to` is strictly greater than `valid_from`.\n\nMCP ROUTING TRIGGERS: Allen's Interval Algebra, Temporal Geometry, Chronological Bounding, Topological Time, State Transition"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TemporalBoundsProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Allen's Interval Algebra to definitively lock a state coordinate within an exact chronological boundary on the Merkle-DAG. Enforces Graphiti Temporal Logic where chronological inception is mandatory.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator to computationally evaluate overlapping or preceding topological events to govern temporal state transitions and eviction.\\n\\nEPISTEMIC BOUNDS: Both `valid_from` and `valid_to` are physically clamped (`le=18446744073709551615.0`, `ge=0.0`). The `@model_validator` mathematically forbids inverted temporal geometry by guaranteeing `valid_to` is strictly greater than `valid_from`.\\n\\nMCP ROUTING TRIGGERS: Allen's Interval Algebra, Temporal Geometry, Chronological Bounding, Topological Time, State Transition\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"valid_from\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"interval_class\": {"]
#[doc = "      \"description\": \"The Allen's interval algebra or causal relationship classification.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/CausalIntervalProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"probabilistic_end_interval\": {"]
#[doc = "      \"title\": \"Probabilistic End Interval\","]
#[doc = "      \"description\": \"Fuzzy bounds of invalidation.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"array\","]
#[doc = "          \"maxItems\": 2,"]
#[doc = "          \"minItems\": 2,"]
#[doc = "          \"prefixItems\": ["]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            }"]
#[doc = "          ]"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"probabilistic_start_interval\": {"]
#[doc = "      \"title\": \"Probabilistic Start Interval\","]
#[doc = "      \"description\": \"Fuzzy bounds of inception.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"array\","]
#[doc = "          \"maxItems\": 2,"]
#[doc = "          \"minItems\": 2,"]
#[doc = "          \"prefixItems\": ["]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            },"]
#[doc = "            {"]
#[doc = "              \"type\": \"number\""]
#[doc = "            }"]
#[doc = "          ]"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"temporal_certainty_score\": {"]
#[doc = "      \"title\": \"Temporal Certainty Score\","]
#[doc = "      \"description\": \"Bayesian certainty of temporal bounds.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"valid_from\": {"]
#[doc = "      \"title\": \"Valid From\","]
#[doc = "      \"description\": \"The UNIX timestamp when this coordinate became true.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"valid_to\": {"]
#[doc = "      \"title\": \"Valid To\","]
#[doc = "      \"description\": \"The UNIX timestamp when this coordinate was invalidated.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.8446744073709552e+19"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TemporalBoundsProfile {
    #[doc = "The Allen's interval algebra or causal relationship classification."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub interval_class: ::std::option::Option<CausalIntervalProfile>,
    #[doc = "Fuzzy bounds of invalidation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub probabilistic_end_interval: ::std::option::Option<[::serde_json::Value; 2usize]>,
    #[doc = "Fuzzy bounds of inception."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub probabilistic_start_interval: ::std::option::Option<[::serde_json::Value; 2usize]>,
    #[doc = "Bayesian certainty of temporal bounds."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub temporal_certainty_score: ::std::option::Option<f64>,
    #[doc = "The UNIX timestamp when this coordinate became true."]
    pub valid_from: f64,
    #[doc = "The UNIX timestamp when this coordinate was invalidated."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub valid_to: ::std::option::Option<f64>,
}
impl TemporalBoundsProfile {
    pub fn builder() -> builder::TemporalBoundsProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements the Chandy-Lamport Distributed Snapshot Algorithm\nand Temporal Logic to create hard, restorative anchors on the continuous\nMerkle-DAG. As a ...State suffix, this is a declarative, frozen snapshot of\nN-dimensional geometry.\n\nCAUSAL AFFORDANCE: Unlocks O(1) state restoration and causal rollback.\nAuthorizes the orchestrator to instantly rewind the swarm's topology to a\npristine historical coordinate without requiring sequential re-computation.\nThe checkpoint_cid (128-char CID) uniquely anchors the snapshot.\n\nEPISTEMIC BOUNDS: The state geometry is mathematically locked to the\nstate_hash via a strict RFC 8785 SHA-256 regex (^[a-f0-9]{64}$). The temporal\npointer ledger_index is physically clamped (le=18446744073709551615) to prevent integer\noverflow during prolonged swarm execution.\n\nMCP ROUTING TRIGGERS: Distributed Snapshot, Chandy-Lamport, Merkle-DAG\nRestoration, Temporal Logic, O(1) Rollback"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TemporalCheckpointState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements the Chandy-Lamport Distributed Snapshot Algorithm\\nand Temporal Logic to create hard, restorative anchors on the continuous\\nMerkle-DAG. As a ...State suffix, this is a declarative, frozen snapshot of\\nN-dimensional geometry.\\n\\nCAUSAL AFFORDANCE: Unlocks O(1) state restoration and causal rollback.\\nAuthorizes the orchestrator to instantly rewind the swarm's topology to a\\npristine historical coordinate without requiring sequential re-computation.\\nThe checkpoint_cid (128-char CID) uniquely anchors the snapshot.\\n\\nEPISTEMIC BOUNDS: The state geometry is mathematically locked to the\\nstate_hash via a strict RFC 8785 SHA-256 regex (^[a-f0-9]{64}$). The temporal\\npointer ledger_index is physically clamped (le=18446744073709551615) to prevent integer\\noverflow during prolonged swarm execution.\\n\\nMCP ROUTING TRIGGERS: Distributed Snapshot, Chandy-Lamport, Merkle-DAG\\nRestoration, Temporal Logic, O(1) Rollback\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"checkpoint_cid\","]
#[doc = "    \"ledger_index\","]
#[doc = "    \"state_hash\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"checkpoint_cid\": {"]
#[doc = "      \"title\": \"Checkpoint Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the temporal anchor.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"ledger_index\": {"]
#[doc = "      \"title\": \"Ledger Index\","]
#[doc = "      \"description\": \"The exact array index in the EpistemicLedgerState this checkpoint represents.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19"]
#[doc = "    },"]
#[doc = "    \"state_hash\": {"]
#[doc = "      \"title\": \"State Hash\","]
#[doc = "      \"description\": \"The canonical RFC 8785 SHA-256 hash of the entire topology at this exact index.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TemporalCheckpointState {
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark for the temporal anchor."]
    pub checkpoint_cid: CheckpointCid,
    #[doc = "The exact array index in the EpistemicLedgerState this checkpoint represents."]
    pub ledger_index: u64,
    #[doc = "The canonical RFC 8785 SHA-256 hash of the entire topology at this exact index."]
    pub state_hash: StateHash,
}
impl TemporalCheckpointState {
    pub fn builder() -> builder::TemporalCheckpointState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the mathematical merge algebra for continuous-time topologies.\nCAUSAL AFFORDANCE: Instructs the orchestrator on how to resolve concurrent edge bounds.\nEPISTEMIC BOUNDS: Constrained to strict algebraic resolution profiles.\nMCP ROUTING TRIGGERS: Conflict Resolution, Graph CRDT, Merge Algebra, Eventual Consistency"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TemporalConflictResolutionPolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the mathematical merge algebra for continuous-time topologies.\\nCAUSAL AFFORDANCE: Instructs the orchestrator on how to resolve concurrent edge bounds.\\nEPISTEMIC BOUNDS: Constrained to strict algebraic resolution profiles.\\nMCP ROUTING TRIGGERS: Conflict Resolution, Graph CRDT, Merge Algebra, Eventual Consistency\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"merge_algebra\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"enforce_idempotence\": {"]
#[doc = "      \"title\": \"Enforce Idempotence\","]
#[doc = "      \"description\": \"Guarantees f(f(x)) = f(x) during multi-agent graph synchronization.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"merge_algebra\": {"]
#[doc = "      \"title\": \"Merge Algebra\","]
#[doc = "      \"description\": \"The formal mathematical operation used to resolve topological forks.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"set_union\","]
#[doc = "        \"lamport_dominance\","]
#[doc = "        \"vector_clock_dominance\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TemporalConflictResolutionPolicy {
    #[doc = "Guarantees f(f(x)) = f(x) during multi-agent graph synchronization."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub enforce_idempotence: ::std::option::Option<bool>,
    #[doc = "The formal mathematical operation used to resolve topological forks."]
    pub merge_algebra: MergeAlgebra,
}
impl TemporalConflictResolutionPolicy {
    pub fn builder() -> builder::TemporalConflictResolutionPolicy {
        Default::default()
    }
}
#[doc = "The temporal decay function for semantic relevance."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Temporal Decay Function\","]
#[doc = "  \"description\": \"The temporal decay function for semantic relevance.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"exponential\","]
#[doc = "    \"cosine_annealing\","]
#[doc = "    \"polynomial\","]
#[doc = "    \"none\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TemporalDecayFunction {
    #[serde(rename = "exponential")]
    Exponential,
    #[serde(rename = "cosine_annealing")]
    CosineAnnealing,
    #[serde(rename = "polynomial")]
    Polynomial,
    #[serde(rename = "none")]
    None,
}
impl ::std::fmt::Display for TemporalDecayFunction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Exponential => f.write_str("exponential"),
            Self::CosineAnnealing => f.write_str("cosine_annealing"),
            Self::Polynomial => f.write_str("polynomial"),
            Self::None => f.write_str("none"),
        }
    }
}
impl ::std::str::FromStr for TemporalDecayFunction {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "exponential" => Ok(Self::Exponential),
            "cosine_annealing" => Ok(Self::CosineAnnealing),
            "polynomial" => Ok(Self::Polynomial),
            "none" => Ok(Self::None),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TemporalDecayFunction {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TemporalDecayFunction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TemporalDecayFunction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements temporal retraction for Graph CRDTs by targeting specific edges for invalidation.\nCAUSAL AFFORDANCE: Allows a node to issue a topological retraction by appending it to a CRDT terminate set.\nEPISTEMIC BOUNDS: The target_edge_cid is strictly typed. The invalidation_timestamp physically caps the timeline geometry.\nMCP ROUTING TRIGGERS: Graph CRDTs, Topological Retraction, Non-Monotonic Logic, Edge Invalidation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TemporalEdgeInvalidationIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements temporal retraction for Graph CRDTs by targeting specific edges for invalidation.\\nCAUSAL AFFORDANCE: Allows a node to issue a topological retraction by appending it to a CRDT terminate set.\\nEPISTEMIC BOUNDS: The target_edge_cid is strictly typed. The invalidation_timestamp physically caps the timeline geometry.\\nMCP ROUTING TRIGGERS: Graph CRDTs, Topological Retraction, Non-Monotonic Logic, Edge Invalidation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"causal_justification_cid\","]
#[doc = "    \"invalidation_timestamp\","]
#[doc = "    \"target_edge_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"causal_justification_cid\": {"]
#[doc = "      \"description\": \"The ObservationEvent or FalsificationContract CID forcing this non-monotonic state transition.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"invalidation_timestamp\": {"]
#[doc = "      \"title\": \"Invalidation Timestamp\","]
#[doc = "      \"description\": \"The precise chronological coordinate terminating the truth value (Graphiti valid_to).\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"target_edge_cid\": {"]
#[doc = "      \"description\": \"The Decentralized Identifier (DID) of the edge being temporally invalidated.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for temporal edge invalidation.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"temporal_invalidation\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TemporalEdgeInvalidationIntent {
    #[doc = "The ObservationEvent or FalsificationContract CID forcing this non-monotonic state transition."]
    pub causal_justification_cid: NodeCidState,
    #[doc = "The precise chronological coordinate terminating the truth value (Graphiti valid_to)."]
    pub invalidation_timestamp: f64,
    #[doc = "The Decentralized Identifier (DID) of the edge being temporally invalidated."]
    pub target_edge_cid: NodeCidState,
    #[doc = "Discriminator for temporal edge invalidation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl TemporalEdgeInvalidationIntent {
    pub fn builder() -> builder::TemporalEdgeInvalidationIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Conflict-free Replicated Data Types (CRDTs) using State-based Semilattices (G-Sets).\nCAUSAL AFFORDANCE: Enables lock-free, decentralized state synchronization across the swarm without destructive updates.\nEPISTEMIC BOUNDS: Cryptographically anchored by diff_cid. CRDT arrays are deterministically sorted via model_validator.\nMCP ROUTING TRIGGERS: Conflict-Free Replicated Data Types, State-based Semilattice, Eventual Consistency, G-Set"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TemporalGraphCRDTManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Conflict-free Replicated Data Types (CRDTs) using State-based Semilattices (G-Sets).\\nCAUSAL AFFORDANCE: Enables lock-free, decentralized state synchronization across the swarm without destructive updates.\\nEPISTEMIC BOUNDS: Cryptographically anchored by diff_cid. CRDT arrays are deterministically sorted via model_validator.\\nMCP ROUTING TRIGGERS: Conflict-Free Replicated Data Types, State-based Semilattice, Eventual Consistency, G-Set\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"author_node_cid\","]
#[doc = "    \"diff_cid\","]
#[doc = "    \"lamport_timestamp\","]
#[doc = "    \"vector_clock\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"add_set\": {"]
#[doc = "      \"title\": \"Add Set\","]
#[doc = "      \"description\": \"The Grow-Only Set (G-Set) of newly transmutated semantic vertices.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"author_node_cid\": {"]
#[doc = "      \"title\": \"Author Node Cid\","]
#[doc = "      \"description\": \"The exact Lineage Watermark of the agent that authored this state mutation.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"diff_cid\": {"]
#[doc = "      \"title\": \"Diff Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"lamport_timestamp\": {"]
#[doc = "      \"title\": \"Lamport Timestamp\","]
#[doc = "      \"description\": \"Strict scalar logical clock governing distributed ordering.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"terminate_set\": {"]
#[doc = "      \"title\": \"Terminate Set\","]
#[doc = "      \"description\": \"The set of non-monotonic timeline caps.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/TemporalEdgeInvalidationIntent\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for temporal graph crdt.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"temporal_graph_crdt\""]
#[doc = "    },"]
#[doc = "    \"vector_clock\": {"]
#[doc = "      \"title\": \"Vector Clock\","]
#[doc = "      \"description\": \"Causal history mapping of all known Lineage Watermarks.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"integer\","]
#[doc = "        \"minimum\": 0.0"]
#[doc = "      }"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TemporalGraphCrdtManifest {
    #[doc = "The Grow-Only Set (G-Set) of newly transmutated semantic vertices."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub add_set: ::std::vec::Vec<NodeCidState>,
    #[doc = "The exact Lineage Watermark of the agent that authored this state mutation."]
    pub author_node_cid: AuthorNodeCid,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark."]
    pub diff_cid: DiffCid,
    #[doc = "Strict scalar logical clock governing distributed ordering."]
    pub lamport_timestamp: u64,
    #[doc = "The set of non-monotonic timeline caps."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub terminate_set: ::std::vec::Vec<TemporalEdgeInvalidationIntent>,
    #[doc = "Discriminator for temporal graph crdt."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "Causal history mapping of all known Lineage Watermarks."]
    pub vector_clock: ::std::collections::HashMap<::std::string::String, u64>,
}
impl TemporalGraphCrdtManifest {
    pub fn builder() -> builder::TemporalGraphCrdtManifest {
        Default::default()
    }
}
#[doc = "AGENT INSTRUCTION: Mathematically aligns abstract Tensor Calculus with rigid Von Neumann Memory Hierarchy limits and IEEE 754 Floating-Point Arithmetic physics.\n\nCAUSAL AFFORDANCE: Empowers the orchestrator to preemptively calculate exact thermodynamic and spatial memory exhaustion limits (VRAM footprint) prior to authorizing the download or projection of N-dimensional tensor payloads.\n\nEPISTEMIC BOUNDS: The `bytes_per_element` property physically clamps array allocations to rigid hardware byte multiples (e.g., 4 bytes for float32). The literal automaton prevents the execution graph from hallucinating non-standard or unsupported silicon data types.\n\nMCP ROUTING TRIGGERS: IEEE 754, Von Neumann Architecture, Tensor Calculus, GPU VRAM Allocation, Memory Hierarchy"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TensorStructuralFormatProfile\","]
#[doc = "  \"description\": \"AGENT INSTRUCTION: Mathematically aligns abstract Tensor Calculus with rigid Von Neumann Memory Hierarchy limits and IEEE 754 Floating-Point Arithmetic physics.\\n\\nCAUSAL AFFORDANCE: Empowers the orchestrator to preemptively calculate exact thermodynamic and spatial memory exhaustion limits (VRAM footprint) prior to authorizing the download or projection of N-dimensional tensor payloads.\\n\\nEPISTEMIC BOUNDS: The `bytes_per_element` property physically clamps array allocations to rigid hardware byte multiples (e.g., 4 bytes for float32). The literal automaton prevents the execution graph from hallucinating non-standard or unsupported silicon data types.\\n\\nMCP ROUTING TRIGGERS: IEEE 754, Von Neumann Architecture, Tensor Calculus, GPU VRAM Allocation, Memory Hierarchy\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"float32\","]
#[doc = "    \"float64\","]
#[doc = "    \"int8\","]
#[doc = "    \"uint8\","]
#[doc = "    \"int32\","]
#[doc = "    \"int64\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TensorStructuralFormatProfile {
    #[serde(rename = "float32")]
    Float32,
    #[serde(rename = "float64")]
    Float64,
    #[serde(rename = "int8")]
    Int8,
    #[serde(rename = "uint8")]
    Uint8,
    #[serde(rename = "int32")]
    Int32,
    #[serde(rename = "int64")]
    Int64,
}
impl ::std::fmt::Display for TensorStructuralFormatProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Float32 => f.write_str("float32"),
            Self::Float64 => f.write_str("float64"),
            Self::Int8 => f.write_str("int8"),
            Self::Uint8 => f.write_str("uint8"),
            Self::Int32 => f.write_str("int32"),
            Self::Int64 => f.write_str("int64"),
        }
    }
}
impl ::std::str::FromStr for TensorStructuralFormatProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "float32" => Ok(Self::Float32),
            "float64" => Ok(Self::Float64),
            "int8" => Ok(Self::Int8),
            "uint8" => Ok(Self::Uint8),
            "int32" => Ok(Self::Int32),
            "int64" => Ok(Self::Int64),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TensorStructuralFormatProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TensorStructuralFormatProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TensorStructuralFormatProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents the discrete, deterministic crystallization of an ephemeral POSIX/TTY execution buffer into a verifiable Merkle-DAG state vector.\n\nCAUSAL AFFORDANCE: Acts as the structural sensor array for shell interactions, capturing continuous stdout/stderr streams and environment matrices as cryptographically locked exogenous perturbations.\n\nEPISTEMIC BOUNDS: Physically restricted to SHA-256 canonical fingerprints (`stdout_hash`, `stderr_hash`, `env_variables_hash`, all matching `^[a-f0-9]{64}$`) to mathematically prevent VRAM memory exhaustion from unbounded shell logs.\n\nMCP ROUTING TRIGGERS: POSIX Environment, Exogenous Perturbation, TTY Buffer, Causal Actuator, Stream Crystallization"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TerminalBufferState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents the discrete, deterministic crystallization of an ephemeral POSIX/TTY execution buffer into a verifiable Merkle-DAG state vector.\\n\\nCAUSAL AFFORDANCE: Acts as the structural sensor array for shell interactions, capturing continuous stdout/stderr streams and environment matrices as cryptographically locked exogenous perturbations.\\n\\nEPISTEMIC BOUNDS: Physically restricted to SHA-256 canonical fingerprints (`stdout_hash`, `stderr_hash`, `env_variables_hash`, all matching `^[a-f0-9]{64}$`) to mathematically prevent VRAM memory exhaustion from unbounded shell logs.\\n\\nMCP ROUTING TRIGGERS: POSIX Environment, Exogenous Perturbation, TTY Buffer, Causal Actuator, Stream Crystallization\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"env_variables_hash\","]
#[doc = "    \"stderr_hash\","]
#[doc = "    \"stdout_hash\","]
#[doc = "    \"working_directory\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"env_variables_hash\": {"]
#[doc = "      \"title\": \"Env Variables Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the state-space context matrix.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"stderr_hash\": {"]
#[doc = "      \"title\": \"Stderr Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash tracking structural deviation anomalies.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"stdout_hash\": {"]
#[doc = "      \"title\": \"Stdout Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the Exogenous Perturbations captured.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator for Causal Actuators on structural buffers.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"terminal\""]
#[doc = "    },"]
#[doc = "    \"working_directory\": {"]
#[doc = "      \"title\": \"Working Directory\","]
#[doc = "      \"description\": \"Capability Perimeters defining context bounds.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TerminalBufferState {
    #[doc = "The SHA-256 hash of the state-space context matrix."]
    pub env_variables_hash: EnvVariablesHash,
    #[doc = "The SHA-256 hash tracking structural deviation anomalies."]
    pub stderr_hash: StderrHash,
    #[doc = "The SHA-256 hash of the Exogenous Perturbations captured."]
    pub stdout_hash: StdoutHash,
    #[doc = "Discriminator for Causal Actuators on structural buffers."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "Capability Perimeters defining context bounds."]
    pub working_directory: WorkingDirectory,
}
impl TerminalBufferState {
    pub fn builder() -> builder::TerminalBufferState {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A terminal state object generated when the Proposer-Verifier macro-topology exhausts its max_revision_loops without achieving ontological alignment. Packages the failure state for HITL routing.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator to halt the active execution wave and physically route the exact contextual state of failure to a human supervisor for manual evaluation.\n\nEPISTEMIC BOUNDS: The cycle count is mathematically bounded by loops_exhausted (ge=1, le=18446744073709551615). The specific mathematical penalty gradient the proposer failed to resolve is locked via final_critique_schema. The last_rejected_hypothesis_hash is a cryptographically locked string (max_length=64).\n\nMCP ROUTING TRIGGERS: Proposer-Verifier Macro-Topology, Terminal State, Execution Halting, Human-in-the-Loop Routing, Cognitive Failure Packaging"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TerminalCognitiveEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A terminal state object generated when the Proposer-Verifier macro-topology exhausts its max_revision_loops without achieving ontological alignment. Packages the failure state for HITL routing.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator to halt the active execution wave and physically route the exact contextual state of failure to a human supervisor for manual evaluation.\\n\\nEPISTEMIC BOUNDS: The cycle count is mathematically bounded by loops_exhausted (ge=1, le=18446744073709551615). The specific mathematical penalty gradient the proposer failed to resolve is locked via final_critique_schema. The last_rejected_hypothesis_hash is a cryptographically locked string (max_length=64).\\n\\nMCP ROUTING TRIGGERS: Proposer-Verifier Macro-Topology, Terminal State, Execution Halting, Human-in-the-Loop Routing, Cognitive Failure Packaging\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"final_critique_schema\","]
#[doc = "    \"last_rejected_hypothesis_hash\","]
#[doc = "    \"loops_exhausted\","]
#[doc = "    \"source_entity\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"final_critique_schema\": {"]
#[doc = "      \"description\": \"The exact penalty gradient that the Proposer failed to resolve.\","]
#[doc = "      \"$ref\": \"#/$defs/CognitiveCritiqueProfile\""]
#[doc = "    },"]
#[doc = "    \"last_rejected_hypothesis_hash\": {"]
#[doc = "      \"title\": \"Last Rejected Hypothesis Hash\","]
#[doc = "      \"description\": \"A pointer to the final abductive guess generated by the Proposer.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 64"]
#[doc = "    },"]
#[doc = "    \"loops_exhausted\": {"]
#[doc = "      \"title\": \"Loops Exhausted\","]
#[doc = "      \"description\": \"The cycle count at the time of failure.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"source_entity\": {"]
#[doc = "      \"description\": \"The original contextualized input data the system attempted to process.\","]
#[doc = "      \"$ref\": \"#/$defs/ContextualizedSourceState\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TerminalCognitiveEvent {
    #[doc = "The exact penalty gradient that the Proposer failed to resolve."]
    pub final_critique_schema: CognitiveCritiqueProfile,
    #[doc = "A pointer to the final abductive guess generated by the Proposer."]
    pub last_rejected_hypothesis_hash: LastRejectedHypothesisHash,
    #[doc = "The cycle count at the time of failure."]
    pub loops_exhausted: ::std::num::NonZeroU64,
    #[doc = "The original contextualized input data the system attempted to process."]
    pub source_entity: ContextualizedSourceState,
}
impl TerminalCognitiveEvent {
    pub fn builder() -> builder::TerminalCognitiveEvent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Establishes the physical Halting Problem brakes for cyclic loops within the execution topology. As a ...Contract suffix, this object defines rigid mathematical boundaries that the orchestrator must enforce globally.\n\nCAUSAL AFFORDANCE: Instructs the orchestrator's control theory loop to physically halt recursive execution branches if the causal depth exceeds the maximum bound or the decayed budget falls below the minimal required magnitude.\n\nEPISTEMIC BOUNDS: Bounded physically by `max_causal_depth` (ge=1, optional) tracking recursion and `minimum_budget_magnitude` (ge=1, optional) guaranteeing a minimum viable thermodynamic state.\n\nMCP ROUTING TRIGGERS: Halting Problem, Recursion Boundary, Causal Depth, Compute Budget Decay, Structural Circuit Breaker"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TerminalConditionContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Establishes the physical Halting Problem brakes for cyclic loops within the execution topology. As a ...Contract suffix, this object defines rigid mathematical boundaries that the orchestrator must enforce globally.\\n\\nCAUSAL AFFORDANCE: Instructs the orchestrator's control theory loop to physically halt recursive execution branches if the causal depth exceeds the maximum bound or the decayed budget falls below the minimal required magnitude.\\n\\nEPISTEMIC BOUNDS: Bounded physically by `max_causal_depth` (ge=1, optional) tracking recursion and `minimum_budget_magnitude` (ge=1, optional) guaranteeing a minimum viable thermodynamic state.\\n\\nMCP ROUTING TRIGGERS: Halting Problem, Recursion Boundary, Causal Depth, Compute Budget Decay, Structural Circuit Breaker\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"properties\": {"]
#[doc = "    \"max_causal_depth\": {"]
#[doc = "      \"title\": \"Max Causal Depth\","]
#[doc = "      \"description\": \"The absolute limit on TraceContextState.causal_clock.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"minimum\": 1.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"minimum_budget_magnitude\": {"]
#[doc = "      \"title\": \"Minimum Budget Magnitude\","]
#[doc = "      \"description\": \"Halts execution if the decayed compute budget drops below this.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"integer\","]
#[doc = "          \"minimum\": 1.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TerminalConditionContract {
    #[doc = "The absolute limit on TraceContextState.causal_clock."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_causal_depth: ::std::option::Option<::std::num::NonZeroU64>,
    #[doc = "Halts execution if the decayed compute budget drops below this."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub minimum_budget_magnitude: ::std::option::Option<::std::num::NonZeroU64>,
}
impl ::std::default::Default for TerminalConditionContract {
    fn default() -> Self {
        Self {
            max_causal_depth: Default::default(),
            minimum_budget_magnitude: Default::default(),
        }
    }
}
impl TerminalConditionContract {
    pub fn builder() -> builder::TerminalConditionContract {
        Default::default()
    }
}
#[doc = "The raw, atomic natural language representation of the proposition. Volumetrically clamped to prevent VRAM overflow."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Text Chunk\","]
#[doc = "  \"description\": \"The raw, atomic natural language representation of the proposition. Volumetrically clamped to prevent VRAM overflow.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 50000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TextChunk(::std::string::String);
impl ::std::ops::Deref for TextChunk {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TextChunk> for ::std::string::String {
    fn from(value: TextChunk) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TextChunk {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 50000usize {
            return Err("longer than 50000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TextChunk {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TextChunk {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TextChunk {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TextChunk {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The extracted atomic data point within the cell."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Text Payload\","]
#[doc = "  \"description\": \"The extracted atomic data point within the cell.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 10000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TextPayload(::std::string::String);
impl ::std::ops::Deref for TextPayload {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TextPayload> for ::std::string::String {
    fn from(value: TextPayload) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TextPayload {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 10000usize {
            return Err("longer than 10000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TextPayload {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TextPayload {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TextPayload {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TextPayload {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Employs Bayesian Theory of Mind (BToM) and Multi-Agent Epistemic Logic to model the hidden cognitive state and knowledge gaps of foreign agents.\n\nCAUSAL AFFORDANCE: Empowers the orchestrator to dynamically compress and target interpersonal communication by referencing assumed_shared_beliefs to avoid redundant information transfer across the swarm.\n\nEPISTEMIC BOUNDS: The predictive certainty is physically bounded by empathy_confidence_score (ge=0.0, le=1.0). The target_agent_cid is anchored to a 128-char CID. Arrays are deterministically sorted by the @model_validator to preserve cryptographic canonicalization.\n\nMCP ROUTING TRIGGERS: Bayesian Theory of Mind, Epistemic Logic, Cognitive Modeling, Common Knowledge, Multi-Agent Inference"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TheoryOfMindSnapshot\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Employs Bayesian Theory of Mind (BToM) and Multi-Agent Epistemic Logic to model the hidden cognitive state and knowledge gaps of foreign agents.\\n\\nCAUSAL AFFORDANCE: Empowers the orchestrator to dynamically compress and target interpersonal communication by referencing assumed_shared_beliefs to avoid redundant information transfer across the swarm.\\n\\nEPISTEMIC BOUNDS: The predictive certainty is physically bounded by empathy_confidence_score (ge=0.0, le=1.0). The target_agent_cid is anchored to a 128-char CID. Arrays are deterministically sorted by the @model_validator to preserve cryptographic canonicalization.\\n\\nMCP ROUTING TRIGGERS: Bayesian Theory of Mind, Epistemic Logic, Cognitive Modeling, Common Knowledge, Multi-Agent Inference\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"assumed_shared_beliefs\","]
#[doc = "    \"empathy_confidence_score\","]
#[doc = "    \"identified_knowledge_gaps\","]
#[doc = "    \"target_agent_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"assumed_shared_beliefs\": {"]
#[doc = "      \"title\": \"Assumed Shared Beliefs\","]
#[doc = "      \"description\": \"The explicit array of Content Identifiers (CIDs) acting as cryptographic Lineage Watermarks that the modeling agent assumes the target already possesses.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 128,"]
#[doc = "        \"minLength\": 1"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"empathy_confidence_score\": {"]
#[doc = "      \"title\": \"Empathy Confidence Score\","]
#[doc = "      \"description\": \"The mathematical confidence (0.0 to 1.0) the agent has in its model of the target's mind.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"identified_knowledge_gaps\": {"]
#[doc = "      \"title\": \"Identified Knowledge Gaps\","]
#[doc = "      \"description\": \"Specific topics or logical premises the target agent is assumed to be missing.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 2000"]
#[doc = "      },"]
#[doc = "      \"maxItems\": 1000"]
#[doc = "    },"]
#[doc = "    \"target_agent_cid\": {"]
#[doc = "      \"title\": \"Target Agent Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the agent whose mind is being modeled.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TheoryOfMindSnapshot {
    #[doc = "The explicit array of Content Identifiers (CIDs) acting as cryptographic Lineage Watermarks that the modeling agent assumes the target already possesses."]
    pub assumed_shared_beliefs: ::std::vec::Vec<AssumedSharedBeliefsItem>,
    #[doc = "The mathematical confidence (0.0 to 1.0) the agent has in its model of the target's mind."]
    pub empathy_confidence_score: f64,
    #[doc = "Specific topics or logical premises the target agent is assumed to be missing."]
    pub identified_knowledge_gaps: ::std::vec::Vec<IdentifiedKnowledgeGapsItem>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the agent whose mind is being modeled."]
    pub target_agent_cid: TargetAgentCid,
}
impl TheoryOfMindSnapshot {
    pub fn builder() -> builder::TheoryOfMindSnapshot {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A declarative, frozen snapshot of a discrete Markov Decision Process\n(MDP) state representing a single coordinate within a non-monotonic reasoning tree. As\na ...State suffix, this is a frozen N-dimensional coordinate.\n\nCAUSAL AFFORDANCE: Tracks a localized reasoning trajectory, enabling the orchestrator's\nProcess Reward Model (PRM) to score the branch and dictate if the traversal should\nrecursively backtrack or continue. Tree reconstruction is enabled via the optional\nparent_branch_cid.\n\nEPISTEMIC BOUNDS: The mathematical validity of the branch is continuously clamped by\nprm_score (optional, ge=0.0, le=1.0, default=None). The node is cryptographically\nanchored to the execution tree via latent_content_hash (strict SHA-256 pattern\n^[a-f0-9]{64}$). The branch_cid is locked to a 128-char CID.\n\nMCP ROUTING TRIGGERS: Markov Decision Process, Process Reward Model, Reasoning Node,\nHeuristic Search, Backtracking"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ThoughtBranchState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A declarative, frozen snapshot of a discrete Markov Decision Process\\n(MDP) state representing a single coordinate within a non-monotonic reasoning tree. As\\na ...State suffix, this is a frozen N-dimensional coordinate.\\n\\nCAUSAL AFFORDANCE: Tracks a localized reasoning trajectory, enabling the orchestrator's\\nProcess Reward Model (PRM) to score the branch and dictate if the traversal should\\nrecursively backtrack or continue. Tree reconstruction is enabled via the optional\\nparent_branch_cid.\\n\\nEPISTEMIC BOUNDS: The mathematical validity of the branch is continuously clamped by\\nprm_score (optional, ge=0.0, le=1.0, default=None). The node is cryptographically\\nanchored to the execution tree via latent_content_hash (strict SHA-256 pattern\\n^[a-f0-9]{64}$). The branch_cid is locked to a 128-char CID.\\n\\nMCP ROUTING TRIGGERS: Markov Decision Process, Process Reward Model, Reasoning Node,\\nHeuristic Search, Backtracking\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"branch_cid\","]
#[doc = "    \"latent_content_hash\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"branch_cid\": {"]
#[doc = "      \"title\": \"Branch Cid\","]
#[doc = "      \"description\": \"A deterministic capability pointer bounding this specific topological divergence in the Latent Scratchpad Trace.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"latent_content_hash\": {"]
#[doc = "      \"title\": \"Latent Content Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the raw latent dimensions explored in this branch.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"parent_branch_cid\": {"]
#[doc = "      \"title\": \"Parent Branch Cid\","]
#[doc = "      \"description\": \"The branch this thought diverged from, enabling tree reconstruction.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"prm_score\": {"]
#[doc = "      \"title\": \"Prm Score\","]
#[doc = "      \"description\": \"The logical validity score assigned to this branch by the Process Reward Model.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 1.0,"]
#[doc = "          \"minimum\": 0.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"thought_branch\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ThoughtBranchState {
    #[doc = "A deterministic capability pointer bounding this specific topological divergence in the Latent Scratchpad Trace."]
    pub branch_cid: BranchCid,
    #[doc = "The SHA-256 hash of the raw latent dimensions explored in this branch."]
    pub latent_content_hash: LatentContentHash,
    #[doc = "The branch this thought diverged from, enabling tree reconstruction."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub parent_branch_cid: ::std::option::Option<::std::string::String>,
    #[doc = "The logical validity score assigned to this branch by the Process Reward Model."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prm_score: ::std::option::Option<f64>,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl ThoughtBranchState {
    pub fn builder() -> builder::ThoughtBranchState {
        Default::default()
    }
}
#[doc = "`TieBreakerPolicy`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"lowest_cost\","]
#[doc = "    \"lowest_latency\","]
#[doc = "    \"highest_confidence\","]
#[doc = "    \"random\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TieBreakerPolicy {
    #[serde(rename = "lowest_cost")]
    LowestCost,
    #[serde(rename = "lowest_latency")]
    LowestLatency,
    #[serde(rename = "highest_confidence")]
    HighestConfidence,
    #[serde(rename = "random")]
    Random,
}
impl ::std::fmt::Display for TieBreakerPolicy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::LowestCost => f.write_str("lowest_cost"),
            Self::LowestLatency => f.write_str("lowest_latency"),
            Self::HighestConfidence => f.write_str("highest_confidence"),
            Self::Random => f.write_str("random"),
        }
    }
}
impl ::std::str::FromStr for TieBreakerPolicy {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "lowest_cost" => Ok(Self::LowestCost),
            "lowest_latency" => Ok(Self::LowestLatency),
            "highest_confidence" => Ok(Self::HighestConfidence),
            "random" => Ok(Self::Random),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TieBreakerPolicy {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TieBreakerPolicy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TieBreakerPolicy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The formal algebraic Big-O notation mathematically bounding temporal execution limits (e.g., 'O(N)', 'O(V + E)', 'O(N^2)')."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Time Complexity Class\","]
#[doc = "  \"description\": \"The formal algebraic Big-O notation mathematically bounding temporal execution limits (e.g., 'O(N)', 'O(V + E)', 'O(N^2)').\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255,"]
#[doc = "  \"pattern\": \"^O\\\\([a-zA-Z0-9_+\\\\^ \\\\-\\\\*]+\\\\)$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TimeComplexityClass(::std::string::String);
impl ::std::ops::Deref for TimeComplexityClass {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TimeComplexityClass> for ::std::string::String {
    fn from(value: TimeComplexityClass) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TimeComplexityClass {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| {
                ::regress::Regex::new("^O\\([a-zA-Z0-9_+\\^ \\-\\*]+\\)$").unwrap()
            });
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^O\\([a-zA-Z0-9_+\\^ \\-\\*]+\\)$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TimeComplexityClass {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TimeComplexityClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TimeComplexityClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TimeComplexityClass {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The action to take if the oracle is unresponsive."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Timeout Action\","]
#[doc = "  \"description\": \"The action to take if the oracle is unresponsive.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"rollback\","]
#[doc = "    \"proceed_default\","]
#[doc = "    \"terminate\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TimeoutAction {
    #[serde(rename = "rollback")]
    Rollback,
    #[serde(rename = "proceed_default")]
    ProceedDefault,
    #[serde(rename = "terminate")]
    Terminate,
}
impl ::std::fmt::Display for TimeoutAction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Rollback => f.write_str("rollback"),
            Self::ProceedDefault => f.write_str("proceed_default"),
            Self::Terminate => f.write_str("terminate"),
        }
    }
}
impl ::std::str::FromStr for TimeoutAction {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "rollback" => Ok(Self::Rollback),
            "proceed_default" => Ok(Self::ProceedDefault),
            "terminate" => Ok(Self::Terminate),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TimeoutAction {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TimeoutAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TimeoutAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The declarative semantic anchor summarizing the underlying visual grammar."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Title\","]
#[doc = "  \"description\": \"The declarative semantic anchor summarizing the underlying visual grammar.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct Title(::std::string::String);
impl ::std::ops::Deref for Title {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<Title> for ::std::string::String {
    fn from(value: Title) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for Title {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for Title {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for Title {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for Title {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for Title {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`TokenBufferItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 10000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TokenBufferItem(::std::string::String);
impl ::std::ops::Deref for TokenBufferItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TokenBufferItem> for ::std::string::String {
    fn from(value: TokenBufferItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TokenBufferItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 10000usize {
            return Err("longer than 10000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TokenBufferItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TokenBufferItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TokenBufferItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TokenBufferItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Landauer's Principle of thermodynamic computing within the neurosymbolic network, serving as a lock-free, cryptographically frozen record of irreversible token and energy expenditure.\n\nCAUSAL AFFORDANCE: Deducts exact computational magnitude from the agent's localized Proof-of-Stake (PoS) execution escrow, progressively narrowing its available search depth. Bound to causal origin via `tool_invocation_cid`.\n\nEPISTEMIC BOUNDS: Integer bounds (`ge=0, le=18446744073709551615`) on `input_tokens`, `output_tokens`, and `burn_magnitude` mathematically prevent integer overflow and fractional bypasses during ledger tallying.\n\nMCP ROUTING TRIGGERS: Landauer's Principle, Thermodynamic Compute, Token Burn, Resource Exhaustion, Lock-Free Tallying"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TokenBurnReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Landauer's Principle of thermodynamic computing within the neurosymbolic network, serving as a lock-free, cryptographically frozen record of irreversible token and energy expenditure.\\n\\nCAUSAL AFFORDANCE: Deducts exact computational magnitude from the agent's localized Proof-of-Stake (PoS) execution escrow, progressively narrowing its available search depth. Bound to causal origin via `tool_invocation_cid`.\\n\\nEPISTEMIC BOUNDS: Integer bounds (`ge=0, le=18446744073709551615`) on `input_tokens`, `output_tokens`, and `burn_magnitude` mathematically prevent integer overflow and fractional bypasses during ledger tallying.\\n\\nMCP ROUTING TRIGGERS: Landauer's Principle, Thermodynamic Compute, Token Burn, Resource Exhaustion, Lock-Free Tallying\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"burn_magnitude\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"input_tokens\","]
#[doc = "    \"output_tokens\","]
#[doc = "    \"timestamp\","]
#[doc = "    \"tool_invocation_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"burn_magnitude\": {"]
#[doc = "      \"title\": \"Burn Magnitude\","]
#[doc = "      \"description\": \"The normalized economic cost magnitude representing thermodynamic burn.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"input_tokens\": {"]
#[doc = "      \"title\": \"Input Tokens\","]
#[doc = "      \"description\": \"The mathematical measure of input tokens consumed.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"output_tokens\": {"]
#[doc = "      \"title\": \"Output Tokens\","]
#[doc = "      \"description\": \"The mathematical measure of output tokens generated.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"tool_invocation_cid\": {"]
#[doc = "      \"title\": \"Tool Invocation Cid\","]
#[doc = "      \"description\": \"A string linking this burn back to the specific ToolInvocationEvent CID.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for a token burn receipt.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"token_burn\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TokenBurnReceipt {
    #[doc = "The normalized economic cost magnitude representing thermodynamic burn."]
    pub burn_magnitude: u64,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The mathematical measure of input tokens consumed."]
    pub input_tokens: u64,
    #[doc = "The mathematical measure of output tokens generated."]
    pub output_tokens: u64,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "A string linking this burn back to the specific ToolInvocationEvent CID."]
    pub tool_invocation_cid: ToolInvocationCid,
    #[doc = "Discriminator type for a token burn receipt."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl TokenBurnReceipt {
    pub fn builder() -> builder::TokenBurnReceipt {
        Default::default()
    }
}
#[doc = "A string linking this burn back to the specific ToolInvocationEvent CID."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Tool Invocation Cid\","]
#[doc = "  \"description\": \"A string linking this burn back to the specific ToolInvocationEvent CID.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ToolInvocationCid(::std::string::String);
impl ::std::ops::Deref for ToolInvocationCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ToolInvocationCid> for ::std::string::String {
    fn from(value: ToolInvocationCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ToolInvocationCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ToolInvocationCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ToolInvocationCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ToolInvocationCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ToolInvocationCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Judea Pearl's Do-Operator ($do(X=x)$) on an external or internal toolset, acting as an A Priori Kinetic Commitment.\n\nCAUSAL AFFORDANCE: Transitions the swarm from internal epistemic deliberation to kinetic execution. Targets a specific `tool_name` with bound parameters, demanding a valid `agent_attestation` identity.\n\nEPISTEMIC BOUNDS: `parameters` payload is volumetrically capped by `enforce_payload_topology`. To prevent infinite compute loops, `authorized_budget_magnitude` is mandated `ge=1`. `zk_proof` serves as mathematical authorization proof.\n\nMCP ROUTING TRIGGERS: Pearlian Do-Operator, Kinetic Commitment, Active Inference, Thermodynamic Escrow, Zero-Trust Actuation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ToolInvocationEvent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Judea Pearl's Do-Operator ($do(X=x)$) on an external or internal toolset, acting as an A Priori Kinetic Commitment.\\n\\nCAUSAL AFFORDANCE: Transitions the swarm from internal epistemic deliberation to kinetic execution. Targets a specific `tool_name` with bound parameters, demanding a valid `agent_attestation` identity.\\n\\nEPISTEMIC BOUNDS: `parameters` payload is volumetrically capped by `enforce_payload_topology`. To prevent infinite compute loops, `authorized_budget_magnitude` is mandated `ge=1`. `zk_proof` serves as mathematical authorization proof.\\n\\nMCP ROUTING TRIGGERS: Pearlian Do-Operator, Kinetic Commitment, Active Inference, Thermodynamic Escrow, Zero-Trust Actuation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"agent_attestation\","]
#[doc = "    \"authorized_budget_magnitude\","]
#[doc = "    \"event_cid\","]
#[doc = "    \"parameters\","]
#[doc = "    \"timestamp\","]
#[doc = "    \"tool_name\","]
#[doc = "    \"zk_proof\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"agent_attestation\": {"]
#[doc = "      \"description\": \"The cryptographic identity anchoring the agent to the execution environment.\","]
#[doc = "      \"$ref\": \"#/$defs/AgentAttestationReceipt\""]
#[doc = "    },"]
#[doc = "    \"authorized_budget_magnitude\": {"]
#[doc = "      \"title\": \"Authorized Budget Magnitude\","]
#[doc = "      \"description\": \"The mandatory discrete thermodynamic token cost reserved for this specific run.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    },"]
#[doc = "    \"event_cid\": {"]
#[doc = "      \"title\": \"Event Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"parameters\": {"]
#[doc = "      \"title\": \"Parameters\","]
#[doc = "      \"description\": \"The intended JSON-RPC payload. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"prior_event_hash\": {"]
#[doc = "      \"title\": \"Prior Event Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"timestamp\": {"]
#[doc = "      \"title\": \"Timestamp\","]
#[doc = "      \"description\": \"Causal Ancestry markers required to resolve decentralized event ordering.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 253402300799.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"tool_name\": {"]
#[doc = "      \"title\": \"Tool Name\","]
#[doc = "      \"description\": \"The exact tool targeted in the CognitiveActionSpaceManifest.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for a tool invocation event.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"tool_invocation\""]
#[doc = "    },"]
#[doc = "    \"zk_proof\": {"]
#[doc = "      \"description\": \"The mathematical attestation proving this tool execution was securely authorized.\","]
#[doc = "      \"$ref\": \"#/$defs/ZeroKnowledgeReceipt\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ToolInvocationEvent {
    #[doc = "The cryptographic identity anchoring the agent to the execution environment."]
    pub agent_attestation: AgentAttestationReceipt,
    #[doc = "The mandatory discrete thermodynamic token cost reserved for this specific run."]
    pub authorized_budget_magnitude: ::std::num::NonZeroU64,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the Merkle-DAG."]
    pub event_cid: EventCid,
    #[doc = "The intended JSON-RPC payload. AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    pub parameters: ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "The SHA-256 hash of the temporally preceding event, establishing the Merkle-DAG chain."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub prior_event_hash: ::std::option::Option<::std::string::String>,
    #[doc = "Causal Ancestry markers required to resolve decentralized event ordering."]
    pub timestamp: f64,
    #[doc = "The exact tool targeted in the CognitiveActionSpaceManifest."]
    pub tool_name: ToolName,
    #[doc = "Discriminator type for a tool invocation event."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
    #[doc = "The mathematical attestation proving this tool execution was securely authorized."]
    pub zk_proof: ZeroKnowledgeReceipt,
}
impl ToolInvocationEvent {
    pub fn builder() -> builder::ToolInvocationEvent {
        Default::default()
    }
}
#[doc = "The deterministically bounded structural identifier mapping this capability within the zero-trust manifold."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Tool Name\","]
#[doc = "  \"description\": \"The deterministically bounded structural identifier mapping this capability within the zero-trust manifold.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ToolName(::std::string::String);
impl ::std::ops::Deref for ToolName {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ToolName> for ::std::string::String {
    fn from(value: ToolName) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ToolName {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ToolName {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ToolName {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ToolName {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ToolName {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Mathematically computes and stores the pre-inference structural density calculations of the context.\n\n    CAUSAL AFFORDANCE: Exposes the exact physical fidelity of a data block, permitting the orchestrator to dynamically drop packets that fall below algorithmic probability thresholds.\n\n    EPISTEMIC BOUNDS: Contextual completeness is geometrically restricted to a continuous float bounding the probability space [0.0, 1.0]. Surrounding token limits are clamped at absolute integers >= 0.\n\n    MCP ROUTING TRIGGERS: Data Fidelity, Density Calculation, Probability Space, Pre-Inference Validation, Completeness Score"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TopologicalFidelityReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Mathematically computes and stores the pre-inference structural density calculations of the context.\\n\\n    CAUSAL AFFORDANCE: Exposes the exact physical fidelity of a data block, permitting the orchestrator to dynamically drop packets that fall below algorithmic probability thresholds.\\n\\n    EPISTEMIC BOUNDS: Contextual completeness is geometrically restricted to a continuous float bounding the probability space [0.0, 1.0]. Surrounding token limits are clamped at absolute integers >= 0.\\n\\n    MCP ROUTING TRIGGERS: Data Fidelity, Density Calculation, Probability Space, Pre-Inference Validation, Completeness Score\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"contextual_completeness_score\","]
#[doc = "    \"surrounding_token_density\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"contextual_completeness_score\": {"]
#[doc = "      \"title\": \"Contextual Completeness Score\","]
#[doc = "      \"description\": \"The continuous normalized float measuring the mathematical density of the contextual semantic envelope.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"surrounding_token_density\": {"]
#[doc = "      \"title\": \"Surrounding Token Density\","]
#[doc = "      \"description\": \"The absolute integer boundary tracking valid structural tokens mathematically bounding the contextual_envelope.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TopologicalFidelityReceipt {
    #[doc = "The continuous normalized float measuring the mathematical density of the contextual semantic envelope."]
    pub contextual_completeness_score: f64,
    #[doc = "The absolute integer boundary tracking valid structural tokens mathematically bounding the contextual_envelope."]
    pub surrounding_token_density: u64,
}
impl TopologicalFidelityReceipt {
    pub fn builder() -> builder::TopologicalFidelityReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: The transitional mathematical contract that calculates the Gromov-Wasserstein distance and authorizes or denies the collapse of a stochastic manifold into a deterministic structure.\n\nCAUSAL AFFORDANCE: Calculates optimal transport mapping and either authorizes downstream kinetic execution or rejects the transition due to topology tears.\n\nEPISTEMIC BOUNDS: Enforces a strict isomorphism confidence interval [0.0, 1.0], acting as a hardware-level guillotine that mandates a minimum 0.85 threshold.\n\nMCP ROUTING TRIGGERS: Gromov-Wasserstein Distance, Topological Compiler, Optimal Transport Mapping, Manifold Collapse, Deterministic Projection"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TopologicalProjectionIntent\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: The transitional mathematical contract that calculates the Gromov-Wasserstein distance and authorizes or denies the collapse of a stochastic manifold into a deterministic structure.\\n\\nCAUSAL AFFORDANCE: Calculates optimal transport mapping and either authorizes downstream kinetic execution or rejects the transition due to topology tears.\\n\\nEPISTEMIC BOUNDS: Enforces a strict isomorphism confidence interval [0.0, 1.0], acting as a hardware-level guillotine that mandates a minimum 0.85 threshold.\\n\\nMCP ROUTING TRIGGERS: Gromov-Wasserstein Distance, Topological Compiler, Optimal Transport Mapping, Manifold Collapse, Deterministic Projection\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"isomorphism_confidence\","]
#[doc = "    \"lossy_translation_divergence\","]
#[doc = "    \"projection_cid\","]
#[doc = "    \"source_superposition_cid\","]
#[doc = "    \"target_topology\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"epistemic_status\": {"]
#[doc = "      \"title\": \"Epistemic Status\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"pending_deterministic_collapse\""]
#[doc = "    },"]
#[doc = "    \"isomorphism_confidence\": {"]
#[doc = "      \"title\": \"Isomorphism Confidence\","]
#[doc = "      \"type\": \"number\""]
#[doc = "    },"]
#[doc = "    \"lossy_translation_divergence\": {"]
#[doc = "      \"title\": \"Lossy Translation Divergence\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 100000"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"projection_cid\": {"]
#[doc = "      \"title\": \"Projection Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"provenance_trace_cid\": {"]
#[doc = "      \"title\": \"Provenance Trace Cid\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"source_superposition_cid\": {"]
#[doc = "      \"title\": \"Source Superposition Cid\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"target_topology\": {"]
#[doc = "      \"$ref\": \"#/$defs/TargetTopologyProfile\""]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"topological_projection\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TopologicalProjectionIntent {
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub epistemic_status: ::std::option::Option<::std::string::String>,
    pub isomorphism_confidence: f64,
    pub lossy_translation_divergence: ::std::vec::Vec<LossyTranslationDivergenceItem>,
    pub projection_cid: ProjectionCid,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub provenance_trace_cid: ::std::option::Option<::std::string::String>,
    pub source_superposition_cid: SourceSuperpositionCid,
    pub target_topology: TargetTopologyProfile,
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl TopologicalProjectionIntent {
    pub fn builder() -> builder::TopologicalProjectionIntent {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the rigid traversal perimeters for Graph Convolutional Network\n(GCN) or Random Walk with Restart (RWR) operations across the Causal DAG. As a ...Contract\nsuffix, this object defines rigid mathematical boundaries that the orchestrator must\nenforce globally.\n\nCAUSAL AFFORDANCE: Restricts graph hopping algorithms to explicit Pearlian edge types\n(Literal[\"causes\", \"confounds\", \"correlates_with\", \"undirected\"]), mathematically\npreventing epistemic drift and hallucination during deep multi-hop retrieval.\n\nEPISTEMIC BOUNDS: Bounded recursively by max_hop_depth (ge=1, le=18446744073709551615). The\n@model_validator physically enforces deterministic sorting of\nallowed_causal_relationships (min_length=1) to guarantee RFC 8785 canonical hashing.\nGeometric distance preservation is toggled via enforce_isometry (default=True).\n\nMCP ROUTING TRIGGERS: Directed Acyclic Graph, Pearlian Traversal, Isometry Preservation,\nRandom Walk with Restart"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TopologicalRetrievalContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the rigid traversal perimeters for Graph Convolutional Network\\n(GCN) or Random Walk with Restart (RWR) operations across the Causal DAG. As a ...Contract\\nsuffix, this object defines rigid mathematical boundaries that the orchestrator must\\nenforce globally.\\n\\nCAUSAL AFFORDANCE: Restricts graph hopping algorithms to explicit Pearlian edge types\\n(Literal[\\\"causes\\\", \\\"confounds\\\", \\\"correlates_with\\\", \\\"undirected\\\"]), mathematically\\npreventing epistemic drift and hallucination during deep multi-hop retrieval.\\n\\nEPISTEMIC BOUNDS: Bounded recursively by max_hop_depth (ge=1, le=18446744073709551615). The\\n@model_validator physically enforces deterministic sorting of\\nallowed_causal_relationships (min_length=1) to guarantee RFC 8785 canonical hashing.\\nGeometric distance preservation is toggled via enforce_isometry (default=True).\\n\\nMCP ROUTING TRIGGERS: Directed Acyclic Graph, Pearlian Traversal, Isometry Preservation,\\nRandom Walk with Restart\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"allowed_causal_relationships\","]
#[doc = "    \"max_hop_depth\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"allowed_causal_relationships\": {"]
#[doc = "      \"title\": \"Allowed Causal Relationships\","]
#[doc = "      \"description\": \"The explicit whitelist of permissible causal edges to traverse.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"enum\": ["]
#[doc = "          \"causes\","]
#[doc = "          \"confounds\","]
#[doc = "          \"correlates_with\","]
#[doc = "          \"undirected\""]
#[doc = "        ]"]
#[doc = "      },"]
#[doc = "      \"minItems\": 1"]
#[doc = "    },"]
#[doc = "    \"enforce_isometry\": {"]
#[doc = "      \"title\": \"Enforce Isometry\","]
#[doc = "      \"description\": \"Enforces preservation of geometric distances.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"max_hop_depth\": {"]
#[doc = "      \"title\": \"Max Hop Depth\","]
#[doc = "      \"description\": \"The strictly typed search depth bound for the cDAG.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TopologicalRetrievalContract {
    #[doc = "The explicit whitelist of permissible causal edges to traverse."]
    pub allowed_causal_relationships: ::std::vec::Vec<AllowedCausalRelationshipsItem>,
    #[doc = "Enforces preservation of geometric distances."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub enforce_isometry: ::std::option::Option<bool>,
    #[doc = "The strictly typed search depth bound for the cDAG."]
    pub max_hop_depth: ::std::num::NonZeroU64,
}
impl TopologicalRetrievalContract {
    pub fn builder() -> builder::TopologicalRetrievalContract {
        Default::default()
    }
}
#[doc = "`TopologyCid`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Topology Cid\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TopologyCid(::std::string::String);
impl ::std::ops::Deref for TopologyCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TopologyCid> for ::std::string::String {
    fn from(value: TopologyCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TopologyCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TopologyCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TopologyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TopologyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TopologyCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The strictly typed mathematical mapping function distorting metrics into Euclidean pixel space."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Topology Class\","]
#[doc = "  \"description\": \"The strictly typed mathematical mapping function distorting metrics into Euclidean pixel space.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"linear\","]
#[doc = "    \"log\","]
#[doc = "    \"time\","]
#[doc = "    \"ordinal\","]
#[doc = "    \"nominal\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TopologyClass {
    #[serde(rename = "linear")]
    Linear,
    #[serde(rename = "log")]
    Log,
    #[serde(rename = "time")]
    Time,
    #[serde(rename = "ordinal")]
    Ordinal,
    #[serde(rename = "nominal")]
    Nominal,
}
impl ::std::fmt::Display for TopologyClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Linear => f.write_str("linear"),
            Self::Log => f.write_str("log"),
            Self::Time => f.write_str("time"),
            Self::Ordinal => f.write_str("ordinal"),
            Self::Nominal => f.write_str("nominal"),
        }
    }
}
impl ::std::str::FromStr for TopologyClass {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "linear" => Ok(Self::Linear),
            "log" => Ok(Self::Log),
            "time" => Ok(Self::Time),
            "ordinal" => Ok(Self::Ordinal),
            "nominal" => Ok(Self::Nominal),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TopologyClass {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TopologyClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TopologyClass {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "A strictly typed SHA-256 hash pointing to a historically executed topological state."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"description\": \"A strictly typed SHA-256 hash pointing to a historically executed topological state.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TopologyHashReceipt(::std::string::String);
impl ::std::ops::Deref for TopologyHashReceipt {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TopologyHashReceipt> for ::std::string::String {
    fn from(value: TopologyHashReceipt) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TopologyHashReceipt {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TopologyHashReceipt {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TopologyHashReceipt {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TopologyHashReceipt {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TopologyHashReceipt {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The globally unique decentralized identifier (DID) anchoring this specific non-monotonic reasoning trace."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Trace Cid\","]
#[doc = "  \"description\": \"The globally unique decentralized identifier (DID) anchoring this specific non-monotonic reasoning trace.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TraceCid(::std::string::String);
impl ::std::ops::Deref for TraceCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TraceCid> for ::std::string::String {
    fn from(value: TraceCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TraceCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TraceCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TraceCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TraceCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TraceCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Distributed Causality using Vector Clocks and rho-calculus. It forms the foundational causality boundary.\n\n    CAUSAL AFFORDANCE: Acts as a Causal Graph Identifier, ensuring deterministic traceability and state boundary enforcement without relying on hidden states.\n\n    EPISTEMIC BOUNDS: Relies on ULID or UUIDv7 string identifiers for strict topological ordering, bounded by 26-36 chars. Causal clocks enforce ge=0 budget decay boundaries.\n\n    MCP ROUTING TRIGGERS: Distributed Causality, Vector Clocks, Trace Context, Topological Ordering, Causal Graph"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TraceContextState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Distributed Causality using Vector Clocks and rho-calculus. It forms the foundational causality boundary.\\n\\n    CAUSAL AFFORDANCE: Acts as a Causal Graph Identifier, ensuring deterministic traceability and state boundary enforcement without relying on hidden states.\\n\\n    EPISTEMIC BOUNDS: Relies on ULID or UUIDv7 string identifiers for strict topological ordering, bounded by 26-36 chars. Causal clocks enforce ge=0 budget decay boundaries.\\n\\n    MCP ROUTING TRIGGERS: Distributed Causality, Vector Clocks, Trace Context, Topological Ordering, Causal Graph\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"span_cid\","]
#[doc = "    \"trace_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"causal_clock\": {"]
#[doc = "      \"title\": \"Causal Clock\","]
#[doc = "      \"description\": \"Tracks the recursion depth/vector clock required for compute budget decay.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"parent_span_cid\": {"]
#[doc = "      \"title\": \"Parent Span Cid\","]
#[doc = "      \"description\": \"The span_cid of the caller. If null, this node is the mathematically proven root.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"span_cid\": {"]
#[doc = "      \"title\": \"Span Cid\","]
#[doc = "      \"description\": \"Unique identifier for the specific execution of this actionSpaceCId. Must be a ULID or UUIDv7.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 36,"]
#[doc = "      \"minLength\": 26,"]
#[doc = "      \"pattern\": \"^[0-9A-HJKMNP-TV-Z]{26}$|^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$\""]
#[doc = "    },"]
#[doc = "    \"trace_cid\": {"]
#[doc = "      \"title\": \"Trace Cid\","]
#[doc = "      \"description\": \"Globally unique ID generated once at the root user prompt. Must be a ULID or UUIDv7.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 36,"]
#[doc = "      \"minLength\": 26,"]
#[doc = "      \"pattern\": \"^[0-9A-HJKMNP-TV-Z]{26}$|^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TraceContextState {
    #[doc = "Tracks the recursion depth/vector clock required for compute budget decay."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub causal_clock: ::std::option::Option<u64>,
    #[doc = "The span_cid of the caller. If null, this node is the mathematically proven root."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub parent_span_cid: ::std::option::Option<::std::string::String>,
    #[doc = "Unique identifier for the specific execution of this actionSpaceCId. Must be a ULID or UUIDv7."]
    pub span_cid: SpanCid,
    #[doc = "Globally unique ID generated once at the root user prompt. Must be a ULID or UUIDv7."]
    pub trace_cid: TraceCid,
}
impl TraceContextState {
    pub fn builder() -> builder::TraceContextState {
        Default::default()
    }
}
#[doc = "The natural language reasoning steps bounded by structural tags."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Trace Payload\","]
#[doc = "  \"description\": \"The natural language reasoning steps bounded by structural tags.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TracePayload(::std::string::String);
impl ::std::ops::Deref for TracePayload {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TracePayload> for ::std::string::String {
    fn from(value: TracePayload) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TracePayload {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TracePayload {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TracePayload {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TracePayload {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TracePayload {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The mathematical optimization vector to break ties within the frontier."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Tradeoff Preference\","]
#[doc = "  \"description\": \"The mathematical optimization vector to break ties within the frontier.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"latency_optimized\","]
#[doc = "    \"cost_optimized\","]
#[doc = "    \"capability_optimized\","]
#[doc = "    \"carbon_optimized\","]
#[doc = "    \"balanced\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TradeoffPreference {
    #[serde(rename = "latency_optimized")]
    LatencyOptimized,
    #[serde(rename = "cost_optimized")]
    CostOptimized,
    #[serde(rename = "capability_optimized")]
    CapabilityOptimized,
    #[serde(rename = "carbon_optimized")]
    CarbonOptimized,
    #[serde(rename = "balanced")]
    Balanced,
}
impl ::std::fmt::Display for TradeoffPreference {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::LatencyOptimized => f.write_str("latency_optimized"),
            Self::CostOptimized => f.write_str("cost_optimized"),
            Self::CapabilityOptimized => f.write_str("capability_optimized"),
            Self::CarbonOptimized => f.write_str("carbon_optimized"),
            Self::Balanced => f.write_str("balanced"),
        }
    }
}
impl ::std::str::FromStr for TradeoffPreference {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "latency_optimized" => Ok(Self::LatencyOptimized),
            "cost_optimized" => Ok(Self::CostOptimized),
            "capability_optimized" => Ok(Self::CapabilityOptimized),
            "carbon_optimized" => Ok(Self::CarbonOptimized),
            "balanced" => Ok(Self::Balanced),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TradeoffPreference {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TradeoffPreference {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TradeoffPreference {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The exact SHA-256 Merkle root of the agent's training lineage."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Training Lineage Hash\","]
#[doc = "  \"description\": \"The exact SHA-256 Merkle root of the agent's training lineage.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TrainingLineageHash(::std::string::String);
impl ::std::ops::Deref for TrainingLineageHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TrainingLineageHash> for ::std::string::String {
    fn from(value: TrainingLineageHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TrainingLineageHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TrainingLineageHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TrainingLineageHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TrainingLineageHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TrainingLineageHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "AGENT INSTRUCTION: Dictates the exact algorithmic or logical mechanism utilized to forge a semantic connection or transmute a bimodal data state, allowing downstream agents to weigh epistemic reliability."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TransformationMechanismProfile\","]
#[doc = "  \"description\": \"AGENT INSTRUCTION: Dictates the exact algorithmic or logical mechanism utilized to forge a semantic connection or transmute a bimodal data state, allowing downstream agents to weigh epistemic reliability.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"lexical_crosswalk\","]
#[doc = "    \"contextual_transformer_inference\","]
#[doc = "    \"rhetorical_extraction\","]
#[doc = "    \"abductive_inference\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TransformationMechanismProfile {
    #[serde(rename = "lexical_crosswalk")]
    LexicalCrosswalk,
    #[serde(rename = "contextual_transformer_inference")]
    ContextualTransformerInference,
    #[serde(rename = "rhetorical_extraction")]
    RhetoricalExtraction,
    #[serde(rename = "abductive_inference")]
    AbductiveInference,
}
impl ::std::fmt::Display for TransformationMechanismProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::LexicalCrosswalk => f.write_str("lexical_crosswalk"),
            Self::ContextualTransformerInference => f.write_str("contextual_transformer_inference"),
            Self::RhetoricalExtraction => f.write_str("rhetorical_extraction"),
            Self::AbductiveInference => f.write_str("abductive_inference"),
        }
    }
}
impl ::std::str::FromStr for TransformationMechanismProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "lexical_crosswalk" => Ok(Self::LexicalCrosswalk),
            "contextual_transformer_inference" => Ok(Self::ContextualTransformerInference),
            "rhetorical_extraction" => Ok(Self::RhetoricalExtraction),
            "abductive_inference" => Ok(Self::AbductiveInference),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TransformationMechanismProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TransformationMechanismProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TransformationMechanismProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents a directed acyclic Markov edge for traversing the Action Space topology. As a ...Profile suffix, this is a declarative, frozen snapshot of a routing geometry.\n\nCAUSAL AFFORDANCE: Unlocks stochastic pathfinding and graph traversal by projecting a probabilistic weight and thermodynamic cost required to advance to the next state node in the DCG.\n\nEPISTEMIC BOUNDS: The semantic path relies on `target_node_cid` (max_length=255). Mathematical optimization is bounded by `probability_weight` (ge=0.0, le=1.0) and `compute_weight_magnitude` (ge=0).\n\nMCP ROUTING TRIGGERS: Markov Decision Process, Acyclic Edge, Stochastic Routing, Transition Probability, Directed Graph"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TransitionEdgeProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents a directed acyclic Markov edge for traversing the Action Space topology. As a ...Profile suffix, this is a declarative, frozen snapshot of a routing geometry.\\n\\nCAUSAL AFFORDANCE: Unlocks stochastic pathfinding and graph traversal by projecting a probabilistic weight and thermodynamic cost required to advance to the next state node in the DCG.\\n\\nEPISTEMIC BOUNDS: The semantic path relies on `target_node_cid` (max_length=255). Mathematical optimization is bounded by `probability_weight` (ge=0.0, le=1.0) and `compute_weight_magnitude` (ge=0).\\n\\nMCP ROUTING TRIGGERS: Markov Decision Process, Acyclic Edge, Stochastic Routing, Transition Probability, Directed Graph\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"compute_weight_magnitude\","]
#[doc = "    \"probability_weight\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"compute_weight_magnitude\": {"]
#[doc = "      \"title\": \"Compute Weight Magnitude\","]
#[doc = "      \"description\": \"The thermodynamic cost to traverse this edge.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"eval_strategy\": {"]
#[doc = "      \"title\": \"Eval Strategy\","]
#[doc = "      \"description\": \"The evaluation strategy: 'strict' pre-fetches schemas, 'lazy' uses Coalgebraic Thunking to prevent State-Space Explosion.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"strict\","]
#[doc = "        \"lazy\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"payload_mappings\": {"]
#[doc = "      \"title\": \"Payload Mappings\","]
#[doc = "      \"description\": \"The algebraic translation matrix mapping the source's Covariant output to the Contravariant input.\","]
#[doc = "      \"type\": \"array\","]
#[doc = "      \"items\": {"]
#[doc = "        \"$ref\": \"#/$defs/EdgeMappingContract\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"probability_weight\": {"]
#[doc = "      \"title\": \"Probability Weight\","]
#[doc = "      \"description\": \"The stochastic heuristic preference of this path.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"target_intent\": {"]
#[doc = "      \"description\": \"Dynamic discovery intent for bridging nodes.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/SemanticDiscoveryIntent\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"target_node_cid\": {"]
#[doc = "      \"title\": \"Target Node Cid\","]
#[doc = "      \"description\": \"The coinductive pointer to the destination capability.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology_class\": {"]
#[doc = "      \"title\": \"Topology Class\","]
#[doc = "      \"description\": \"Discriminator type for an acyclic edge.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"const\": \"acyclic\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TransitionEdgeProfile {
    #[doc = "The thermodynamic cost to traverse this edge."]
    pub compute_weight_magnitude: u64,
    #[doc = "The evaluation strategy: 'strict' pre-fetches schemas, 'lazy' uses Coalgebraic Thunking to prevent State-Space Explosion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub eval_strategy: ::std::option::Option<EvalStrategy>,
    #[doc = "The algebraic translation matrix mapping the source's Covariant output to the Contravariant input."]
    #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
    pub payload_mappings: ::std::vec::Vec<EdgeMappingContract>,
    #[doc = "The stochastic heuristic preference of this path."]
    pub probability_weight: f64,
    #[doc = "Dynamic discovery intent for bridging nodes."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub target_intent: ::std::option::Option<SemanticDiscoveryIntent>,
    #[doc = "The coinductive pointer to the destination capability."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub target_node_cid: ::std::option::Option<::std::string::String>,
    #[doc = "Discriminator type for an acyclic edge."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub topology_class: ::std::option::Option<::std::string::String>,
}
impl TransitionEdgeProfile {
    pub fn builder() -> builder::TransitionEdgeProfile {
        Default::default()
    }
}
#[doc = "RFC 8785 canonical hash of the final executed payload."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Transmuted Payload Hash\","]
#[doc = "  \"description\": \"RFC 8785 canonical hash of the final executed payload.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TransmutedPayloadHash(::std::string::String);
impl ::std::ops::Deref for TransmutedPayloadHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TransmutedPayloadHash> for ::std::string::String {
    fn from(value: TransmutedPayloadHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TransmutedPayloadHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TransmutedPayloadHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TransmutedPayloadHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TransmutedPayloadHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TransmutedPayloadHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Polymorphic transport configuration (stdio, sse, or http) including env_vars, args, and headers."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Transport\","]
#[doc = "  \"description\": \"Polymorphic transport configuration (stdio, sse, or http) including env_vars, args, and headers.\","]
#[doc = "  \"oneOf\": ["]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/StdioTransportProfile\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/SSETransportProfile\""]
#[doc = "    },"]
#[doc = "    {"]
#[doc = "      \"$ref\": \"#/$defs/HTTPTransportProfile\""]
#[doc = "    }"]
#[doc = "  ],"]
#[doc = "  \"discriminator\": {"]
#[doc = "    \"mapping\": {"]
#[doc = "      \"http\": \"#/$defs/HTTPTransportProfile\","]
#[doc = "      \"sse\": \"#/$defs/SSETransportProfile\","]
#[doc = "      \"stdio\": \"#/$defs/StdioTransportProfile\""]
#[doc = "    },"]
#[doc = "    \"propertyName\": \"topology_class\""]
#[doc = "  }"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(untagged)]
pub enum Transport {
    StdioTransportProfile(StdioTransportProfile),
    SseTransportProfile(SseTransportProfile),
    HttpTransportProfile(HttpTransportProfile),
}
impl ::std::convert::From<StdioTransportProfile> for Transport {
    fn from(value: StdioTransportProfile) -> Self {
        Self::StdioTransportProfile(value)
    }
}
impl ::std::convert::From<SseTransportProfile> for Transport {
    fn from(value: SseTransportProfile) -> Self {
        Self::SseTransportProfile(value)
    }
}
impl ::std::convert::From<HttpTransportProfile> for Transport {
    fn from(value: HttpTransportProfile) -> Self {
        Self::HttpTransportProfile(value)
    }
}
#[doc = "`TriggerConditionsItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"on_tool_call\","]
#[doc = "    \"on_belief_mutation\","]
#[doc = "    \"on_quarantine\","]
#[doc = "    \"on_falsification\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TriggerConditionsItem {
    #[serde(rename = "on_tool_call")]
    OnToolCall,
    #[serde(rename = "on_belief_mutation")]
    OnBeliefMutation,
    #[serde(rename = "on_quarantine")]
    OnQuarantine,
    #[serde(rename = "on_falsification")]
    OnFalsification,
}
impl ::std::fmt::Display for TriggerConditionsItem {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::OnToolCall => f.write_str("on_tool_call"),
            Self::OnBeliefMutation => f.write_str("on_belief_mutation"),
            Self::OnQuarantine => f.write_str("on_quarantine"),
            Self::OnFalsification => f.write_str("on_falsification"),
        }
    }
}
impl ::std::str::FromStr for TriggerConditionsItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "on_tool_call" => Ok(Self::OnToolCall),
            "on_belief_mutation" => Ok(Self::OnBeliefMutation),
            "on_quarantine" => Ok(Self::OnQuarantine),
            "on_falsification" => Ok(Self::OnFalsification),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TriggerConditionsItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TriggerConditionsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TriggerConditionsItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The mathematically bounded semantic projection defining when the router must trigger this SOP."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Trigger Description\","]
#[doc = "  \"description\": \"The mathematically bounded semantic projection defining when the router must trigger this SOP.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct TriggerDescription(::std::string::String);
impl ::std::ops::Deref for TriggerDescription {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<TriggerDescription> for ::std::string::String {
    fn from(value: TriggerDescription) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for TriggerDescription {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for TriggerDescription {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TriggerDescription {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TriggerDescription {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for TriggerDescription {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "Dictates how the orchestrator caps the state when max_unfold_depth is reached."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Truncation Strategy\","]
#[doc = "  \"description\": \"Dictates how the orchestrator caps the state when max_unfold_depth is reached.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"hash_pointer\","]
#[doc = "    \"nullify\","]
#[doc = "    \"scalar_summary\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum TruncationStrategy {
    #[serde(rename = "hash_pointer")]
    HashPointer,
    #[serde(rename = "nullify")]
    Nullify,
    #[serde(rename = "scalar_summary")]
    ScalarSummary,
}
impl ::std::fmt::Display for TruncationStrategy {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::HashPointer => f.write_str("hash_pointer"),
            Self::Nullify => f.write_str("nullify"),
            Self::ScalarSummary => f.write_str("scalar_summary"),
        }
    }
}
impl ::std::str::FromStr for TruncationStrategy {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "hash_pointer" => Ok(Self::HashPointer),
            "nullify" => Ok(Self::Nullify),
            "scalar_summary" => Ok(Self::ScalarSummary),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for TruncationStrategy {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for TruncationStrategy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for TruncationStrategy {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements a Non-Monotonic Truth Maintenance System (TMS) governing belief retraction across the Merkle-DAG. As a ...Policy suffix, this object defines rigid mathematical boundaries that the orchestrator must enforce globally.\n\nCAUSAL AFFORDANCE: Authorizes the orchestrator to automatically sever downstream SemanticEdgeState vectors when an upstream axiom is falsified, halting epistemic contagion across the swarm topology. `cap_validity` forces the runtime to inject `valid_to` boundaries rather than executing destructive CRUD operations.\n\nEPISTEMIC BOUNDS: Physically restricts catastrophic unravelling via integer limits on `max_cascade_depth` (`le=18446744073709551615, gt=0`) and `max_quarantine_blast_radius` (`le=18446744073709551615, gt=0`). Modulates continuous entropy via `decay_propagation_rate` (`ge=0.0, le=1.0`).\n\nMCP ROUTING TRIGGERS: Truth Maintenance System, Non-Monotonic Logic, Defeasible Reasoning, Belief Revision, Causal Graph Ablation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"TruthMaintenancePolicy\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements a Non-Monotonic Truth Maintenance System (TMS) governing belief retraction across the Merkle-DAG. As a ...Policy suffix, this object defines rigid mathematical boundaries that the orchestrator must enforce globally.\\n\\nCAUSAL AFFORDANCE: Authorizes the orchestrator to automatically sever downstream SemanticEdgeState vectors when an upstream axiom is falsified, halting epistemic contagion across the swarm topology. `cap_validity` forces the runtime to inject `valid_to` boundaries rather than executing destructive CRUD operations.\\n\\nEPISTEMIC BOUNDS: Physically restricts catastrophic unravelling via integer limits on `max_cascade_depth` (`le=18446744073709551615, gt=0`) and `max_quarantine_blast_radius` (`le=18446744073709551615, gt=0`). Modulates continuous entropy via `decay_propagation_rate` (`ge=0.0, le=1.0`).\\n\\nMCP ROUTING TRIGGERS: Truth Maintenance System, Non-Monotonic Logic, Defeasible Reasoning, Belief Revision, Causal Graph Ablation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"decay_propagation_rate\","]
#[doc = "    \"epistemic_quarantine_threshold\","]
#[doc = "    \"max_cascade_depth\","]
#[doc = "    \"max_quarantine_blast_radius\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"decay_propagation_rate\": {"]
#[doc = "      \"title\": \"Decay Propagation Rate\","]
#[doc = "      \"description\": \"Entropy Penalty applied per edge traversal during a defeasible cascade.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"enforce_cross_agent_quarantine\": {"]
#[doc = "      \"title\": \"Enforce Cross Agent Quarantine\","]
#[doc = "      \"description\": \"If True, the orchestrator must automatically emit global QuarantineIntents to sever infected SemanticEdges across the swarm to prevent epistemic contagion.\","]
#[doc = "      \"type\": \"boolean\""]
#[doc = "    },"]
#[doc = "    \"epistemic_quarantine_threshold\": {"]
#[doc = "      \"title\": \"Epistemic Quarantine Threshold\","]
#[doc = "      \"description\": \"The minimum certainty boundary. If an event's propagated confidence drops below this threshold, it is structurally quarantined.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"max_cascade_depth\": {"]
#[doc = "      \"title\": \"Max Cascade Depth\","]
#[doc = "      \"description\": \"The absolute recursion depth limit for state retractions.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"max_quarantine_blast_radius\": {"]
#[doc = "      \"title\": \"Max Quarantine Blast Radius\","]
#[doc = "      \"description\": \"The maximum number of nodes allowed to be severed in a single defeasible event.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"retroactive_falsification_mode\": {"]
#[doc = "      \"title\": \"Retroactive Falsification Mode\","]
#[doc = "      \"description\": \"Dictates whether to cap valid_to bounds or destructively delete branches upon retroactive falsification.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"cap_validity\","]
#[doc = "        \"delete_branch\","]
#[doc = "        \"preserve_as_counterfactual\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TruthMaintenancePolicy {
    #[doc = "Entropy Penalty applied per edge traversal during a defeasible cascade."]
    pub decay_propagation_rate: f64,
    #[doc = "If True, the orchestrator must automatically emit global QuarantineIntents to sever infected SemanticEdges across the swarm to prevent epistemic contagion."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub enforce_cross_agent_quarantine: ::std::option::Option<bool>,
    #[doc = "The minimum certainty boundary. If an event's propagated confidence drops below this threshold, it is structurally quarantined."]
    pub epistemic_quarantine_threshold: f64,
    #[doc = "The absolute recursion depth limit for state retractions."]
    pub max_cascade_depth: ::std::num::NonZeroU64,
    #[doc = "The maximum number of nodes allowed to be severed in a single defeasible event."]
    pub max_quarantine_blast_radius: ::std::num::NonZeroU64,
    #[doc = "Dictates whether to cap valid_to bounds or destructively delete branches upon retroactive falsification."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub retroactive_falsification_mode: ::std::option::Option<RetroactiveFalsificationMode>,
}
impl TruthMaintenancePolicy {
    pub fn builder() -> builder::TruthMaintenancePolicy {
        Default::default()
    }
}
#[doc = "`UngroundedLinkAction`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Ungrounded Link Action\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"sever_edge\","]
#[doc = "    \"flag_for_human\","]
#[doc = "    \"decay_weight\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum UngroundedLinkAction {
    #[serde(rename = "sever_edge")]
    SeverEdge,
    #[serde(rename = "flag_for_human")]
    FlagForHuman,
    #[serde(rename = "decay_weight")]
    DecayWeight,
}
impl ::std::fmt::Display for UngroundedLinkAction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::SeverEdge => f.write_str("sever_edge"),
            Self::FlagForHuman => f.write_str("flag_for_human"),
            Self::DecayWeight => f.write_str("decay_weight"),
        }
    }
}
impl ::std::str::FromStr for UngroundedLinkAction {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "sever_edge" => Ok(Self::SeverEdge),
            "flag_for_human" => Ok(Self::FlagForHuman),
            "decay_weight" => Ok(Self::DecayWeight),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for UngroundedLinkAction {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for UngroundedLinkAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for UngroundedLinkAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "AGENT INSTRUCTION: Classifies reality into domain-independent categories based on Basic Formal Ontology principles to prevent graph bloat."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"UpperOntologyClassProfile\","]
#[doc = "  \"description\": \"AGENT INSTRUCTION: Classifies reality into domain-independent categories based on Basic Formal Ontology principles to prevent graph bloat.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"continuant\","]
#[doc = "    \"occurrent\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum UpperOntologyClassProfile {
    #[serde(rename = "continuant")]
    Continuant,
    #[serde(rename = "occurrent")]
    Occurrent,
}
impl ::std::fmt::Display for UpperOntologyClassProfile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Continuant => f.write_str("continuant"),
            Self::Occurrent => f.write_str("occurrent"),
        }
    }
}
impl ::std::str::FromStr for UpperOntologyClassProfile {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "continuant" => Ok(Self::Continuant),
            "occurrent" => Ok(Self::Occurrent),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for UpperOntologyClassProfile {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for UpperOntologyClassProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for UpperOntologyClassProfile {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`UrisItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct UrisItem(::std::string::String);
impl ::std::ops::Deref for UrisItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<UrisItem> for ::std::string::String {
    fn from(value: UrisItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for UrisItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for UrisItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for UrisItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for UrisItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for UrisItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Multi-Attribute Utility Theory (MAUT) to capture the exact multi-dimensional trade-offs (Pareto vectors) of a given routing decision.\n\nCAUSAL AFFORDANCE: Provides explicit mathematical justification for an agent's trajectory. If the variance of the utility distribution exceeds the threshold, it physically forces the orchestrator to deploy the embedded ensemble specification for deterministic resolution.\n\nEPISTEMIC BOUNDS: The `superposition_variance_threshold` is physically clamped strictly above zero (`gt=0.0`, `le=18446744073709551615.0`), as a variance of absolute 0.0 represents mathematical certainty, which physically precludes superposition geometry. Vector dictionaries are bounded purely by spatial cardinality (`max_length=1000`).\n\nMCP ROUTING TRIGGERS: Multi-Attribute Utility Theory, Pareto Efficiency, Variance Reduction, Fallback Superposition, Utility Routing"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"UtilityJustificationGraphReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Multi-Attribute Utility Theory (MAUT) to capture the exact multi-dimensional trade-offs (Pareto vectors) of a given routing decision.\\n\\nCAUSAL AFFORDANCE: Provides explicit mathematical justification for an agent's trajectory. If the variance of the utility distribution exceeds the threshold, it physically forces the orchestrator to deploy the embedded ensemble specification for deterministic resolution.\\n\\nEPISTEMIC BOUNDS: The `superposition_variance_threshold` is physically clamped strictly above zero (`gt=0.0`, `le=18446744073709551615.0`), as a variance of absolute 0.0 represents mathematical certainty, which physically precludes superposition geometry. Vector dictionaries are bounded purely by spatial cardinality (`max_length=1000`).\\n\\nMCP ROUTING TRIGGERS: Multi-Attribute Utility Theory, Pareto Efficiency, Variance Reduction, Fallback Superposition, Utility Routing\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"superposition_variance_threshold\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"degrading_vectors\": {"]
#[doc = "      \"title\": \"Degrading Vectors\","]
#[doc = "      \"description\": \"Multi-dimensional continuous values representing degradations.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"number\","]
#[doc = "        \"maximum\": 1000.0,"]
#[doc = "        \"minimum\": -1000.0"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"ensemble_spec\": {"]
#[doc = "      \"description\": \"The deterministic ensemble specification to fall back on when threshold falls below delta.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/EnsembleTopologyProfile\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"optimizing_vectors\": {"]
#[doc = "      \"title\": \"Optimizing Vectors\","]
#[doc = "      \"description\": \"Multi-dimensional continuous values representing optimizations.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 1000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"number\","]
#[doc = "        \"maximum\": 1000.0,"]
#[doc = "        \"minimum\": -1000.0"]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"superposition_variance_threshold\": {"]
#[doc = "      \"title\": \"Superposition Variance Threshold\","]
#[doc = "      \"description\": \"The statistical variance threshold below which deterministic fallback is enforced.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"exclusiveMinimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct UtilityJustificationGraphReceipt {
    #[doc = "Multi-dimensional continuous values representing degradations."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub degrading_vectors: ::std::collections::HashMap<::std::string::String, f64>,
    #[doc = "The deterministic ensemble specification to fall back on when threshold falls below delta."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub ensemble_spec: ::std::option::Option<EnsembleTopologyProfile>,
    #[doc = "Multi-dimensional continuous values representing optimizations."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub optimizing_vectors: ::std::collections::HashMap<::std::string::String, f64>,
    #[doc = "The statistical variance threshold below which deterministic fallback is enforced."]
    pub superposition_variance_threshold: f64,
}
impl UtilityJustificationGraphReceipt {
    pub fn builder() -> builder::UtilityJustificationGraphReceipt {
        Default::default()
    }
}
#[doc = "`ValidationFailureAction`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Validation Failure Action\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"quarantine_chunk\","]
#[doc = "    \"escalate_to_human\","]
#[doc = "    \"drop_edge\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ValidationFailureAction {
    #[serde(rename = "quarantine_chunk")]
    QuarantineChunk,
    #[serde(rename = "escalate_to_human")]
    EscalateToHuman,
    #[serde(rename = "drop_edge")]
    DropEdge,
}
impl ::std::fmt::Display for ValidationFailureAction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::QuarantineChunk => f.write_str("quarantine_chunk"),
            Self::EscalateToHuman => f.write_str("escalate_to_human"),
            Self::DropEdge => f.write_str("drop_edge"),
        }
    }
}
impl ::std::str::FromStr for ValidationFailureAction {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "quarantine_chunk" => Ok(Self::QuarantineChunk),
            "escalate_to_human" => Ok(Self::EscalateToHuman),
            "drop_edge" => Ok(Self::DropEdge),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ValidationFailureAction {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ValidationFailureAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ValidationFailureAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "The base64-encoded dense vector array."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Vector Base64\","]
#[doc = "  \"description\": \"The base64-encoded dense vector array.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 5000000,"]
#[doc = "  \"pattern\": \"^[A-Za-z0-9+/]*={0,2}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct VectorBase64(::std::string::String);
impl ::std::ops::Deref for VectorBase64 {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<VectorBase64> for ::std::string::String {
    fn from(value: VectorBase64) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for VectorBase64 {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 5000000usize {
            return Err("longer than 5000000 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[A-Za-z0-9+/]*={0,2}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[A-Za-z0-9+/]*={0,2}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for VectorBase64 {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for VectorBase64 {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for VectorBase64 {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for VectorBase64 {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Represents a declarative, frozen geometric coordinate\nwithin a high-dimensional latent manifold, acting as a dense vector anchor\nfor zero-shot semantic routing. As a ...State suffix, this is a frozen\nN-dimensional coordinate.\n\nCAUSAL AFFORDANCE: Unlocks Maximum Inner Product Search (MIPS) and k-Nearest\nNeighbors (k-NN) retrieval without invoking stochastic token generation. The\nfoundation_matrix_name (max_length=2000) traces embedding provenance. The dimensionality\n(int, unbounded) specifies the vector array size. These fields allow the Maximum Inner\nProduct Search (MIPS) engine to automatically decay geometric similarity based on the\nquery's current timestamp.\n\nEPISTEMIC BOUNDS: The vector_base64 enforces a strict Base64 regex\n(^[A-Za-z0-9+/]*={0,2}$) and is physically capped at max_length=5000000 to\nprevent VRAM exhaustion during deserialization.\n\nMCP ROUTING TRIGGERS: Topological Data Analysis, Dense Vector Embedding,\nLatent Manifold, Maximum Inner Product Search, k-Nearest Neighbors"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"VectorEmbeddingState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Represents a declarative, frozen geometric coordinate\\nwithin a high-dimensional latent manifold, acting as a dense vector anchor\\nfor zero-shot semantic routing. As a ...State suffix, this is a frozen\\nN-dimensional coordinate.\\n\\nCAUSAL AFFORDANCE: Unlocks Maximum Inner Product Search (MIPS) and k-Nearest\\nNeighbors (k-NN) retrieval without invoking stochastic token generation. The\\nfoundation_matrix_name (max_length=2000) traces embedding provenance. The dimensionality\\n(int, unbounded) specifies the vector array size. These fields allow the Maximum Inner\\nProduct Search (MIPS) engine to automatically decay geometric similarity based on the\\nquery's current timestamp.\\n\\nEPISTEMIC BOUNDS: The vector_base64 enforces a strict Base64 regex\\n(^[A-Za-z0-9+/]*={0,2}$) and is physically capped at max_length=5000000 to\\nprevent VRAM exhaustion during deserialization.\\n\\nMCP ROUTING TRIGGERS: Topological Data Analysis, Dense Vector Embedding,\\nLatent Manifold, Maximum Inner Product Search, k-Nearest Neighbors\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"dimensionality\","]
#[doc = "    \"foundation_matrix_name\","]
#[doc = "    \"vector_base64\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"dimensionality\": {"]
#[doc = "      \"title\": \"Dimensionality\","]
#[doc = "      \"description\": \"The size of the vector array.\","]
#[doc = "      \"type\": \"integer\""]
#[doc = "    },"]
#[doc = "    \"foundation_matrix_name\": {"]
#[doc = "      \"title\": \"Foundation Matrix Name\","]
#[doc = "      \"description\": \"The provenance of the embedding model used (e.g., 'text-embedding-3-large').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"temporal_decay_function\": {"]
#[doc = "      \"title\": \"Temporal Decay Function\","]
#[doc = "      \"description\": \"The temporal decay function for semantic relevance.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"exponential\","]
#[doc = "        \"cosine_annealing\","]
#[doc = "        \"polynomial\","]
#[doc = "        \"none\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"time_derivative_vector\": {"]
#[doc = "      \"title\": \"Time Derivative Vector\","]
#[doc = "      \"description\": \"A base64-encoded tensor defining the geometric rate of change over time.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"vector_base64\": {"]
#[doc = "      \"title\": \"Vector Base64\","]
#[doc = "      \"description\": \"The base64-encoded dense vector array.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 5000000,"]
#[doc = "      \"pattern\": \"^[A-Za-z0-9+/]*={0,2}$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct VectorEmbeddingState {
    #[doc = "The size of the vector array."]
    pub dimensionality: i64,
    #[doc = "The provenance of the embedding model used (e.g., 'text-embedding-3-large')."]
    pub foundation_matrix_name: FoundationMatrixName,
    #[doc = "The temporal decay function for semantic relevance."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub temporal_decay_function: ::std::option::Option<TemporalDecayFunction>,
    #[doc = "A base64-encoded tensor defining the geometric rate of change over time."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub time_derivative_vector: ::std::option::Option<::std::string::String>,
    #[doc = "The base64-encoded dense vector array."]
    pub vector_base64: VectorBase64,
}
impl VectorEmbeddingState {
    pub fn builder() -> builder::VectorEmbeddingState {
        Default::default()
    }
}
#[doc = "The tensor operation to perform: add the vector, subtract it, or clamp activations to its bounds."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Vector Modality\","]
#[doc = "  \"description\": \"The tensor operation to perform: add the vector, subtract it, or clamp activations to its bounds.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"additive\","]
#[doc = "    \"ablation\","]
#[doc = "    \"clamping\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum VectorModality {
    #[serde(rename = "additive")]
    Additive,
    #[serde(rename = "ablation")]
    Ablation,
    #[serde(rename = "clamping")]
    Clamping,
}
impl ::std::fmt::Display for VectorModality {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::Additive => f.write_str("additive"),
            Self::Ablation => f.write_str("ablation"),
            Self::Clamping => f.write_str("clamping"),
        }
    }
}
impl ::std::str::FromStr for VectorModality {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "additive" => Ok(Self::Additive),
            "ablation" => Ok(Self::Ablation),
            "clamping" => Ok(Self::Clamping),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for VectorModality {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for VectorModality {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for VectorModality {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes the W3C Verifiable Credentials Data Model (VCDM v2.0) to establish a decentralized, Zero-Trust identity perimeter on the Merkle-DAG.\n\nCAUSAL AFFORDANCE: Unlocks isolated execution bounds by projecting cryptographically verified geometric predicates (`authorization_claims`) into the orchestrator via `issuer_did`, allowing an agent to prove authorization clearance without centralized identity brokers.\n\nEPISTEMIC BOUNDS: The `authorization_claims` dict (`max_length=86400000`) is volumetrically bounded by the `enforce_payload_topology` hook (`_validate_payload_bounds`) to completely sever Predicate Exhaustion Attacks during selective disclosure verification. `cryptographic_proof_blob` capped at `max_length=100000`.\n\nMCP ROUTING TRIGGERS: W3C VCDM, Zero-Knowledge Proofs, Selective Disclosure, Decentralized Identifiers, Object Capability Model"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"VerifiableCredentialPresentationReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes the W3C Verifiable Credentials Data Model (VCDM v2.0) to establish a decentralized, Zero-Trust identity perimeter on the Merkle-DAG.\\n\\nCAUSAL AFFORDANCE: Unlocks isolated execution bounds by projecting cryptographically verified geometric predicates (`authorization_claims`) into the orchestrator via `issuer_did`, allowing an agent to prove authorization clearance without centralized identity brokers.\\n\\nEPISTEMIC BOUNDS: The `authorization_claims` dict (`max_length=86400000`) is volumetrically bounded by the `enforce_payload_topology` hook (`_validate_payload_bounds`) to completely sever Predicate Exhaustion Attacks during selective disclosure verification. `cryptographic_proof_blob` capped at `max_length=100000`.\\n\\nMCP ROUTING TRIGGERS: W3C VCDM, Zero-Knowledge Proofs, Selective Disclosure, Decentralized Identifiers, Object Capability Model\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"authorization_claims\","]
#[doc = "    \"cryptographic_proof_blob\","]
#[doc = "    \"issuer_did\","]
#[doc = "    \"presentation_format\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"authorization_claims\": {"]
#[doc = "      \"title\": \"Authorization Claims\","]
#[doc = "      \"description\": \"The strict, domain-agnostic JSON dictionary of strictly bounded geometric predicates that define the operational perimeter of the agent (e.g., {'clearance': 'RESTRICTED'}). AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"maxProperties\": 86400000,"]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"$ref\": \"#/$defs/JsonPrimitiveState\""]
#[doc = "      }"]
#[doc = "    },"]
#[doc = "    \"cryptographic_proof_blob\": {"]
#[doc = "      \"title\": \"Cryptographic Proof Blob\","]
#[doc = "      \"description\": \"The base64-encoded cryptographic proof (e.g., ZK-SNARKs, zkVM receipts, or programmable trust attestations) proving the claims without revealing the private key.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000"]
#[doc = "    },"]
#[doc = "    \"issuer_did\": {"]
#[doc = "      \"description\": \"The globally unique decentralized identifier (DID) anchoring the trusted authority that cryptographically signed the credential, explicitly representing the delegation of authority from a human or parent principal.\","]
#[doc = "      \"$ref\": \"#/$defs/NodeCIDState\""]
#[doc = "    },"]
#[doc = "    \"presentation_format\": {"]
#[doc = "      \"title\": \"Presentation Format\","]
#[doc = "      \"description\": \"The exact cryptographic standard used to encode this credential presentation.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"jwt_vc\","]
#[doc = "        \"ldp_vc\","]
#[doc = "        \"sd_jwt\","]
#[doc = "        \"zkp_vc\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct VerifiableCredentialPresentationReceipt {
    #[doc = "The strict, domain-agnostic JSON dictionary of strictly bounded geometric predicates that define the operational perimeter of the agent (e.g., {'clearance': 'RESTRICTED'}). AGENT INSTRUCTION: Payload volume is strictly limited to an absolute $O(N)$ limit of 10,000 nodes and a maximum recursion depth of 10 to prevent VRAM exhaustion."]
    pub authorization_claims:
        ::std::collections::HashMap<::std::string::String, JsonPrimitiveState>,
    #[doc = "The base64-encoded cryptographic proof (e.g., ZK-SNARKs, zkVM receipts, or programmable trust attestations) proving the claims without revealing the private key."]
    pub cryptographic_proof_blob: CryptographicProofBlob,
    #[doc = "The globally unique decentralized identifier (DID) anchoring the trusted authority that cryptographically signed the credential, explicitly representing the delegation of authority from a human or parent principal."]
    pub issuer_did: NodeCidState,
    #[doc = "The exact cryptographic standard used to encode this credential presentation."]
    pub presentation_format: PresentationFormat,
}
impl VerifiableCredentialPresentationReceipt {
    pub fn builder() -> builder::VerifiableCredentialPresentationReceipt {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: A cryptographically frozen receipt representing a Verifiable Random Function (VRF) output via elliptic curve cryptography. As an append-only coordinate on the Merkle-DAG, the LLM must never hallucinate a mutation to it.\n\nCAUSAL AFFORDANCE: Unlocks stochastic graph mutations (EvolutionaryTopology crossovers or prediction market resolutions) by providing mathematical proof that randomness was uniformly distributed and not manipulated by a Byzantine node.\n\nEPISTEMIC BOUNDS: Validity is physically bound to `seed_hash` (strict SHA-256 pattern `^[a-f0-9]{64}$`, `max_length=128`, `min_length=10`) and `public_key` (`max_length=8192`). `vrf_proof` is capped at `max_length=5000000`. Prevents adversarial Hash Poisoning.\n\nMCP ROUTING TRIGGERS: Verifiable Random Function, VRF, Stochastic Fairness, Elliptic Curve Cryptography, Zero-Knowledge Entropy"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"VerifiableEntropyReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: A cryptographically frozen receipt representing a Verifiable Random Function (VRF) output via elliptic curve cryptography. As an append-only coordinate on the Merkle-DAG, the LLM must never hallucinate a mutation to it.\\n\\nCAUSAL AFFORDANCE: Unlocks stochastic graph mutations (EvolutionaryTopology crossovers or prediction market resolutions) by providing mathematical proof that randomness was uniformly distributed and not manipulated by a Byzantine node.\\n\\nEPISTEMIC BOUNDS: Validity is physically bound to `seed_hash` (strict SHA-256 pattern `^[a-f0-9]{64}$`, `max_length=128`, `min_length=10`) and `public_key` (`max_length=8192`). `vrf_proof` is capped at `max_length=5000000`. Prevents adversarial Hash Poisoning.\\n\\nMCP ROUTING TRIGGERS: Verifiable Random Function, VRF, Stochastic Fairness, Elliptic Curve Cryptography, Zero-Knowledge Entropy\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"public_key\","]
#[doc = "    \"seed_hash\","]
#[doc = "    \"vrf_proof\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"public_key\": {"]
#[doc = "      \"title\": \"Public Key\","]
#[doc = "      \"description\": \"The public key of the oracle or node used to verify the VRF proof.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 8192,"]
#[doc = "      \"minLength\": 10"]
#[doc = "    },"]
#[doc = "    \"seed_hash\": {"]
#[doc = "      \"title\": \"Seed Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the origin seed used to initialize the VRF.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 10,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"vrf_proof\": {"]
#[doc = "      \"title\": \"Vrf Proof\","]
#[doc = "      \"description\": \"The zero-knowledge cryptographic proof of fair random generation.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 5000000,"]
#[doc = "      \"minLength\": 10"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct VerifiableEntropyReceipt {
    #[doc = "The public key of the oracle or node used to verify the VRF proof."]
    pub public_key: PublicKey,
    #[doc = "The SHA-256 hash of the origin seed used to initialize the VRF."]
    pub seed_hash: SeedHash,
    #[doc = "The zero-knowledge cryptographic proof of fair random generation."]
    pub vrf_proof: VrfProof,
}
impl VerifiableEntropyReceipt {
    pub fn builder() -> builder::VerifiableEntropyReceipt {
        Default::default()
    }
}
#[doc = "The DID or public key identifier required by an auditor to reconstruct the PRF and verify the watermark."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Verification Public Key Cid\","]
#[doc = "  \"description\": \"The DID or public key identifier required by an auditor to reconstruct the PRF and verify the watermark.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct VerificationPublicKeyCid(::std::string::String);
impl ::std::ops::Deref for VerificationPublicKeyCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<VerificationPublicKeyCid> for ::std::string::String {
    fn from(value: VerificationPublicKeyCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for VerificationPublicKeyCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for VerificationPublicKeyCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for VerificationPublicKeyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for VerificationPublicKeyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for VerificationPublicKeyCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The absolute cryptographic SHA-256 hash mathematically proving formal state verification."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Verified Theorem Hash\","]
#[doc = "  \"description\": \"The absolute cryptographic SHA-256 hash mathematically proving formal state verification.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct VerifiedTheoremHash(::std::string::String);
impl ::std::ops::Deref for VerifiedTheoremHash {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<VerifiedTheoremHash> for ::std::string::String {
    fn from(value: VerifiedTheoremHash) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for VerifiedTheoremHash {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-f0-9]{64}$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-f0-9]{64}$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for VerifiedTheoremHash {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for VerifiedTheoremHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for VerifiedTheoremHash {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for VerifiedTheoremHash {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the public evaluation key."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Verifier Key Cid\","]
#[doc = "  \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the public evaluation key.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct VerifierKeyCid(::std::string::String);
impl ::std::ops::Deref for VerifierKeyCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<VerifierKeyCid> for ::std::string::String {
    fn from(value: VerifierKeyCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for VerifierKeyCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for VerifierKeyCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for VerifierKeyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for VerifierKeyCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for VerifierKeyCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The deterministic solver evaluating the hypotheses."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Verifier Node Cid\","]
#[doc = "  \"description\": \"The deterministic solver evaluating the hypotheses.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct VerifierNodeCid(::std::string::String);
impl ::std::ops::Deref for VerifierNodeCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<VerifierNodeCid> for ::std::string::String {
    fn from(value: VerifierNodeCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for VerifierNodeCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for VerifierNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for VerifierNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for VerifierNodeCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for VerifierNodeCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the linear algebraic projection matrix required to map N-dimensional spatial geometries onto a normalized View Frustum.\n\nCAUSAL AFFORDANCE: Authorizes an external rendering client to mathematically multiply a 3D SE(3) topology by a projection matrix, safely collapsing depth dimensions into an SE(2) plane for flat-screen rendering without fracturing topological relationships.\n\nEPISTEMIC BOUNDS: Bounding rules physically enforce valid optical geometry. The `clipping_plane_near` (`ge=0.001`) must mathematically precede `clipping_plane_far`. Perspective projections unconditionally mandate a valid `field_of_view_degrees` (`ge=1.0, le=179.0`) to prevent division-by-zero optical singularities.\n\nMCP ROUTING TRIGGERS: Viewport Projection Matrix, View Frustum, Field of View, Clipping Planes, Linear Algebraic Projection"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ViewportProjectionContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the linear algebraic projection matrix required to map N-dimensional spatial geometries onto a normalized View Frustum.\\n\\nCAUSAL AFFORDANCE: Authorizes an external rendering client to mathematically multiply a 3D SE(3) topology by a projection matrix, safely collapsing depth dimensions into an SE(2) plane for flat-screen rendering without fracturing topological relationships.\\n\\nEPISTEMIC BOUNDS: Bounding rules physically enforce valid optical geometry. The `clipping_plane_near` (`ge=0.001`) must mathematically precede `clipping_plane_far`. Perspective projections unconditionally mandate a valid `field_of_view_degrees` (`ge=1.0, le=179.0`) to prevent division-by-zero optical singularities.\\n\\nMCP ROUTING TRIGGERS: Viewport Projection Matrix, View Frustum, Field of View, Clipping Planes, Linear Algebraic Projection\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"clipping_plane_far\","]
#[doc = "    \"clipping_plane_near\","]
#[doc = "    \"projection_class\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"clipping_plane_far\": {"]
#[doc = "      \"title\": \"Clipping Plane Far\","]
#[doc = "      \"description\": \"The far frustum clipping plane.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"minimum\": 0.01"]
#[doc = "    },"]
#[doc = "    \"clipping_plane_near\": {"]
#[doc = "      \"title\": \"Clipping Plane Near\","]
#[doc = "      \"description\": \"The near frustum clipping plane.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"minimum\": 0.001"]
#[doc = "    },"]
#[doc = "    \"field_of_view_degrees\": {"]
#[doc = "      \"title\": \"Field Of View Degrees\","]
#[doc = "      \"description\": \"The Y-axis optical field of view. Mandatory for perspective projections.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"number\","]
#[doc = "          \"maximum\": 179.0,"]
#[doc = "          \"minimum\": 1.0"]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"projection_class\": {"]
#[doc = "      \"title\": \"Projection Class\","]
#[doc = "      \"description\": \"The linear algebraic projection operator applied to collapse the topology.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"perspective\","]
#[doc = "        \"orthographic\""]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ViewportProjectionContract {
    #[doc = "The far frustum clipping plane."]
    pub clipping_plane_far: f64,
    #[doc = "The near frustum clipping plane."]
    pub clipping_plane_near: f64,
    #[doc = "The Y-axis optical field of view. Mandatory for perspective projections."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub field_of_view_degrees: ::std::option::Option<f64>,
    #[doc = "The linear algebraic projection operator applied to collapse the topology."]
    pub projection_class: ProjectionClass,
}
impl ViewportProjectionContract {
    pub fn builder() -> builder::ViewportProjectionContract {
        Default::default()
    }
}
#[doc = "The generated natural language scenario."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Vignette Payload\","]
#[doc = "  \"description\": \"The generated natural language scenario.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct VignettePayload(::std::string::String);
impl ::std::ops::Deref for VignettePayload {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<VignettePayload> for ::std::string::String {
    fn from(value: VignettePayload) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for VignettePayload {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100000usize {
            return Err("longer than 100000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for VignettePayload {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for VignettePayload {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for VignettePayload {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for VignettePayload {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`ViolatedAlgebraicConstraint`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Violated Algebraic Constraint\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ViolatedAlgebraicConstraint(::std::string::String);
impl ::std::ops::Deref for ViolatedAlgebraicConstraint {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ViolatedAlgebraicConstraint> for ::std::string::String {
    fn from(value: ViolatedAlgebraicConstraint) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ViolatedAlgebraicConstraint {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ViolatedAlgebraicConstraint {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ViolatedAlgebraicConstraint {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ViolatedAlgebraicConstraint {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ViolatedAlgebraicConstraint {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "`ViolationAction`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Violation Action\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"DROP_GRAPH\","]
#[doc = "    \"STRIP_TRIPLES\","]
#[doc = "    \"HALT_EXECUTION\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum ViolationAction {
    #[serde(rename = "DROP_GRAPH")]
    DropGraph,
    #[serde(rename = "STRIP_TRIPLES")]
    StripTriples,
    #[serde(rename = "HALT_EXECUTION")]
    HaltExecution,
}
impl ::std::fmt::Display for ViolationAction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::DropGraph => f.write_str("DROP_GRAPH"),
            Self::StripTriples => f.write_str("STRIP_TRIPLES"),
            Self::HaltExecution => f.write_str("HALT_EXECUTION"),
        }
    }
}
impl ::std::str::FromStr for ViolationAction {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "DROP_GRAPH" => Ok(Self::DropGraph),
            "STRIP_TRIPLES" => Ok(Self::StripTriples),
            "HALT_EXECUTION" => Ok(Self::HaltExecution),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for ViolationAction {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ViolationAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ViolationAction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "Categorical descriptor of the failure, e.g., missing, type_error."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Violation Category\","]
#[doc = "  \"description\": \"Categorical descriptor of the failure, e.g., missing, type_error.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 255"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ViolationCategory(::std::string::String);
impl ::std::ops::Deref for ViolationCategory {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ViolationCategory> for ::std::string::String {
    fn from(value: ViolationCategory) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ViolationCategory {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 255usize {
            return Err("longer than 255 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ViolationCategory {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for ViolationCategory {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for ViolationCategory {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ViolationCategory {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines the mathematical mapping function between an abstract data dimension (field) and a physiological human perception vector (channel).\n\nCAUSAL AFFORDANCE: Constrains the renderer's geometric plotting algorithm by forcing the interpretation of data through an optional ScalePolicy transformation.\n\nEPISTEMIC BOUNDS: The channel is strictly typed to a Literal enum `[\"x\", \"y\", \"color\", \"size\", \"opacity\", \"shape\", \"text\"]`. The target field is physically bounded to `max_length=2000` to prevent dictionary bombing during rendering loops.\n\nMCP ROUTING TRIGGERS: Bijective Mapping, Retinal Variables, Dimensionality Reduction, Geometric Plotting, Visual Channel Encoding"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"VisualEncodingProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines the mathematical mapping function between an abstract data dimension (field) and a physiological human perception vector (channel).\\n\\nCAUSAL AFFORDANCE: Constrains the renderer's geometric plotting algorithm by forcing the interpretation of data through an optional ScalePolicy transformation.\\n\\nEPISTEMIC BOUNDS: The channel is strictly typed to a Literal enum `[\\\"x\\\", \\\"y\\\", \\\"color\\\", \\\"size\\\", \\\"opacity\\\", \\\"shape\\\", \\\"text\\\"]`. The target field is physically bounded to `max_length=2000` to prevent dictionary bombing during rendering loops.\\n\\nMCP ROUTING TRIGGERS: Bijective Mapping, Retinal Variables, Dimensionality Reduction, Geometric Plotting, Visual Channel Encoding\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"channel\","]
#[doc = "    \"field\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"channel\": {"]
#[doc = "      \"title\": \"Channel\","]
#[doc = "      \"description\": \"The visual channel the metric is mapped to.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"x\","]
#[doc = "        \"y\","]
#[doc = "        \"color\","]
#[doc = "        \"size\","]
#[doc = "        \"opacity\","]
#[doc = "        \"shape\","]
#[doc = "        \"text\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"field\": {"]
#[doc = "      \"title\": \"Field\","]
#[doc = "      \"description\": \"The exact column or field name from the semantic series.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 2000"]
#[doc = "    },"]
#[doc = "    \"scale\": {"]
#[doc = "      \"description\": \"Optional scale override for this specific channel.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ScalePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct VisualEncodingProfile {
    #[doc = "The visual channel the metric is mapped to."]
    pub channel: Channel,
    #[doc = "The exact column or field name from the semantic series."]
    pub field: Field,
    #[doc = "Optional scale override for this specific channel."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub scale: ::std::option::Option<ScalePolicy>,
}
impl VisualEncodingProfile {
    pub fn builder() -> builder::VisualEncodingProfile {
        Default::default()
    }
}
#[doc = "`VisualPatchHashesItem`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct VisualPatchHashesItem(::std::string::String);
impl ::std::ops::Deref for VisualPatchHashesItem {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<VisualPatchHashesItem> for ::std::string::String {
    fn from(value: VisualPatchHashesItem) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for VisualPatchHashesItem {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for VisualPatchHashesItem {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for VisualPatchHashesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for VisualPatchHashesItem {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for VisualPatchHashesItem {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Defines a continuous 3D Axis-Aligned Bounding Box (AABB) or Oriented Bounding Box (OBB) using spatial kinematics.\n\nCAUSAL AFFORDANCE: Instructs the spatial orchestrator to enforce a physical holographic cage, structurally preventing agents or dynamic UI layouts from spawning coordinates that collide with environmental walls or overflow spatial geometry.\n\nEPISTEMIC BOUNDS: Anchored by an `SE3TransformProfile`. Spatial magnitude is clamped by strictly non-negative extents (`ge=0.0`). The `@model_validator` `validate_volume_physics` mathematically prevents the instantiation of zero-dimensional point anomalies by demanding a strictly positive aggregate volume.\n\nMCP ROUTING TRIGGERS: Volumetric Boundary, Holographic Cage, Oriented Bounding Box, Spatial Kinematics, Collision Perimeter"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"VolumetricBoundingProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Defines a continuous 3D Axis-Aligned Bounding Box (AABB) or Oriented Bounding Box (OBB) using spatial kinematics.\\n\\nCAUSAL AFFORDANCE: Instructs the spatial orchestrator to enforce a physical holographic cage, structurally preventing agents or dynamic UI layouts from spawning coordinates that collide with environmental walls or overflow spatial geometry.\\n\\nEPISTEMIC BOUNDS: Anchored by an `SE3TransformProfile`. Spatial magnitude is clamped by strictly non-negative extents (`ge=0.0`). The `@model_validator` `validate_volume_physics` mathematically prevents the instantiation of zero-dimensional point anomalies by demanding a strictly positive aggregate volume.\\n\\nMCP ROUTING TRIGGERS: Volumetric Boundary, Holographic Cage, Oriented Bounding Box, Spatial Kinematics, Collision Perimeter\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"center_transform\","]
#[doc = "    \"extents_x\","]
#[doc = "    \"extents_y\","]
#[doc = "    \"extents_z\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"center_transform\": {"]
#[doc = "      \"description\": \"The absolute SE(3) position and rotation of the bounding volume's exact geometric center.\","]
#[doc = "      \"$ref\": \"#/$defs/SE3TransformProfile\""]
#[doc = "    },"]
#[doc = "    \"extents_x\": {"]
#[doc = "      \"title\": \"Extents X\","]
#[doc = "      \"description\": \"The total width of the boundary volume.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"extents_y\": {"]
#[doc = "      \"title\": \"Extents Y\","]
#[doc = "      \"description\": \"The total height of the boundary volume.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"extents_z\": {"]
#[doc = "      \"title\": \"Extents Z\","]
#[doc = "      \"description\": \"The total depth of the boundary volume.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct VolumetricBoundingProfile {
    #[doc = "The absolute SE(3) position and rotation of the bounding volume's exact geometric center."]
    pub center_transform: Se3TransformProfile,
    #[doc = "The total width of the boundary volume."]
    pub extents_x: f64,
    #[doc = "The total height of the boundary volume."]
    pub extents_y: f64,
    #[doc = "The total depth of the boundary volume."]
    pub extents_z: f64,
}
impl VolumetricBoundingProfile {
    pub fn builder() -> builder::VolumetricBoundingProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes the geometric curve and token flow thermodynamics between topological vertices.\n\nCAUSAL AFFORDANCE: Instructs the spatial rendering engine to compute C1-continuous parametric splines between discrete nodes, translating abstract logical edges into physical volumetric manifolds.\n\nEPISTEMIC BOUNDS: Curve geometry is locked to the Literal automaton `[\"straight\", \"bezier\", \"catmull_rom\", \"riemannian_geodesic\"]`. Thermodynamic token velocity is clamped by `flow_velocity` (`ge=0.0, le=100.0`). Spline rigidity (`tension`) is bounded `[0.0, 1.0]`.\n\nMCP ROUTING TRIGGERS: Parametric Spline Interpolation, Catmull-Rom, Bezier Geometry, C1 Continuity, Volumetric Edge"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"VolumetricEdgeProfile\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes the geometric curve and token flow thermodynamics between topological vertices.\\n\\nCAUSAL AFFORDANCE: Instructs the spatial rendering engine to compute C1-continuous parametric splines between discrete nodes, translating abstract logical edges into physical volumetric manifolds.\\n\\nEPISTEMIC BOUNDS: Curve geometry is locked to the Literal automaton `[\\\"straight\\\", \\\"bezier\\\", \\\"catmull_rom\\\", \\\"riemannian_geodesic\\\"]`. Thermodynamic token velocity is clamped by `flow_velocity` (`ge=0.0, le=100.0`). Spline rigidity (`tension`) is bounded `[0.0, 1.0]`.\\n\\nMCP ROUTING TRIGGERS: Parametric Spline Interpolation, Catmull-Rom, Bezier Geometry, C1 Continuity, Volumetric Edge\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"curve_class\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"curve_class\": {"]
#[doc = "      \"title\": \"Curve Class\","]
#[doc = "      \"description\": \"The mathematical spline geometry used to interpolate the space between vertices.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"enum\": ["]
#[doc = "        \"straight\","]
#[doc = "        \"bezier\","]
#[doc = "        \"catmull_rom\","]
#[doc = "        \"riemannian_geodesic\""]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"edge_thickness\": {"]
#[doc = "      \"title\": \"Edge Thickness\","]
#[doc = "      \"description\": \"The physical volumetric width of the connection manifold in meters.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 10.0,"]
#[doc = "      \"minimum\": 0.01"]
#[doc = "    },"]
#[doc = "    \"flow_velocity\": {"]
#[doc = "      \"title\": \"Flow Velocity\","]
#[doc = "      \"description\": \"The temporal speed (derivative) of token transmission visualized along the edge manifold.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 100.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"spatial_repulsion_scalar\": {"]
#[doc = "      \"title\": \"Spatial Repulsion Scalar\","]
#[doc = "      \"description\": \"The mathematical gravity or repulsion field the edge asserts to avoid intersecting with volumetric bounding cages.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 100.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    },"]
#[doc = "    \"tension\": {"]
#[doc = "      \"title\": \"Tension\","]
#[doc = "      \"description\": \"The mathematical rigidity scalar of the spline interpolation.\","]
#[doc = "      \"type\": \"number\","]
#[doc = "      \"maximum\": 1.0,"]
#[doc = "      \"minimum\": 0.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct VolumetricEdgeProfile {
    #[doc = "The mathematical spline geometry used to interpolate the space between vertices."]
    pub curve_class: CurveClass,
    #[doc = "The physical volumetric width of the connection manifold in meters."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub edge_thickness: ::std::option::Option<f64>,
    #[doc = "The temporal speed (derivative) of token transmission visualized along the edge manifold."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub flow_velocity: ::std::option::Option<f64>,
    #[doc = "The mathematical gravity or repulsion field the edge asserts to avoid intersecting with volumetric bounding cages."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub spatial_repulsion_scalar: ::std::option::Option<f64>,
    #[doc = "The mathematical rigidity scalar of the spline interpolation."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub tension: ::std::option::Option<f64>,
}
impl VolumetricEdgeProfile {
    pub fn builder() -> builder::VolumetricEdgeProfile {
        Default::default()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Implements Hierarchical Spatial Hashing and Area of Interest (AOI) Management to prevent $O(N^2)$ network saturation in massive spatial hypermedia environments.\n\nCAUSAL AFFORDANCE: Allows a distributed client to mathematically define a spatial perimeter. The orchestrator restricts the egress of KinematicDeltaManifest streams exclusively to nodes residing within this specific volumetric boundary.\n\nEPISTEMIC BOUNDS: The temporal liveness is guillotined by `subscription_ttl_ms` (`ge=1, le=18446744073709551615`). The volume is physically restricted by the nested `VolumetricBoundingProfile`.\n\nMCP ROUTING TRIGGERS: Area of Interest Management, Hierarchical Spatial Hashing, Telemetry Isolation, Spatial Partitioning, Culling"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"VolumetricPartitionState\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Implements Hierarchical Spatial Hashing and Area of Interest (AOI) Management to prevent $O(N^2)$ network saturation in massive spatial hypermedia environments.\\n\\nCAUSAL AFFORDANCE: Allows a distributed client to mathematically define a spatial perimeter. The orchestrator restricts the egress of KinematicDeltaManifest streams exclusively to nodes residing within this specific volumetric boundary.\\n\\nEPISTEMIC BOUNDS: The temporal liveness is guillotined by `subscription_ttl_ms` (`ge=1, le=18446744073709551615`). The volume is physically restricted by the nested `VolumetricBoundingProfile`.\\n\\nMCP ROUTING TRIGGERS: Area of Interest Management, Hierarchical Spatial Hashing, Telemetry Isolation, Spatial Partitioning, Culling\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"partition_boundary\","]
#[doc = "    \"subscription_ttl_ms\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"optical_hardware_constraint_proof\": {"]
#[doc = "      \"description\": \"zk-SNARK proof that the requested spatial volume mathematically intersects with and does not exceed the physical rendering frustum of the client's authenticated optical hardware.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/ZeroKnowledgeReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"partition_boundary\": {"]
#[doc = "      \"description\": \"The 3D physical cage defining the observer's subscribed spatial area.\","]
#[doc = "      \"$ref\": \"#/$defs/VolumetricBoundingProfile\""]
#[doc = "    },"]
#[doc = "    \"subscription_ttl_ms\": {"]
#[doc = "      \"title\": \"Subscription Ttl Ms\","]
#[doc = "      \"description\": \"The exact Time-To-Live in milliseconds before the orchestrator forcibly drops the telemetry stream to prevent zombie subscriptions.\","]
#[doc = "      \"type\": \"integer\","]
#[doc = "      \"maximum\": 1.8446744073709552e+19,"]
#[doc = "      \"minimum\": 1.0"]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct VolumetricPartitionState {
    #[doc = "zk-SNARK proof that the requested spatial volume mathematically intersects with and does not exceed the physical rendering frustum of the client's authenticated optical hardware."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub optical_hardware_constraint_proof: ::std::option::Option<ZeroKnowledgeReceipt>,
    #[doc = "The 3D physical cage defining the observer's subscribed spatial area."]
    pub partition_boundary: VolumetricBoundingProfile,
    #[doc = "The exact Time-To-Live in milliseconds before the orchestrator forcibly drops the telemetry stream to prevent zombie subscriptions."]
    pub subscription_ttl_ms: ::std::num::NonZeroU64,
}
impl VolumetricPartitionState {
    pub fn builder() -> builder::VolumetricPartitionState {
        Default::default()
    }
}
#[doc = "The zero-knowledge cryptographic proof of fair random generation."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Vrf Proof\","]
#[doc = "  \"description\": \"The zero-knowledge cryptographic proof of fair random generation.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 5000000,"]
#[doc = "  \"minLength\": 10"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct VrfProof(::std::string::String);
impl ::std::ops::Deref for VrfProof {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<VrfProof> for ::std::string::String {
    fn from(value: VrfProof) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for VrfProof {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 5000000usize {
            return Err("longer than 5000000 characters".into());
        }
        if value.chars().count() < 10usize {
            return Err("shorter than 10 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for VrfProof {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for VrfProof {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for VrfProof {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for VrfProof {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "The mathematical methodology used to embed the chain of custody."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Watermark Protocol\","]
#[doc = "  \"description\": \"The mathematical methodology used to embed the chain of custody.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"merkle_dag\","]
#[doc = "    \"statistical_token\","]
#[doc = "    \"homomorphic_mac\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum WatermarkProtocol {
    #[serde(rename = "merkle_dag")]
    MerkleDag,
    #[serde(rename = "statistical_token")]
    StatisticalToken,
    #[serde(rename = "homomorphic_mac")]
    HomomorphicMac,
}
impl ::std::fmt::Display for WatermarkProtocol {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::MerkleDag => f.write_str("merkle_dag"),
            Self::StatisticalToken => f.write_str("statistical_token"),
            Self::HomomorphicMac => f.write_str("homomorphic_mac"),
        }
    }
}
impl ::std::str::FromStr for WatermarkProtocol {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "merkle_dag" => Ok(Self::MerkleDag),
            "statistical_token" => Ok(Self::StatisticalToken),
            "homomorphic_mac" => Ok(Self::HomomorphicMac),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for WatermarkProtocol {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for WatermarkProtocol {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for WatermarkProtocol {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "`WaveCollapseFunction`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Wave Collapse Function\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"enum\": ["]
#[doc = "    \"plurality_vote\","]
#[doc = "    \"highest_confidence\","]
#[doc = "    \"deterministic_compiler\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(
    :: serde :: Deserialize,
    :: serde :: Serialize,
    Clone,
    Copy,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
)]
pub enum WaveCollapseFunction {
    #[serde(rename = "plurality_vote")]
    PluralityVote,
    #[serde(rename = "highest_confidence")]
    HighestConfidence,
    #[serde(rename = "deterministic_compiler")]
    DeterministicCompiler,
}
impl ::std::fmt::Display for WaveCollapseFunction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        match *self {
            Self::PluralityVote => f.write_str("plurality_vote"),
            Self::HighestConfidence => f.write_str("highest_confidence"),
            Self::DeterministicCompiler => f.write_str("deterministic_compiler"),
        }
    }
}
impl ::std::str::FromStr for WaveCollapseFunction {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        match value {
            "plurality_vote" => Ok(Self::PluralityVote),
            "highest_confidence" => Ok(Self::HighestConfidence),
            "deterministic_compiler" => Ok(Self::DeterministicCompiler),
            _ => Err("invalid value".into()),
        }
    }
}
impl ::std::convert::TryFrom<&str> for WaveCollapseFunction {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for WaveCollapseFunction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for WaveCollapseFunction {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes Hardware-Backed Human-in-the-Loop (HITL)\nauthentication, utilizing FIDO2/WebAuthn or Post-Quantum physical security\nkeys to verify human intent. As a ...Contract suffix, this enforces rigid\nmathematical boundaries globally.\n\nCAUSAL AFFORDANCE: Translates physical human entropy (e.g., a biometric tap or\nhardware key touch) into a definitive mathematical signature via mechanism\n(URN-patterned attestation mechanism), authorizing the orchestrator to break a\nMixed-Initiative execution halt. The did_subject (DID pattern\n^did:[a-z0-9]+:.*$) anchors the human identity.\n\nEPISTEMIC BOUNDS: Physically binds the signature to a specific Merkle-DAG\ncoordinate via dag_node_nonce (UUID), strictly preventing cryptographic Replay\nAttacks. The cryptographic_payload is restricted by regex\n(^[A-Za-z0-9+/=_-]+$) to prevent injection anomalies. The liveness_challenge_hash\nis tightly bounded to SHA-256 (^[a-f0-9]{64}$) to prove real-time human presence.\n\nMCP ROUTING TRIGGERS: WebAuthn, FIDO2, Cryptographic Nonce, Replay Attack\nPrevention, Wetware Entropy"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"WetwareAttestationContract\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes Hardware-Backed Human-in-the-Loop (HITL)\\nauthentication, utilizing FIDO2/WebAuthn or Post-Quantum physical security\\nkeys to verify human intent. As a ...Contract suffix, this enforces rigid\\nmathematical boundaries globally.\\n\\nCAUSAL AFFORDANCE: Translates physical human entropy (e.g., a biometric tap or\\nhardware key touch) into a definitive mathematical signature via mechanism\\n(URN-patterned attestation mechanism), authorizing the orchestrator to break a\\nMixed-Initiative execution halt. The did_subject (DID pattern\\n^did:[a-z0-9]+:.*$) anchors the human identity.\\n\\nEPISTEMIC BOUNDS: Physically binds the signature to a specific Merkle-DAG\\ncoordinate via dag_node_nonce (UUID), strictly preventing cryptographic Replay\\nAttacks. The cryptographic_payload is restricted by regex\\n(^[A-Za-z0-9+/=_-]+$) to prevent injection anomalies. The liveness_challenge_hash\\nis tightly bounded to SHA-256 (^[a-f0-9]{64}$) to prove real-time human presence.\\n\\nMCP ROUTING TRIGGERS: WebAuthn, FIDO2, Cryptographic Nonce, Replay Attack\\nPrevention, Wetware Entropy\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"cryptographic_payload\","]
#[doc = "    \"dag_node_nonce\","]
#[doc = "    \"did_subject\","]
#[doc = "    \"liveness_challenge_hash\","]
#[doc = "    \"mechanism\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"cryptographic_payload\": {"]
#[doc = "      \"title\": \"Cryptographic Payload\","]
#[doc = "      \"description\": \"The strictly formatted (Base64url/Hex/Multibase) signature or proof.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 100000,"]
#[doc = "      \"pattern\": \"^[A-Za-z0-9+/=_-]+$\""]
#[doc = "    },"]
#[doc = "    \"dag_node_nonce\": {"]
#[doc = "      \"title\": \"Dag Node Nonce\","]
#[doc = "      \"description\": \"The cryptographic nonce tightly binding this signature to the specific Merkle-DAG node.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    },"]
#[doc = "    \"did_subject\": {"]
#[doc = "      \"title\": \"Did Subject\","]
#[doc = "      \"description\": \"The Decentralized Identifier (DID) of the human operator.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 1024,"]
#[doc = "      \"pattern\": \"^did:[a-z0-9]+:.*$\""]
#[doc = "    },"]
#[doc = "    \"liveness_challenge_hash\": {"]
#[doc = "      \"title\": \"Liveness Challenge Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the dynamic, temporally bound challenge emitted by the orchestrator to guarantee real-time human presence.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"mechanism\": {"]
#[doc = "      \"title\": \"Mechanism\","]
#[doc = "      \"description\": \"The SOTA cryptographic mechanism URN used to generate the proof.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct WetwareAttestationContract {
    #[doc = "The strictly formatted (Base64url/Hex/Multibase) signature or proof."]
    pub cryptographic_payload: CryptographicPayload,
    #[doc = "The cryptographic nonce tightly binding this signature to the specific Merkle-DAG node."]
    pub dag_node_nonce: DagNodeNonce,
    #[doc = "The Decentralized Identifier (DID) of the human operator."]
    pub did_subject: DidSubject,
    #[doc = "The SHA-256 hash of the dynamic, temporally bound challenge emitted by the orchestrator to guarantee real-time human presence."]
    pub liveness_challenge_hash: LivenessChallengeHash,
    #[doc = "The SOTA cryptographic mechanism URN used to generate the proof."]
    pub mechanism: Mechanism,
}
impl WetwareAttestationContract {
    pub fn builder() -> builder::WetwareAttestationContract {
        Default::default()
    }
}
#[doc = "The hypothesis ID that was verified."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Winning Hypothesis Cid\","]
#[doc = "  \"description\": \"The hypothesis ID that was verified.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 128,"]
#[doc = "  \"minLength\": 1,"]
#[doc = "  \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct WinningHypothesisCid(::std::string::String);
impl ::std::ops::Deref for WinningHypothesisCid {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<WinningHypothesisCid> for ::std::string::String {
    fn from(value: WinningHypothesisCid) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for WinningHypothesisCid {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 128usize {
            return Err("longer than 128 characters".into());
        }
        if value.chars().count() < 1usize {
            return Err("shorter than 1 characters".into());
        }
        static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
            ::std::sync::LazyLock::new(|| ::regress::Regex::new("^[a-zA-Z0-9_.:-]+$").unwrap());
        if PATTERN.find(value).is_none() {
            return Err("doesn't match pattern \"^[a-zA-Z0-9_.:-]+$\"".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for WinningHypothesisCid {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for WinningHypothesisCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for WinningHypothesisCid {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for WinningHypothesisCid {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Formalizes the Topos Theory representation of a fully encapsulated swarm environment, serving as the macroscopic topological envelope for the entire execution payload and enforcing the Viable System Model.\n\nCAUSAL AFFORDANCE: Physically initializes the execution DAG. This structural lock guarantees that any graph execution is mathematically anchored to a CoReason Genesis Block via `genesis_provenance`; stripping this violates Topological Consistency.\n\nEPISTEMIC BOUNDS: The topology dictates execution constraints natively without relying on legacy federated dominance validation.\n\nMCP ROUTING TRIGGERS: Topos Theory, Cybernetics, Execution Envelope, Macroscopic Topology, Viable System Model"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"WorkflowManifest\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Formalizes the Topos Theory representation of a fully encapsulated swarm environment, serving as the macroscopic topological envelope for the entire execution payload and enforcing the Viable System Model.\\n\\nCAUSAL AFFORDANCE: Physically initializes the execution DAG. This structural lock guarantees that any graph execution is mathematically anchored to a CoReason Genesis Block via `genesis_provenance`; stripping this violates Topological Consistency.\\n\\nEPISTEMIC BOUNDS: The topology dictates execution constraints natively without relying on legacy federated dominance validation.\\n\\nMCP ROUTING TRIGGERS: Topos Theory, Cybernetics, Execution Envelope, Macroscopic Topology, Viable System Model\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"genesis_provenance\","]
#[doc = "    \"manifest_version\","]
#[doc = "    \"topology\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"genesis_provenance\": {"]
#[doc = "      \"description\": \"The cryptographic chain of custody anchoring this execution graph to its genesis block.\","]
#[doc = "      \"$ref\": \"#/$defs/EpistemicProvenanceReceipt\""]
#[doc = "    },"]
#[doc = "    \"governance\": {"]
#[doc = "      \"description\": \"Macro-economic circuit breakers and TTL limits for the swarm.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/GlobalGovernancePolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"manifest_version\": {"]
#[doc = "      \"description\": \"The semantic version of this workflow manifestation schema.\","]
#[doc = "      \"$ref\": \"#/$defs/SemanticVersionState\""]
#[doc = "    },"]
#[doc = "    \"max_risk_tolerance\": {"]
#[doc = "      \"description\": \"The absolute maximum enterprise risk threshold permitted for this topology.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/RiskLevelPolicy\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"pq_signature\": {"]
#[doc = "      \"description\": \"The quantum-resistant signature securing the root execution graph.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"$ref\": \"#/$defs/PostQuantumSignatureReceipt\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"session_cid\": {"]
#[doc = "      \"title\": \"Session Cid\","]
#[doc = "      \"description\": \"The ephemeral session boundary for this execution.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"tenant_cid\": {"]
#[doc = "      \"title\": \"Tenant Cid\","]
#[doc = "      \"description\": \"The enterprise tenant boundary for this execution.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"topology\": {"]
#[doc = "      \"description\": \"The underlying topology governing execution routing.\","]
#[doc = "      \"$ref\": \"#/$defs/AnyTopologyManifest\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false,"]
#[doc = "  \"x-domain-cluster\": \"cognitive_routing\","]
#[doc = "  \"x-synergistic-classes\": ["]
#[doc = "    \"TaxonomicRoutingPolicy\","]
#[doc = "    \"CognitiveAgentNodeProfile\","]
#[doc = "    \"SemanticRelationalVectorState\""]
#[doc = "  ]"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct WorkflowManifest {
    #[doc = "The cryptographic chain of custody anchoring this execution graph to its genesis block."]
    pub genesis_provenance: EpistemicProvenanceReceipt,
    #[doc = "Macro-economic circuit breakers and TTL limits for the swarm."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub governance: ::std::option::Option<GlobalGovernancePolicy>,
    #[doc = "The semantic version of this workflow manifestation schema."]
    pub manifest_version: SemanticVersionState,
    #[doc = "The absolute maximum enterprise risk threshold permitted for this topology."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub max_risk_tolerance: ::std::option::Option<RiskLevelPolicy>,
    #[doc = "The quantum-resistant signature securing the root execution graph."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub pq_signature: ::std::option::Option<PostQuantumSignatureReceipt>,
    #[doc = "The ephemeral session boundary for this execution."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub session_cid: ::std::option::Option<::std::string::String>,
    #[doc = "The enterprise tenant boundary for this execution."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub tenant_cid: ::std::option::Option<::std::string::String>,
    #[doc = "The underlying topology governing execution routing."]
    pub topology: AnyTopologyManifest,
}
impl WorkflowManifest {
    pub fn builder() -> builder::WorkflowManifest {
        Default::default()
    }
}
#[doc = "Capability Perimeters defining context bounds."]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"Working Directory\","]
#[doc = "  \"description\": \"Capability Perimeters defining context bounds.\","]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 2000"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct WorkingDirectory(::std::string::String);
impl ::std::ops::Deref for WorkingDirectory {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<WorkingDirectory> for ::std::string::String {
    fn from(value: WorkingDirectory) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for WorkingDirectory {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 2000usize {
            return Err("longer than 2000 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for WorkingDirectory {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String> for WorkingDirectory {
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String> for WorkingDirectory {
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for WorkingDirectory {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = "CoReason Shared Kernel Ontology\n\nAGENT INSTRUCTION: Enforces Computational Integrity via Verifiable Computing, utilizing succinct non-interactive arguments of knowledge (zk-SNARKs/STARKs) to prove execution correctness without revealing private state.\n\nCAUSAL AFFORDANCE: Authorizes the zero-trust orchestrator to accept and merge off-chain state mutations by verifying the `cryptographic_blob` against the `public_inputs_hash` and `verifier_key_cid`.\n\nEPISTEMIC BOUNDS: `proof_protocol` is constrained via URN pattern. `public_inputs_hash` guarantees linkage via SHA-256 regex `^[a-f0-9]{64}$`. `cryptographic_blob` is capped at `max_length=5000000`. `latent_state_commitments` restricts dictionary to `le=18446744073709551615`.\n\nMCP ROUTING TRIGGERS: Computational Integrity, Verifiable Computing, Zero-Knowledge Proofs, zk-SNARK, State Attestation"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"title\": \"ZeroKnowledgeReceipt\","]
#[doc = "  \"description\": \"CoReason Shared Kernel Ontology\\n\\nAGENT INSTRUCTION: Enforces Computational Integrity via Verifiable Computing, utilizing succinct non-interactive arguments of knowledge (zk-SNARKs/STARKs) to prove execution correctness without revealing private state.\\n\\nCAUSAL AFFORDANCE: Authorizes the zero-trust orchestrator to accept and merge off-chain state mutations by verifying the `cryptographic_blob` against the `public_inputs_hash` and `verifier_key_cid`.\\n\\nEPISTEMIC BOUNDS: `proof_protocol` is constrained via URN pattern. `public_inputs_hash` guarantees linkage via SHA-256 regex `^[a-f0-9]{64}$`. `cryptographic_blob` is capped at `max_length=5000000`. `latent_state_commitments` restricts dictionary to `le=18446744073709551615`.\\n\\nMCP ROUTING TRIGGERS: Computational Integrity, Verifiable Computing, Zero-Knowledge Proofs, zk-SNARK, State Attestation\","]
#[doc = "  \"type\": \"object\","]
#[doc = "  \"required\": ["]
#[doc = "    \"cryptographic_blob\","]
#[doc = "    \"logical_circuit_hash\","]
#[doc = "    \"proof_protocol\","]
#[doc = "    \"public_inputs_hash\","]
#[doc = "    \"verifier_key_cid\""]
#[doc = "  ],"]
#[doc = "  \"properties\": {"]
#[doc = "    \"cryptographic_blob\": {"]
#[doc = "      \"title\": \"Cryptographic Blob\","]
#[doc = "      \"description\": \"The base64-encoded succinct cryptographic proof payload.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 5000000"]
#[doc = "    },"]
#[doc = "    \"latent_state_commitments\": {"]
#[doc = "      \"title\": \"Latent State Commitments\","]
#[doc = "      \"description\": \"Cryptographic bindings (hashes) of intermediate residual stream states to prevent activation spoofing.\","]
#[doc = "      \"type\": \"object\","]
#[doc = "      \"additionalProperties\": {"]
#[doc = "        \"type\": \"string\","]
#[doc = "        \"maxLength\": 100"]
#[doc = "      },"]
#[doc = "      \"le\": 18446744073709551615"]
#[doc = "    },"]
#[doc = "    \"logical_circuit_hash\": {"]
#[doc = "      \"title\": \"Logical Circuit Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the exact prompt, weights, and constraints evaluated by the prover.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"proof_protocol\": {"]
#[doc = "      \"title\": \"Proof Protocol\","]
#[doc = "      \"description\": \"The URN of the mathematical dialect of the cryptographic proof (e.g., 'urn:coreason:zk:snark').\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"pattern\": \"^urn:coreason:.*$\""]
#[doc = "    },"]
#[doc = "    \"public_inputs_hash\": {"]
#[doc = "      \"title\": \"Public Inputs Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the public inputs (e.g., prompt, Lamport clock) anchoring this proof to the specific state index.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-f0-9]{64}$\""]
#[doc = "    },"]
#[doc = "    \"temporal_circuit_hash\": {"]
#[doc = "      \"title\": \"Temporal Circuit Hash\","]
#[doc = "      \"description\": \"The SHA-256 hash of the temporal verification circuit.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"temporal_interval_proof\": {"]
#[doc = "      \"title\": \"Temporal Interval Proof\","]
#[doc = "      \"description\": \"The zk-SNARK payload specific to time inequalities. Proves chronological sequence without exposing exact timestamps.\","]
#[doc = "      \"anyOf\": ["]
#[doc = "        {"]
#[doc = "          \"type\": \"string\""]
#[doc = "        },"]
#[doc = "        {"]
#[doc = "          \"type\": \"null\""]
#[doc = "        }"]
#[doc = "      ]"]
#[doc = "    },"]
#[doc = "    \"verifier_key_cid\": {"]
#[doc = "      \"title\": \"Verifier Key Cid\","]
#[doc = "      \"description\": \"A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the public evaluation key.\","]
#[doc = "      \"type\": \"string\","]
#[doc = "      \"maxLength\": 128,"]
#[doc = "      \"minLength\": 1,"]
#[doc = "      \"pattern\": \"^[a-zA-Z0-9_.:-]+$\""]
#[doc = "    }"]
#[doc = "  },"]
#[doc = "  \"additionalProperties\": false"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ZeroKnowledgeReceipt {
    #[doc = "The base64-encoded succinct cryptographic proof payload."]
    pub cryptographic_blob: CryptographicBlob,
    #[doc = "Cryptographic bindings (hashes) of intermediate residual stream states to prevent activation spoofing."]
    #[serde(
        default,
        skip_serializing_if = ":: std :: collections :: HashMap::is_empty"
    )]
    pub latent_state_commitments: ::std::collections::HashMap<
        ::std::string::String,
        ZeroKnowledgeReceiptLatentStateCommitmentsValue,
    >,
    #[doc = "The SHA-256 hash of the exact prompt, weights, and constraints evaluated by the prover."]
    pub logical_circuit_hash: LogicalCircuitHash,
    #[doc = "The URN of the mathematical dialect of the cryptographic proof (e.g., 'urn:coreason:zk:snark')."]
    pub proof_protocol: ProofProtocol,
    #[doc = "The SHA-256 hash of the public inputs (e.g., prompt, Lamport clock) anchoring this proof to the specific state index."]
    pub public_inputs_hash: PublicInputsHash,
    #[doc = "The SHA-256 hash of the temporal verification circuit."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub temporal_circuit_hash: ::std::option::Option<::std::string::String>,
    #[doc = "The zk-SNARK payload specific to time inequalities. Proves chronological sequence without exposing exact timestamps."]
    #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
    pub temporal_interval_proof: ::std::option::Option<::std::string::String>,
    #[doc = "A Content Identifier (CID) acting as a cryptographic Lineage Watermark binding this node to the public evaluation key."]
    pub verifier_key_cid: VerifierKeyCid,
}
impl ZeroKnowledgeReceipt {
    pub fn builder() -> builder::ZeroKnowledgeReceipt {
        Default::default()
    }
}
#[doc = "`ZeroKnowledgeReceiptLatentStateCommitmentsValue`"]
#[doc = r""]
#[doc = r" <details><summary>JSON schema</summary>"]
#[doc = r""]
#[doc = r" ```json"]
#[doc = "{"]
#[doc = "  \"type\": \"string\","]
#[doc = "  \"maxLength\": 100"]
#[doc = "}"]
#[doc = r" ```"]
#[doc = r" </details>"]
#[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[serde(transparent)]
pub struct ZeroKnowledgeReceiptLatentStateCommitmentsValue(::std::string::String);
impl ::std::ops::Deref for ZeroKnowledgeReceiptLatentStateCommitmentsValue {
    type Target = ::std::string::String;
    fn deref(&self) -> &::std::string::String {
        &self.0
    }
}
impl ::std::convert::From<ZeroKnowledgeReceiptLatentStateCommitmentsValue>
    for ::std::string::String
{
    fn from(value: ZeroKnowledgeReceiptLatentStateCommitmentsValue) -> Self {
        value.0
    }
}
impl ::std::str::FromStr for ZeroKnowledgeReceiptLatentStateCommitmentsValue {
    type Err = self::error::ConversionError;
    fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        if value.chars().count() > 100usize {
            return Err("longer than 100 characters".into());
        }
        Ok(Self(value.to_string()))
    }
}
impl ::std::convert::TryFrom<&str> for ZeroKnowledgeReceiptLatentStateCommitmentsValue {
    type Error = self::error::ConversionError;
    fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<&::std::string::String>
    for ZeroKnowledgeReceiptLatentStateCommitmentsValue
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: &::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl ::std::convert::TryFrom<::std::string::String>
    for ZeroKnowledgeReceiptLatentStateCommitmentsValue
{
    type Error = self::error::ConversionError;
    fn try_from(
        value: ::std::string::String,
    ) -> ::std::result::Result<Self, self::error::ConversionError> {
        value.parse()
    }
}
impl<'de> ::serde::Deserialize<'de> for ZeroKnowledgeReceiptLatentStateCommitmentsValue {
    fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        ::std::string::String::deserialize(deserializer)?
            .parse()
            .map_err(|e: self::error::ConversionError| {
                <D::Error as ::serde::de::Error>::custom(e.to_string())
            })
    }
}
#[doc = r" Types for composing complex structures."]
pub mod builder {
    #[derive(Clone, Debug)]
    pub struct ActivationSteeringContract {
        scaling_factor: ::std::result::Result<f64, ::std::string::String>,
        steering_vector_hash:
            ::std::result::Result<super::SteeringVectorHash, ::std::string::String>,
        target_hook_points: ::std::result::Result<
            ::std::vec::Vec<super::TargetHookPointsItem>,
            ::std::string::String,
        >,
        vector_modality: ::std::result::Result<super::VectorModality, ::std::string::String>,
    }
    impl ::std::default::Default for ActivationSteeringContract {
        fn default() -> Self {
            Self {
                scaling_factor: Err("no value supplied for scaling_factor".to_string()),
                steering_vector_hash: Err("no value supplied for steering_vector_hash".to_string()),
                target_hook_points: Err("no value supplied for target_hook_points".to_string()),
                vector_modality: Err("no value supplied for vector_modality".to_string()),
            }
        }
    }
    impl ActivationSteeringContract {
        pub fn scaling_factor<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.scaling_factor = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for scaling_factor: {e}"));
            self
        }
        pub fn steering_vector_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SteeringVectorHash>,
            T::Error: ::std::fmt::Display,
        {
            self.steering_vector_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for steering_vector_hash: {e}")
            });
            self
        }
        pub fn target_hook_points<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::TargetHookPointsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.target_hook_points = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_hook_points: {e}")
            });
            self
        }
        pub fn vector_modality<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VectorModality>,
            T::Error: ::std::fmt::Display,
        {
            self.vector_modality = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for vector_modality: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ActivationSteeringContract> for super::ActivationSteeringContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ActivationSteeringContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                scaling_factor: value.scaling_factor?,
                steering_vector_hash: value.steering_vector_hash?,
                target_hook_points: value.target_hook_points?,
                vector_modality: value.vector_modality?,
            })
        }
    }
    impl ::std::convert::From<super::ActivationSteeringContract> for ActivationSteeringContract {
        fn from(value: super::ActivationSteeringContract) -> Self {
            Self {
                scaling_factor: Ok(value.scaling_factor),
                steering_vector_hash: Ok(value.steering_vector_hash),
                target_hook_points: Ok(value.target_hook_points),
                vector_modality: Ok(value.vector_modality),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ActiveInferenceContract {
        execution_cost_budget_magnitude: ::std::result::Result<u64, ::std::string::String>,
        expected_information_gain: ::std::result::Result<f64, ::std::string::String>,
        selected_tool_name: ::std::result::Result<super::SelectedToolName, ::std::string::String>,
        target_condition_cid:
            ::std::result::Result<super::TargetConditionCid, ::std::string::String>,
        target_hypothesis_cid:
            ::std::result::Result<super::TargetHypothesisCid, ::std::string::String>,
        task_cid: ::std::result::Result<super::TaskCid, ::std::string::String>,
    }
    impl ::std::default::Default for ActiveInferenceContract {
        fn default() -> Self {
            Self {
                execution_cost_budget_magnitude: Err(
                    "no value supplied for execution_cost_budget_magnitude".to_string(),
                ),
                expected_information_gain: Err(
                    "no value supplied for expected_information_gain".to_string()
                ),
                selected_tool_name: Err("no value supplied for selected_tool_name".to_string()),
                target_condition_cid: Err("no value supplied for target_condition_cid".to_string()),
                target_hypothesis_cid: Err(
                    "no value supplied for target_hypothesis_cid".to_string()
                ),
                task_cid: Err("no value supplied for task_cid".to_string()),
            }
        }
    }
    impl ActiveInferenceContract {
        pub fn execution_cost_budget_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.execution_cost_budget_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for execution_cost_budget_magnitude: {e}")
            });
            self
        }
        pub fn expected_information_gain<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.expected_information_gain = value.try_into().map_err(|e| {
                format!("error converting supplied value for expected_information_gain: {e}")
            });
            self
        }
        pub fn selected_tool_name<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SelectedToolName>,
            T::Error: ::std::fmt::Display,
        {
            self.selected_tool_name = value.try_into().map_err(|e| {
                format!("error converting supplied value for selected_tool_name: {e}")
            });
            self
        }
        pub fn target_condition_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetConditionCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_condition_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_condition_cid: {e}")
            });
            self
        }
        pub fn target_hypothesis_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetHypothesisCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_hypothesis_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_hypothesis_cid: {e}")
            });
            self
        }
        pub fn task_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TaskCid>,
            T::Error: ::std::fmt::Display,
        {
            self.task_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for task_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ActiveInferenceContract> for super::ActiveInferenceContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ActiveInferenceContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                execution_cost_budget_magnitude: value.execution_cost_budget_magnitude?,
                expected_information_gain: value.expected_information_gain?,
                selected_tool_name: value.selected_tool_name?,
                target_condition_cid: value.target_condition_cid?,
                target_hypothesis_cid: value.target_hypothesis_cid?,
                task_cid: value.task_cid?,
            })
        }
    }
    impl ::std::convert::From<super::ActiveInferenceContract> for ActiveInferenceContract {
        fn from(value: super::ActiveInferenceContract) -> Self {
            Self {
                execution_cost_budget_magnitude: Ok(value.execution_cost_budget_magnitude),
                expected_information_gain: Ok(value.expected_information_gain),
                selected_tool_name: Ok(value.selected_tool_name),
                target_condition_cid: Ok(value.target_condition_cid),
                target_hypothesis_cid: Ok(value.target_hypothesis_cid),
                task_cid: Ok(value.task_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AdjudicationIntent {
        deadlocked_claims: ::std::result::Result<
            ::std::vec::Vec<super::DeadlockedClaimsItem>,
            ::std::string::String,
        >,
        resolution_schema: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        timeout_action: ::std::result::Result<super::TimeoutAction, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for AdjudicationIntent {
        fn default() -> Self {
            Self {
                deadlocked_claims: Err("no value supplied for deadlocked_claims".to_string()),
                resolution_schema: Err("no value supplied for resolution_schema".to_string()),
                timeout_action: Err("no value supplied for timeout_action".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl AdjudicationIntent {
        pub fn deadlocked_claims<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::DeadlockedClaimsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.deadlocked_claims = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for deadlocked_claims: {e}"));
            self
        }
        pub fn resolution_schema<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.resolution_schema = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for resolution_schema: {e}"));
            self
        }
        pub fn timeout_action<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TimeoutAction>,
            T::Error: ::std::fmt::Display,
        {
            self.timeout_action = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timeout_action: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<AdjudicationIntent> for super::AdjudicationIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AdjudicationIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                deadlocked_claims: value.deadlocked_claims?,
                resolution_schema: value.resolution_schema?,
                timeout_action: value.timeout_action?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::AdjudicationIntent> for AdjudicationIntent {
        fn from(value: super::AdjudicationIntent) -> Self {
            Self {
                deadlocked_claims: Ok(value.deadlocked_claims),
                resolution_schema: Ok(value.resolution_schema),
                timeout_action: Ok(value.timeout_action),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AdjudicationReceipt {
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        passed: ::std::result::Result<bool, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        reasoning: ::std::result::Result<super::Reasoning, ::std::string::String>,
        rubric_cid: ::std::result::Result<super::RubricCid, ::std::string::String>,
        score: ::std::result::Result<i64, ::std::string::String>,
        target_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for AdjudicationReceipt {
        fn default() -> Self {
            Self {
                event_cid: Err("no value supplied for event_cid".to_string()),
                passed: Err("no value supplied for passed".to_string()),
                prior_event_hash: Ok(Default::default()),
                reasoning: Err("no value supplied for reasoning".to_string()),
                rubric_cid: Err("no value supplied for rubric_cid".to_string()),
                score: Err("no value supplied for score".to_string()),
                target_node_cid: Err("no value supplied for target_node_cid".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl AdjudicationReceipt {
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn passed<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.passed = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for passed: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn reasoning<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Reasoning>,
            T::Error: ::std::fmt::Display,
        {
            self.reasoning = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for reasoning: {e}"));
            self
        }
        pub fn rubric_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RubricCid>,
            T::Error: ::std::fmt::Display,
        {
            self.rubric_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for rubric_cid: {e}"));
            self
        }
        pub fn score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<i64>,
            T::Error: ::std::fmt::Display,
        {
            self.score = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for score: {e}"));
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<AdjudicationReceipt> for super::AdjudicationReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AdjudicationReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                event_cid: value.event_cid?,
                passed: value.passed?,
                prior_event_hash: value.prior_event_hash?,
                reasoning: value.reasoning?,
                rubric_cid: value.rubric_cid?,
                score: value.score?,
                target_node_cid: value.target_node_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::AdjudicationReceipt> for AdjudicationReceipt {
        fn from(value: super::AdjudicationReceipt) -> Self {
            Self {
                event_cid: Ok(value.event_cid),
                passed: Ok(value.passed),
                prior_event_hash: Ok(value.prior_event_hash),
                reasoning: Ok(value.reasoning),
                rubric_cid: Ok(value.rubric_cid),
                score: Ok(value.score),
                target_node_cid: Ok(value.target_node_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AdjudicationRubricProfile {
        criteria: ::std::result::Result<
            ::std::vec::Vec<super::GradingCriterionProfile>,
            ::std::string::String,
        >,
        passing_threshold: ::std::result::Result<f64, ::std::string::String>,
        rubric_cid: ::std::result::Result<super::RubricCid, ::std::string::String>,
    }
    impl ::std::default::Default for AdjudicationRubricProfile {
        fn default() -> Self {
            Self {
                criteria: Err("no value supplied for criteria".to_string()),
                passing_threshold: Err("no value supplied for passing_threshold".to_string()),
                rubric_cid: Err("no value supplied for rubric_cid".to_string()),
            }
        }
    }
    impl AdjudicationRubricProfile {
        pub fn criteria<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::GradingCriterionProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.criteria = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for criteria: {e}"));
            self
        }
        pub fn passing_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.passing_threshold = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for passing_threshold: {e}"));
            self
        }
        pub fn rubric_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RubricCid>,
            T::Error: ::std::fmt::Display,
        {
            self.rubric_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for rubric_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<AdjudicationRubricProfile> for super::AdjudicationRubricProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AdjudicationRubricProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                criteria: value.criteria?,
                passing_threshold: value.passing_threshold?,
                rubric_cid: value.rubric_cid?,
            })
        }
    }
    impl ::std::convert::From<super::AdjudicationRubricProfile> for AdjudicationRubricProfile {
        fn from(value: super::AdjudicationRubricProfile) -> Self {
            Self {
                criteria: Ok(value.criteria),
                passing_threshold: Ok(value.passing_threshold),
                rubric_cid: Ok(value.rubric_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AdversarialMarketTopologyManifest {
        adjudicator_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        blue_team_cids:
            ::std::result::Result<::std::vec::Vec<super::NodeCidState>, ::std::string::String>,
        market_rules: ::std::result::Result<super::PredictionMarketPolicy, ::std::string::String>,
        red_team_cids:
            ::std::result::Result<::std::vec::Vec<super::NodeCidState>, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for AdversarialMarketTopologyManifest {
        fn default() -> Self {
            Self {
                adjudicator_cid: Err("no value supplied for adjudicator_cid".to_string()),
                blue_team_cids: Err("no value supplied for blue_team_cids".to_string()),
                market_rules: Err("no value supplied for market_rules".to_string()),
                red_team_cids: Err("no value supplied for red_team_cids".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl AdversarialMarketTopologyManifest {
        pub fn adjudicator_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.adjudicator_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for adjudicator_cid: {e}"));
            self
        }
        pub fn blue_team_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.blue_team_cids = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for blue_team_cids: {e}"));
            self
        }
        pub fn market_rules<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PredictionMarketPolicy>,
            T::Error: ::std::fmt::Display,
        {
            self.market_rules = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for market_rules: {e}"));
            self
        }
        pub fn red_team_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.red_team_cids = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for red_team_cids: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<AdversarialMarketTopologyManifest>
        for super::AdversarialMarketTopologyManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AdversarialMarketTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                adjudicator_cid: value.adjudicator_cid?,
                blue_team_cids: value.blue_team_cids?,
                market_rules: value.market_rules?,
                red_team_cids: value.red_team_cids?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::AdversarialMarketTopologyManifest>
        for AdversarialMarketTopologyManifest
    {
        fn from(value: super::AdversarialMarketTopologyManifest) -> Self {
            Self {
                adjudicator_cid: Ok(value.adjudicator_cid),
                blue_team_cids: Ok(value.blue_team_cids),
                market_rules: Ok(value.market_rules),
                red_team_cids: Ok(value.red_team_cids),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AgentAttestationReceipt {
        capability_merkle_root:
            ::std::result::Result<super::CapabilityMerkleRoot, ::std::string::String>,
        credential_presentations: ::std::result::Result<
            ::std::vec::Vec<super::VerifiableCredentialPresentationReceipt>,
            ::std::string::String,
        >,
        developer_signature:
            ::std::result::Result<super::DeveloperSignature, ::std::string::String>,
        training_lineage_hash:
            ::std::result::Result<super::TrainingLineageHash, ::std::string::String>,
    }
    impl ::std::default::Default for AgentAttestationReceipt {
        fn default() -> Self {
            Self {
                capability_merkle_root: Err(
                    "no value supplied for capability_merkle_root".to_string()
                ),
                credential_presentations: Ok(Default::default()),
                developer_signature: Err("no value supplied for developer_signature".to_string()),
                training_lineage_hash: Err(
                    "no value supplied for training_lineage_hash".to_string()
                ),
            }
        }
    }
    impl AgentAttestationReceipt {
        pub fn capability_merkle_root<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CapabilityMerkleRoot>,
            T::Error: ::std::fmt::Display,
        {
            self.capability_merkle_root = value.try_into().map_err(|e| {
                format!("error converting supplied value for capability_merkle_root: {e}")
            });
            self
        }
        pub fn credential_presentations<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::vec::Vec<super::VerifiableCredentialPresentationReceipt>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.credential_presentations = value.try_into().map_err(|e| {
                format!("error converting supplied value for credential_presentations: {e}")
            });
            self
        }
        pub fn developer_signature<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DeveloperSignature>,
            T::Error: ::std::fmt::Display,
        {
            self.developer_signature = value.try_into().map_err(|e| {
                format!("error converting supplied value for developer_signature: {e}")
            });
            self
        }
        pub fn training_lineage_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TrainingLineageHash>,
            T::Error: ::std::fmt::Display,
        {
            self.training_lineage_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for training_lineage_hash: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<AgentAttestationReceipt> for super::AgentAttestationReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AgentAttestationReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                capability_merkle_root: value.capability_merkle_root?,
                credential_presentations: value.credential_presentations?,
                developer_signature: value.developer_signature?,
                training_lineage_hash: value.training_lineage_hash?,
            })
        }
    }
    impl ::std::convert::From<super::AgentAttestationReceipt> for AgentAttestationReceipt {
        fn from(value: super::AgentAttestationReceipt) -> Self {
            Self {
                capability_merkle_root: Ok(value.capability_merkle_root),
                credential_presentations: Ok(value.credential_presentations),
                developer_signature: Ok(value.developer_signature),
                training_lineage_hash: Ok(value.training_lineage_hash),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AgentBidIntent {
        agent_cid: ::std::result::Result<super::AgentCid, ::std::string::String>,
        confidence_score: ::std::result::Result<f64, ::std::string::String>,
        estimated_carbon_gco2eq: ::std::result::Result<f64, ::std::string::String>,
        estimated_cost_magnitude: ::std::result::Result<u64, ::std::string::String>,
        estimated_latency_ms: ::std::result::Result<u64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for AgentBidIntent {
        fn default() -> Self {
            Self {
                agent_cid: Err("no value supplied for agent_cid".to_string()),
                confidence_score: Err("no value supplied for confidence_score".to_string()),
                estimated_carbon_gco2eq: Err(
                    "no value supplied for estimated_carbon_gco2eq".to_string()
                ),
                estimated_cost_magnitude: Err(
                    "no value supplied for estimated_cost_magnitude".to_string()
                ),
                estimated_latency_ms: Err("no value supplied for estimated_latency_ms".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl AgentBidIntent {
        pub fn agent_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AgentCid>,
            T::Error: ::std::fmt::Display,
        {
            self.agent_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for agent_cid: {e}"));
            self
        }
        pub fn confidence_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.confidence_score = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for confidence_score: {e}"));
            self
        }
        pub fn estimated_carbon_gco2eq<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.estimated_carbon_gco2eq = value.try_into().map_err(|e| {
                format!("error converting supplied value for estimated_carbon_gco2eq: {e}")
            });
            self
        }
        pub fn estimated_cost_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.estimated_cost_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for estimated_cost_magnitude: {e}")
            });
            self
        }
        pub fn estimated_latency_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.estimated_latency_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for estimated_latency_ms: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<AgentBidIntent> for super::AgentBidIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AgentBidIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                agent_cid: value.agent_cid?,
                confidence_score: value.confidence_score?,
                estimated_carbon_gco2eq: value.estimated_carbon_gco2eq?,
                estimated_cost_magnitude: value.estimated_cost_magnitude?,
                estimated_latency_ms: value.estimated_latency_ms?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::AgentBidIntent> for AgentBidIntent {
        fn from(value: super::AgentBidIntent) -> Self {
            Self {
                agent_cid: Ok(value.agent_cid),
                confidence_score: Ok(value.confidence_score),
                estimated_carbon_gco2eq: Ok(value.estimated_carbon_gco2eq),
                estimated_cost_magnitude: Ok(value.estimated_cost_magnitude),
                estimated_latency_ms: Ok(value.estimated_latency_ms),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AlgebraicRefinementContract {
        mathematical_predicate:
            ::std::result::Result<super::MathematicalPredicate, ::std::string::String>,
        target_property: ::std::result::Result<super::TargetProperty, ::std::string::String>,
    }
    impl ::std::default::Default for AlgebraicRefinementContract {
        fn default() -> Self {
            Self {
                mathematical_predicate: Err(
                    "no value supplied for mathematical_predicate".to_string()
                ),
                target_property: Err("no value supplied for target_property".to_string()),
            }
        }
    }
    impl AlgebraicRefinementContract {
        pub fn mathematical_predicate<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MathematicalPredicate>,
            T::Error: ::std::fmt::Display,
        {
            self.mathematical_predicate = value.try_into().map_err(|e| {
                format!("error converting supplied value for mathematical_predicate: {e}")
            });
            self
        }
        pub fn target_property<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetProperty>,
            T::Error: ::std::fmt::Display,
        {
            self.target_property = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_property: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<AlgebraicRefinementContract> for super::AlgebraicRefinementContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AlgebraicRefinementContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                mathematical_predicate: value.mathematical_predicate?,
                target_property: value.target_property?,
            })
        }
    }
    impl ::std::convert::From<super::AlgebraicRefinementContract> for AlgebraicRefinementContract {
        fn from(value: super::AlgebraicRefinementContract) -> Self {
            Self {
                mathematical_predicate: Ok(value.mathematical_predicate),
                target_property: Ok(value.target_property),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AmbientState {
        epistemic_entropy_score:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        progress: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        status_message: ::std::result::Result<super::StatusMessage, ::std::string::String>,
        thermodynamic_burn_rate:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
    }
    impl ::std::default::Default for AmbientState {
        fn default() -> Self {
            Self {
                epistemic_entropy_score: Ok(Default::default()),
                progress: Ok(Default::default()),
                status_message: Err("no value supplied for status_message".to_string()),
                thermodynamic_burn_rate: Ok(Default::default()),
            }
        }
    }
    impl AmbientState {
        pub fn epistemic_entropy_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_entropy_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_entropy_score: {e}")
            });
            self
        }
        pub fn progress<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.progress = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for progress: {e}"));
            self
        }
        pub fn status_message<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StatusMessage>,
            T::Error: ::std::fmt::Display,
        {
            self.status_message = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for status_message: {e}"));
            self
        }
        pub fn thermodynamic_burn_rate<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.thermodynamic_burn_rate = value.try_into().map_err(|e| {
                format!("error converting supplied value for thermodynamic_burn_rate: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<AmbientState> for super::AmbientState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AmbientState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                epistemic_entropy_score: value.epistemic_entropy_score?,
                progress: value.progress?,
                status_message: value.status_message?,
                thermodynamic_burn_rate: value.thermodynamic_burn_rate?,
            })
        }
    }
    impl ::std::convert::From<super::AmbientState> for AmbientState {
        fn from(value: super::AmbientState) -> Self {
            Self {
                epistemic_entropy_score: Ok(value.epistemic_entropy_score),
                progress: Ok(value.progress),
                status_message: Ok(value.status_message),
                thermodynamic_burn_rate: Ok(value.thermodynamic_burn_rate),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AnalogicalMappingTask {
        divergence_temperature_override: ::std::result::Result<f64, ::std::string::String>,
        required_isomorphisms: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        source_domain: ::std::result::Result<super::SourceDomain, ::std::string::String>,
        target_domain: ::std::result::Result<super::TargetDomain, ::std::string::String>,
        task_cid: ::std::result::Result<super::TaskCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for AnalogicalMappingTask {
        fn default() -> Self {
            Self {
                divergence_temperature_override: Err(
                    "no value supplied for divergence_temperature_override".to_string(),
                ),
                required_isomorphisms: Err(
                    "no value supplied for required_isomorphisms".to_string()
                ),
                source_domain: Err("no value supplied for source_domain".to_string()),
                target_domain: Err("no value supplied for target_domain".to_string()),
                task_cid: Err("no value supplied for task_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl AnalogicalMappingTask {
        pub fn divergence_temperature_override<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.divergence_temperature_override = value.try_into().map_err(|e| {
                format!("error converting supplied value for divergence_temperature_override: {e}")
            });
            self
        }
        pub fn required_isomorphisms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.required_isomorphisms = value.try_into().map_err(|e| {
                format!("error converting supplied value for required_isomorphisms: {e}")
            });
            self
        }
        pub fn source_domain<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceDomain>,
            T::Error: ::std::fmt::Display,
        {
            self.source_domain = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_domain: {e}"));
            self
        }
        pub fn target_domain<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetDomain>,
            T::Error: ::std::fmt::Display,
        {
            self.target_domain = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_domain: {e}"));
            self
        }
        pub fn task_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TaskCid>,
            T::Error: ::std::fmt::Display,
        {
            self.task_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for task_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<AnalogicalMappingTask> for super::AnalogicalMappingTask {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AnalogicalMappingTask,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                divergence_temperature_override: value.divergence_temperature_override?,
                required_isomorphisms: value.required_isomorphisms?,
                source_domain: value.source_domain?,
                target_domain: value.target_domain?,
                task_cid: value.task_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::AnalogicalMappingTask> for AnalogicalMappingTask {
        fn from(value: super::AnalogicalMappingTask) -> Self {
            Self {
                divergence_temperature_override: Ok(value.divergence_temperature_override),
                required_isomorphisms: Ok(value.required_isomorphisms),
                source_domain: Ok(value.source_domain),
                target_domain: Ok(value.target_domain),
                task_cid: Ok(value.task_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AnchoringPolicy {
        anchor_prompt_hash: ::std::result::Result<super::AnchorPromptHash, ::std::string::String>,
        max_semantic_drift: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for AnchoringPolicy {
        fn default() -> Self {
            Self {
                anchor_prompt_hash: Err("no value supplied for anchor_prompt_hash".to_string()),
                max_semantic_drift: Err("no value supplied for max_semantic_drift".to_string()),
            }
        }
    }
    impl AnchoringPolicy {
        pub fn anchor_prompt_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AnchorPromptHash>,
            T::Error: ::std::fmt::Display,
        {
            self.anchor_prompt_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for anchor_prompt_hash: {e}")
            });
            self
        }
        pub fn max_semantic_drift<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_semantic_drift = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_semantic_drift: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<AnchoringPolicy> for super::AnchoringPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AnchoringPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                anchor_prompt_hash: value.anchor_prompt_hash?,
                max_semantic_drift: value.max_semantic_drift?,
            })
        }
    }
    impl ::std::convert::From<super::AnchoringPolicy> for AnchoringPolicy {
        fn from(value: super::AnchoringPolicy) -> Self {
            Self {
                anchor_prompt_hash: Ok(value.anchor_prompt_hash),
                max_semantic_drift: Ok(value.max_semantic_drift),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ArtifactCorruptionEvent {
        artifact_cid: ::std::result::Result<super::ArtifactCid, ::std::string::String>,
        corruption_class: ::std::result::Result<super::CorruptionClass, ::std::string::String>,
        diagnostic_hash: ::std::result::Result<super::DiagnosticHash, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for ArtifactCorruptionEvent {
        fn default() -> Self {
            Self {
                artifact_cid: Err("no value supplied for artifact_cid".to_string()),
                corruption_class: Err("no value supplied for corruption_class".to_string()),
                diagnostic_hash: Err("no value supplied for diagnostic_hash".to_string()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                prior_event_hash: Ok(Default::default()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl ArtifactCorruptionEvent {
        pub fn artifact_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ArtifactCid>,
            T::Error: ::std::fmt::Display,
        {
            self.artifact_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for artifact_cid: {e}"));
            self
        }
        pub fn corruption_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CorruptionClass>,
            T::Error: ::std::fmt::Display,
        {
            self.corruption_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for corruption_class: {e}"));
            self
        }
        pub fn diagnostic_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DiagnosticHash>,
            T::Error: ::std::fmt::Display,
        {
            self.diagnostic_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for diagnostic_hash: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ArtifactCorruptionEvent> for super::ArtifactCorruptionEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ArtifactCorruptionEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                artifact_cid: value.artifact_cid?,
                corruption_class: value.corruption_class?,
                diagnostic_hash: value.diagnostic_hash?,
                event_cid: value.event_cid?,
                prior_event_hash: value.prior_event_hash?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::ArtifactCorruptionEvent> for ArtifactCorruptionEvent {
        fn from(value: super::ArtifactCorruptionEvent) -> Self {
            Self {
                artifact_cid: Ok(value.artifact_cid),
                corruption_class: Ok(value.corruption_class),
                diagnostic_hash: Ok(value.diagnostic_hash),
                event_cid: Ok(value.event_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AstGradientReceipt {
        actual_type_geometry:
            ::std::result::Result<super::ActualTypeGeometry, ::std::string::String>,
        ast_node_pointer: ::std::result::Result<super::AstNodePointer, ::std::string::String>,
        compilation_attempt_cid:
            ::std::result::Result<super::CompilationAttemptCid, ::std::string::String>,
        expected_type_geometry:
            ::std::result::Result<super::ExpectedTypeGeometry, ::std::string::String>,
        structural_loss_vector: ::std::result::Result<
            ::std::option::Option<super::VectorEmbeddingState>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for AstGradientReceipt {
        fn default() -> Self {
            Self {
                actual_type_geometry: Err("no value supplied for actual_type_geometry".to_string()),
                ast_node_pointer: Err("no value supplied for ast_node_pointer".to_string()),
                compilation_attempt_cid: Err(
                    "no value supplied for compilation_attempt_cid".to_string()
                ),
                expected_type_geometry: Err(
                    "no value supplied for expected_type_geometry".to_string()
                ),
                structural_loss_vector: Ok(Default::default()),
            }
        }
    }
    impl AstGradientReceipt {
        pub fn actual_type_geometry<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ActualTypeGeometry>,
            T::Error: ::std::fmt::Display,
        {
            self.actual_type_geometry = value.try_into().map_err(|e| {
                format!("error converting supplied value for actual_type_geometry: {e}")
            });
            self
        }
        pub fn ast_node_pointer<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AstNodePointer>,
            T::Error: ::std::fmt::Display,
        {
            self.ast_node_pointer = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for ast_node_pointer: {e}"));
            self
        }
        pub fn compilation_attempt_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CompilationAttemptCid>,
            T::Error: ::std::fmt::Display,
        {
            self.compilation_attempt_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for compilation_attempt_cid: {e}")
            });
            self
        }
        pub fn expected_type_geometry<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ExpectedTypeGeometry>,
            T::Error: ::std::fmt::Display,
        {
            self.expected_type_geometry = value.try_into().map_err(|e| {
                format!("error converting supplied value for expected_type_geometry: {e}")
            });
            self
        }
        pub fn structural_loss_vector<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VectorEmbeddingState>>,
            T::Error: ::std::fmt::Display,
        {
            self.structural_loss_vector = value.try_into().map_err(|e| {
                format!("error converting supplied value for structural_loss_vector: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<AstGradientReceipt> for super::AstGradientReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AstGradientReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                actual_type_geometry: value.actual_type_geometry?,
                ast_node_pointer: value.ast_node_pointer?,
                compilation_attempt_cid: value.compilation_attempt_cid?,
                expected_type_geometry: value.expected_type_geometry?,
                structural_loss_vector: value.structural_loss_vector?,
            })
        }
    }
    impl ::std::convert::From<super::AstGradientReceipt> for AstGradientReceipt {
        fn from(value: super::AstGradientReceipt) -> Self {
            Self {
                actual_type_geometry: Ok(value.actual_type_geometry),
                ast_node_pointer: Ok(value.ast_node_pointer),
                compilation_attempt_cid: Ok(value.compilation_attempt_cid),
                expected_type_geometry: Ok(value.expected_type_geometry),
                structural_loss_vector: Ok(value.structural_loss_vector),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AsymptoticComplexityReceipt {
        capability_cid: ::std::result::Result<super::CapabilityCid, ::std::string::String>,
        peak_vram_bytes: ::std::result::Result<u64, ::std::string::String>,
        simulated_cpu_cycles: ::std::result::Result<u64, ::std::string::String>,
        space_complexity_class:
            ::std::result::Result<super::SpaceComplexityClass, ::std::string::String>,
        time_complexity_class:
            ::std::result::Result<super::TimeComplexityClass, ::std::string::String>,
    }
    impl ::std::default::Default for AsymptoticComplexityReceipt {
        fn default() -> Self {
            Self {
                capability_cid: Err("no value supplied for capability_cid".to_string()),
                peak_vram_bytes: Err("no value supplied for peak_vram_bytes".to_string()),
                simulated_cpu_cycles: Err("no value supplied for simulated_cpu_cycles".to_string()),
                space_complexity_class: Err(
                    "no value supplied for space_complexity_class".to_string()
                ),
                time_complexity_class: Err(
                    "no value supplied for time_complexity_class".to_string()
                ),
            }
        }
    }
    impl AsymptoticComplexityReceipt {
        pub fn capability_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CapabilityCid>,
            T::Error: ::std::fmt::Display,
        {
            self.capability_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for capability_cid: {e}"));
            self
        }
        pub fn peak_vram_bytes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.peak_vram_bytes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for peak_vram_bytes: {e}"));
            self
        }
        pub fn simulated_cpu_cycles<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.simulated_cpu_cycles = value.try_into().map_err(|e| {
                format!("error converting supplied value for simulated_cpu_cycles: {e}")
            });
            self
        }
        pub fn space_complexity_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SpaceComplexityClass>,
            T::Error: ::std::fmt::Display,
        {
            self.space_complexity_class = value.try_into().map_err(|e| {
                format!("error converting supplied value for space_complexity_class: {e}")
            });
            self
        }
        pub fn time_complexity_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TimeComplexityClass>,
            T::Error: ::std::fmt::Display,
        {
            self.time_complexity_class = value.try_into().map_err(|e| {
                format!("error converting supplied value for time_complexity_class: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<AsymptoticComplexityReceipt> for super::AsymptoticComplexityReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AsymptoticComplexityReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                capability_cid: value.capability_cid?,
                peak_vram_bytes: value.peak_vram_bytes?,
                simulated_cpu_cycles: value.simulated_cpu_cycles?,
                space_complexity_class: value.space_complexity_class?,
                time_complexity_class: value.time_complexity_class?,
            })
        }
    }
    impl ::std::convert::From<super::AsymptoticComplexityReceipt> for AsymptoticComplexityReceipt {
        fn from(value: super::AsymptoticComplexityReceipt) -> Self {
            Self {
                capability_cid: Ok(value.capability_cid),
                peak_vram_bytes: Ok(value.peak_vram_bytes),
                simulated_cpu_cycles: Ok(value.simulated_cpu_cycles),
                space_complexity_class: Ok(value.space_complexity_class),
                time_complexity_class: Ok(value.time_complexity_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AtomicPropositionState {
        anaphoric_resolution_cids:
            ::std::result::Result<::std::vec::Vec<super::NodeCidState>, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        illocutionary_force:
            ::std::result::Result<super::IllocutionaryForceProfile, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        proposition_cid: ::std::result::Result<super::PropositionCid, ::std::string::String>,
        rhetorical_role:
            ::std::result::Result<super::RhetoricalStructureProfile, ::std::string::String>,
        statistical_qualifiers: ::std::result::Result<
            ::std::vec::Vec<super::EmpiricalStatisticalProfile>,
            ::std::string::String,
        >,
        text_chunk: ::std::result::Result<super::TextChunk, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for AtomicPropositionState {
        fn default() -> Self {
            Self {
                anaphoric_resolution_cids: Ok(Default::default()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                illocutionary_force: Err("no value supplied for illocutionary_force".to_string()),
                prior_event_hash: Ok(Default::default()),
                proposition_cid: Err("no value supplied for proposition_cid".to_string()),
                rhetorical_role: Err("no value supplied for rhetorical_role".to_string()),
                statistical_qualifiers: Ok(Default::default()),
                text_chunk: Err("no value supplied for text_chunk".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl AtomicPropositionState {
        pub fn anaphoric_resolution_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.anaphoric_resolution_cids = value.try_into().map_err(|e| {
                format!("error converting supplied value for anaphoric_resolution_cids: {e}")
            });
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn illocutionary_force<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::IllocutionaryForceProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.illocutionary_force = value.try_into().map_err(|e| {
                format!("error converting supplied value for illocutionary_force: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn proposition_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PropositionCid>,
            T::Error: ::std::fmt::Display,
        {
            self.proposition_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proposition_cid: {e}"));
            self
        }
        pub fn rhetorical_role<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RhetoricalStructureProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.rhetorical_role = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for rhetorical_role: {e}"));
            self
        }
        pub fn statistical_qualifiers<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EmpiricalStatisticalProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.statistical_qualifiers = value.try_into().map_err(|e| {
                format!("error converting supplied value for statistical_qualifiers: {e}")
            });
            self
        }
        pub fn text_chunk<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TextChunk>,
            T::Error: ::std::fmt::Display,
        {
            self.text_chunk = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for text_chunk: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<AtomicPropositionState> for super::AtomicPropositionState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AtomicPropositionState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                anaphoric_resolution_cids: value.anaphoric_resolution_cids?,
                event_cid: value.event_cid?,
                illocutionary_force: value.illocutionary_force?,
                prior_event_hash: value.prior_event_hash?,
                proposition_cid: value.proposition_cid?,
                rhetorical_role: value.rhetorical_role?,
                statistical_qualifiers: value.statistical_qualifiers?,
                text_chunk: value.text_chunk?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::AtomicPropositionState> for AtomicPropositionState {
        fn from(value: super::AtomicPropositionState) -> Self {
            Self {
                anaphoric_resolution_cids: Ok(value.anaphoric_resolution_cids),
                event_cid: Ok(value.event_cid),
                illocutionary_force: Ok(value.illocutionary_force),
                prior_event_hash: Ok(value.prior_event_hash),
                proposition_cid: Ok(value.proposition_cid),
                rhetorical_role: Ok(value.rhetorical_role),
                statistical_qualifiers: Ok(value.statistical_qualifiers),
                text_chunk: Ok(value.text_chunk),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AuctionPolicy {
        auction_type: ::std::result::Result<super::AuctionMechanismProfile, ::std::string::String>,
        max_bidding_window_ms: ::std::result::Result<u64, ::std::string::String>,
        tie_breaker: ::std::result::Result<super::TieBreakerPolicy, ::std::string::String>,
    }
    impl ::std::default::Default for AuctionPolicy {
        fn default() -> Self {
            Self {
                auction_type: Err("no value supplied for auction_type".to_string()),
                max_bidding_window_ms: Err(
                    "no value supplied for max_bidding_window_ms".to_string()
                ),
                tie_breaker: Err("no value supplied for tie_breaker".to_string()),
            }
        }
    }
    impl AuctionPolicy {
        pub fn auction_type<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AuctionMechanismProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.auction_type = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for auction_type: {e}"));
            self
        }
        pub fn max_bidding_window_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_bidding_window_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_bidding_window_ms: {e}")
            });
            self
        }
        pub fn tie_breaker<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TieBreakerPolicy>,
            T::Error: ::std::fmt::Display,
        {
            self.tie_breaker = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for tie_breaker: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<AuctionPolicy> for super::AuctionPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AuctionPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                auction_type: value.auction_type?,
                max_bidding_window_ms: value.max_bidding_window_ms?,
                tie_breaker: value.tie_breaker?,
            })
        }
    }
    impl ::std::convert::From<super::AuctionPolicy> for AuctionPolicy {
        fn from(value: super::AuctionPolicy) -> Self {
            Self {
                auction_type: Ok(value.auction_type),
                max_bidding_window_ms: Ok(value.max_bidding_window_ms),
                tie_breaker: Ok(value.tie_breaker),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct AuctionState {
        announcement: ::std::result::Result<super::TaskAnnouncementIntent, ::std::string::String>,
        award: ::std::result::Result<
            ::std::option::Option<super::TaskAwardReceipt>,
            ::std::string::String,
        >,
        bids: ::std::result::Result<::std::vec::Vec<super::AgentBidIntent>, ::std::string::String>,
        clearing_timeout: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        minimum_tick_size: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for AuctionState {
        fn default() -> Self {
            Self {
                announcement: Err("no value supplied for announcement".to_string()),
                award: Ok(Default::default()),
                bids: Ok(Default::default()),
                clearing_timeout: Err("no value supplied for clearing_timeout".to_string()),
                minimum_tick_size: Err("no value supplied for minimum_tick_size".to_string()),
            }
        }
    }
    impl AuctionState {
        pub fn announcement<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TaskAnnouncementIntent>,
            T::Error: ::std::fmt::Display,
        {
            self.announcement = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for announcement: {e}"));
            self
        }
        pub fn award<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TaskAwardReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.award = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for award: {e}"));
            self
        }
        pub fn bids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AgentBidIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.bids = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for bids: {e}"));
            self
        }
        pub fn clearing_timeout<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.clearing_timeout = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for clearing_timeout: {e}"));
            self
        }
        pub fn minimum_tick_size<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.minimum_tick_size = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for minimum_tick_size: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<AuctionState> for super::AuctionState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: AuctionState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                announcement: value.announcement?,
                award: value.award?,
                bids: value.bids?,
                clearing_timeout: value.clearing_timeout?,
                minimum_tick_size: value.minimum_tick_size?,
            })
        }
    }
    impl ::std::convert::From<super::AuctionState> for AuctionState {
        fn from(value: super::AuctionState) -> Self {
            Self {
                announcement: Ok(value.announcement),
                award: Ok(value.award),
                bids: Ok(value.bids),
                clearing_timeout: Ok(value.clearing_timeout),
                minimum_tick_size: Ok(value.minimum_tick_size),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct BackpressurePolicy {
        max_concurrent_tool_invocations: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
        max_queue_depth: ::std::result::Result<u64, ::std::string::String>,
        max_requests_per_minute: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
        max_tokens_per_minute: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
        max_uninterruptible_span_ms: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
        token_budget_per_branch:
            ::std::result::Result<::std::option::Option<u64>, ::std::string::String>,
    }
    impl ::std::default::Default for BackpressurePolicy {
        fn default() -> Self {
            Self {
                max_concurrent_tool_invocations: Ok(Default::default()),
                max_queue_depth: Err("no value supplied for max_queue_depth".to_string()),
                max_requests_per_minute: Ok(Default::default()),
                max_tokens_per_minute: Ok(Default::default()),
                max_uninterruptible_span_ms: Ok(Default::default()),
                token_budget_per_branch: Ok(Default::default()),
            }
        }
    }
    impl BackpressurePolicy {
        pub fn max_concurrent_tool_invocations<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_concurrent_tool_invocations = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_concurrent_tool_invocations: {e}")
            });
            self
        }
        pub fn max_queue_depth<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_queue_depth = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_queue_depth: {e}"));
            self
        }
        pub fn max_requests_per_minute<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_requests_per_minute = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_requests_per_minute: {e}")
            });
            self
        }
        pub fn max_tokens_per_minute<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_tokens_per_minute = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_tokens_per_minute: {e}")
            });
            self
        }
        pub fn max_uninterruptible_span_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_uninterruptible_span_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_uninterruptible_span_ms: {e}")
            });
            self
        }
        pub fn token_budget_per_branch<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.token_budget_per_branch = value.try_into().map_err(|e| {
                format!("error converting supplied value for token_budget_per_branch: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<BackpressurePolicy> for super::BackpressurePolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: BackpressurePolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_concurrent_tool_invocations: value.max_concurrent_tool_invocations?,
                max_queue_depth: value.max_queue_depth?,
                max_requests_per_minute: value.max_requests_per_minute?,
                max_tokens_per_minute: value.max_tokens_per_minute?,
                max_uninterruptible_span_ms: value.max_uninterruptible_span_ms?,
                token_budget_per_branch: value.token_budget_per_branch?,
            })
        }
    }
    impl ::std::convert::From<super::BackpressurePolicy> for BackpressurePolicy {
        fn from(value: super::BackpressurePolicy) -> Self {
            Self {
                max_concurrent_tool_invocations: Ok(value.max_concurrent_tool_invocations),
                max_queue_depth: Ok(value.max_queue_depth),
                max_requests_per_minute: Ok(value.max_requests_per_minute),
                max_tokens_per_minute: Ok(value.max_tokens_per_minute),
                max_uninterruptible_span_ms: Ok(value.max_uninterruptible_span_ms),
                token_budget_per_branch: Ok(value.token_budget_per_branch),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct BargeInInterruptEvent {
        epistemic_disposition:
            ::std::result::Result<super::EpistemicDisposition, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        retained_partial_payload: ::std::result::Result<
            ::std::option::Option<super::RetainedPartialPayload>,
            ::std::string::String,
        >,
        sensory_trigger: ::std::result::Result<
            ::std::option::Option<super::EmbodiedSensoryVectorProfile>,
            ::std::string::String,
        >,
        target_event_cid: ::std::result::Result<super::TargetEventCid, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for BargeInInterruptEvent {
        fn default() -> Self {
            Self {
                epistemic_disposition: Err(
                    "no value supplied for epistemic_disposition".to_string()
                ),
                event_cid: Err("no value supplied for event_cid".to_string()),
                prior_event_hash: Ok(Default::default()),
                retained_partial_payload: Ok(Default::default()),
                sensory_trigger: Ok(Default::default()),
                target_event_cid: Err("no value supplied for target_event_cid".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl BargeInInterruptEvent {
        pub fn epistemic_disposition<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EpistemicDisposition>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_disposition = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_disposition: {e}")
            });
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn retained_partial_payload<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::RetainedPartialPayload>>,
            T::Error: ::std::fmt::Display,
        {
            self.retained_partial_payload = value.try_into().map_err(|e| {
                format!("error converting supplied value for retained_partial_payload: {e}")
            });
            self
        }
        pub fn sensory_trigger<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EmbodiedSensoryVectorProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.sensory_trigger = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for sensory_trigger: {e}"));
            self
        }
        pub fn target_event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetEventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_event_cid: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<BargeInInterruptEvent> for super::BargeInInterruptEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: BargeInInterruptEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                epistemic_disposition: value.epistemic_disposition?,
                event_cid: value.event_cid?,
                prior_event_hash: value.prior_event_hash?,
                retained_partial_payload: value.retained_partial_payload?,
                sensory_trigger: value.sensory_trigger?,
                target_event_cid: value.target_event_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::BargeInInterruptEvent> for BargeInInterruptEvent {
        fn from(value: super::BargeInInterruptEvent) -> Self {
            Self {
                epistemic_disposition: Ok(value.epistemic_disposition),
                event_cid: Ok(value.event_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                retained_partial_payload: Ok(value.retained_partial_payload),
                sensory_trigger: Ok(value.sensory_trigger),
                target_event_cid: Ok(value.target_event_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct BeliefModulationReceipt {
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        grounded_edges: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::DempsterShaferBeliefVector>,
            ::std::string::String,
        >,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        receipt_cid: ::std::result::Result<super::ReceiptCid, ::std::string::String>,
        severed_edge_cids: ::std::result::Result<
            ::std::vec::Vec<super::SeveredEdgeCidsItem>,
            ::std::string::String,
        >,
        target_graph_cid: ::std::result::Result<super::TargetGraphCid, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for BeliefModulationReceipt {
        fn default() -> Self {
            Self {
                event_cid: Err("no value supplied for event_cid".to_string()),
                grounded_edges: Err("no value supplied for grounded_edges".to_string()),
                prior_event_hash: Ok(Default::default()),
                receipt_cid: Err("no value supplied for receipt_cid".to_string()),
                severed_edge_cids: Err("no value supplied for severed_edge_cids".to_string()),
                target_graph_cid: Err("no value supplied for target_graph_cid".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl BeliefModulationReceipt {
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn grounded_edges<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::DempsterShaferBeliefVector,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.grounded_edges = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for grounded_edges: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn receipt_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ReceiptCid>,
            T::Error: ::std::fmt::Display,
        {
            self.receipt_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for receipt_cid: {e}"));
            self
        }
        pub fn severed_edge_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::SeveredEdgeCidsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.severed_edge_cids = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for severed_edge_cids: {e}"));
            self
        }
        pub fn target_graph_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetGraphCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_graph_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_graph_cid: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<BeliefModulationReceipt> for super::BeliefModulationReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: BeliefModulationReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                event_cid: value.event_cid?,
                grounded_edges: value.grounded_edges?,
                prior_event_hash: value.prior_event_hash?,
                receipt_cid: value.receipt_cid?,
                severed_edge_cids: value.severed_edge_cids?,
                target_graph_cid: value.target_graph_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::BeliefModulationReceipt> for BeliefModulationReceipt {
        fn from(value: super::BeliefModulationReceipt) -> Self {
            Self {
                event_cid: Ok(value.event_cid),
                grounded_edges: Ok(value.grounded_edges),
                prior_event_hash: Ok(value.prior_event_hash),
                receipt_cid: Ok(value.receipt_cid),
                severed_edge_cids: Ok(value.severed_edge_cids),
                target_graph_cid: Ok(value.target_graph_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct BeliefMutationEvent {
        causal_attributions: ::std::result::Result<
            ::std::vec::Vec<super::CausalAttributionState>,
            ::std::string::String,
        >,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        hardware_attestation: ::std::result::Result<
            ::std::option::Option<super::HardwareEnclaveReceipt>,
            ::std::string::String,
        >,
        neural_audit: ::std::result::Result<
            ::std::option::Option<super::NeuralAuditAttestationReceipt>,
            ::std::string::String,
        >,
        payload: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        quorum_signatures: ::std::result::Result<
            ::std::vec::Vec<super::QuorumSignaturesItem>,
            ::std::string::String,
        >,
        scratchpad_trace: ::std::result::Result<
            ::std::option::Option<super::LatentScratchpadReceipt>,
            ::std::string::String,
        >,
        source_node_cid: ::std::result::Result<
            ::std::option::Option<super::NodeCidState>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        uncertainty_profile: ::std::result::Result<
            ::std::option::Option<super::CognitiveUncertaintyProfile>,
            ::std::string::String,
        >,
        zk_proof: ::std::result::Result<
            ::std::option::Option<super::ZeroKnowledgeReceipt>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for BeliefMutationEvent {
        fn default() -> Self {
            Self {
                causal_attributions: Ok(Default::default()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                hardware_attestation: Ok(Default::default()),
                neural_audit: Ok(Default::default()),
                payload: Err("no value supplied for payload".to_string()),
                prior_event_hash: Ok(Default::default()),
                quorum_signatures: Ok(Default::default()),
                scratchpad_trace: Ok(Default::default()),
                source_node_cid: Ok(Default::default()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
                uncertainty_profile: Ok(Default::default()),
                zk_proof: Ok(Default::default()),
            }
        }
    }
    impl BeliefMutationEvent {
        pub fn causal_attributions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::CausalAttributionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_attributions = value.try_into().map_err(|e| {
                format!("error converting supplied value for causal_attributions: {e}")
            });
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn hardware_attestation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HardwareEnclaveReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.hardware_attestation = value.try_into().map_err(|e| {
                format!("error converting supplied value for hardware_attestation: {e}")
            });
            self
        }
        pub fn neural_audit<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NeuralAuditAttestationReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.neural_audit = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for neural_audit: {e}"));
            self
        }
        pub fn payload<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.payload = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for payload: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn quorum_signatures<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::QuorumSignaturesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.quorum_signatures = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for quorum_signatures: {e}"));
            self
        }
        pub fn scratchpad_trace<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LatentScratchpadReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.scratchpad_trace = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for scratchpad_trace: {e}"));
            self
        }
        pub fn source_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.source_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_node_cid: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn uncertainty_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveUncertaintyProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.uncertainty_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for uncertainty_profile: {e}")
            });
            self
        }
        pub fn zk_proof<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ZeroKnowledgeReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.zk_proof = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for zk_proof: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<BeliefMutationEvent> for super::BeliefMutationEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: BeliefMutationEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                causal_attributions: value.causal_attributions?,
                event_cid: value.event_cid?,
                hardware_attestation: value.hardware_attestation?,
                neural_audit: value.neural_audit?,
                payload: value.payload?,
                prior_event_hash: value.prior_event_hash?,
                quorum_signatures: value.quorum_signatures?,
                scratchpad_trace: value.scratchpad_trace?,
                source_node_cid: value.source_node_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
                uncertainty_profile: value.uncertainty_profile?,
                zk_proof: value.zk_proof?,
            })
        }
    }
    impl ::std::convert::From<super::BeliefMutationEvent> for BeliefMutationEvent {
        fn from(value: super::BeliefMutationEvent) -> Self {
            Self {
                causal_attributions: Ok(value.causal_attributions),
                event_cid: Ok(value.event_cid),
                hardware_attestation: Ok(value.hardware_attestation),
                neural_audit: Ok(value.neural_audit),
                payload: Ok(value.payload),
                prior_event_hash: Ok(value.prior_event_hash),
                quorum_signatures: Ok(value.quorum_signatures),
                scratchpad_trace: Ok(value.scratchpad_trace),
                source_node_cid: Ok(value.source_node_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
                uncertainty_profile: Ok(value.uncertainty_profile),
                zk_proof: Ok(value.zk_proof),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct BoundedInterventionScopePolicy {
        allowed_fields:
            ::std::result::Result<::std::vec::Vec<super::AllowedFieldsItem>, ::std::string::String>,
        json_schema_whitelist: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for BoundedInterventionScopePolicy {
        fn default() -> Self {
            Self {
                allowed_fields: Err("no value supplied for allowed_fields".to_string()),
                json_schema_whitelist: Err(
                    "no value supplied for json_schema_whitelist".to_string()
                ),
            }
        }
    }
    impl BoundedInterventionScopePolicy {
        pub fn allowed_fields<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AllowedFieldsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.allowed_fields = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for allowed_fields: {e}"));
            self
        }
        pub fn json_schema_whitelist<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.json_schema_whitelist = value.try_into().map_err(|e| {
                format!("error converting supplied value for json_schema_whitelist: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<BoundedInterventionScopePolicy>
        for super::BoundedInterventionScopePolicy
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: BoundedInterventionScopePolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                allowed_fields: value.allowed_fields?,
                json_schema_whitelist: value.json_schema_whitelist?,
            })
        }
    }
    impl ::std::convert::From<super::BoundedInterventionScopePolicy>
        for BoundedInterventionScopePolicy
    {
        fn from(value: super::BoundedInterventionScopePolicy) -> Self {
            Self {
                allowed_fields: Ok(value.allowed_fields),
                json_schema_whitelist: Ok(value.json_schema_whitelist),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct BoundedJsonrpcIntent {
        id: ::std::result::Result<::std::option::Option<super::Id>, ::std::string::String>,
        jsonrpc: ::std::result::Result<::std::string::String, ::std::string::String>,
        method: ::std::result::Result<super::Method, ::std::string::String>,
        params: ::std::result::Result<
            ::std::option::Option<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for BoundedJsonrpcIntent {
        fn default() -> Self {
            Self {
                id: Ok(Default::default()),
                jsonrpc: Err("no value supplied for jsonrpc".to_string()),
                method: Err("no value supplied for method".to_string()),
                params: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl BoundedJsonrpcIntent {
        pub fn id<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::Id>>,
            T::Error: ::std::fmt::Display,
        {
            self.id = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for id: {e}"));
            self
        }
        pub fn jsonrpc<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.jsonrpc = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for jsonrpc: {e}"));
            self
        }
        pub fn method<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Method>,
            T::Error: ::std::fmt::Display,
        {
            self.method = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for method: {e}"));
            self
        }
        pub fn params<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.params = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for params: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<BoundedJsonrpcIntent> for super::BoundedJsonrpcIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: BoundedJsonrpcIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                id: value.id?,
                jsonrpc: value.jsonrpc?,
                method: value.method?,
                params: value.params?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::BoundedJsonrpcIntent> for BoundedJsonrpcIntent {
        fn from(value: super::BoundedJsonrpcIntent) -> Self {
            Self {
                id: Ok(value.id),
                jsonrpc: Ok(value.jsonrpc),
                method: Ok(value.method),
                params: Ok(value.params),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct BrowserDomState {
        accessibility_tree_hash:
            ::std::result::Result<super::AccessibilityTreeHash, ::std::string::String>,
        current_url: ::std::result::Result<super::CurrentUrl, ::std::string::String>,
        dom_hash: ::std::result::Result<super::DomHash, ::std::string::String>,
        screenshot_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        viewport_size:
            ::std::result::Result<::std::vec::Vec<::serde_json::Value>, ::std::string::String>,
    }
    impl ::std::default::Default for BrowserDomState {
        fn default() -> Self {
            Self {
                accessibility_tree_hash: Err(
                    "no value supplied for accessibility_tree_hash".to_string()
                ),
                current_url: Err("no value supplied for current_url".to_string()),
                dom_hash: Err("no value supplied for dom_hash".to_string()),
                screenshot_cid: Ok(Default::default()),
                topology_class: Ok(Default::default()),
                viewport_size: Err("no value supplied for viewport_size".to_string()),
            }
        }
    }
    impl BrowserDomState {
        pub fn accessibility_tree_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AccessibilityTreeHash>,
            T::Error: ::std::fmt::Display,
        {
            self.accessibility_tree_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for accessibility_tree_hash: {e}")
            });
            self
        }
        pub fn current_url<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CurrentUrl>,
            T::Error: ::std::fmt::Display,
        {
            self.current_url = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for current_url: {e}"));
            self
        }
        pub fn dom_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DomHash>,
            T::Error: ::std::fmt::Display,
        {
            self.dom_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for dom_hash: {e}"));
            self
        }
        pub fn screenshot_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.screenshot_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for screenshot_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn viewport_size<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<::serde_json::Value>>,
            T::Error: ::std::fmt::Display,
        {
            self.viewport_size = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for viewport_size: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<BrowserDomState> for super::BrowserDomState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: BrowserDomState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                accessibility_tree_hash: value.accessibility_tree_hash?,
                current_url: value.current_url?,
                dom_hash: value.dom_hash?,
                screenshot_cid: value.screenshot_cid?,
                topology_class: value.topology_class?,
                viewport_size: value.viewport_size?,
            })
        }
    }
    impl ::std::convert::From<super::BrowserDomState> for BrowserDomState {
        fn from(value: super::BrowserDomState) -> Self {
            Self {
                accessibility_tree_hash: Ok(value.accessibility_tree_hash),
                current_url: Ok(value.current_url),
                dom_hash: Ok(value.dom_hash),
                screenshot_cid: Ok(value.screenshot_cid),
                topology_class: Ok(value.topology_class),
                viewport_size: Ok(value.viewport_size),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct BudgetExhaustionEvent {
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        exhausted_escrow_cid:
            ::std::result::Result<super::ExhaustedEscrowCid, ::std::string::String>,
        final_burn_receipt_cid:
            ::std::result::Result<super::FinalBurnReceiptCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for BudgetExhaustionEvent {
        fn default() -> Self {
            Self {
                event_cid: Err("no value supplied for event_cid".to_string()),
                exhausted_escrow_cid: Err("no value supplied for exhausted_escrow_cid".to_string()),
                final_burn_receipt_cid: Err(
                    "no value supplied for final_burn_receipt_cid".to_string()
                ),
                prior_event_hash: Ok(Default::default()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl BudgetExhaustionEvent {
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn exhausted_escrow_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ExhaustedEscrowCid>,
            T::Error: ::std::fmt::Display,
        {
            self.exhausted_escrow_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for exhausted_escrow_cid: {e}")
            });
            self
        }
        pub fn final_burn_receipt_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FinalBurnReceiptCid>,
            T::Error: ::std::fmt::Display,
        {
            self.final_burn_receipt_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for final_burn_receipt_cid: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<BudgetExhaustionEvent> for super::BudgetExhaustionEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: BudgetExhaustionEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                event_cid: value.event_cid?,
                exhausted_escrow_cid: value.exhausted_escrow_cid?,
                final_burn_receipt_cid: value.final_burn_receipt_cid?,
                prior_event_hash: value.prior_event_hash?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::BudgetExhaustionEvent> for BudgetExhaustionEvent {
        fn from(value: super::BudgetExhaustionEvent) -> Self {
            Self {
                event_cid: Ok(value.event_cid),
                exhausted_escrow_cid: Ok(value.exhausted_escrow_cid),
                final_burn_receipt_cid: Ok(value.final_burn_receipt_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct BypassReceipt {
        artifact_event_cid: ::std::result::Result<super::ArtifactEventCid, ::std::string::String>,
        bypassed_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        cryptographic_null_hash:
            ::std::result::Result<super::CryptographicNullHash, ::std::string::String>,
        justification: ::std::result::Result<super::Justification, ::std::string::String>,
    }
    impl ::std::default::Default for BypassReceipt {
        fn default() -> Self {
            Self {
                artifact_event_cid: Err("no value supplied for artifact_event_cid".to_string()),
                bypassed_node_cid: Err("no value supplied for bypassed_node_cid".to_string()),
                cryptographic_null_hash: Err(
                    "no value supplied for cryptographic_null_hash".to_string()
                ),
                justification: Err("no value supplied for justification".to_string()),
            }
        }
    }
    impl BypassReceipt {
        pub fn artifact_event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ArtifactEventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.artifact_event_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for artifact_event_cid: {e}")
            });
            self
        }
        pub fn bypassed_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.bypassed_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for bypassed_node_cid: {e}"));
            self
        }
        pub fn cryptographic_null_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CryptographicNullHash>,
            T::Error: ::std::fmt::Display,
        {
            self.cryptographic_null_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for cryptographic_null_hash: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Justification>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<BypassReceipt> for super::BypassReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: BypassReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                artifact_event_cid: value.artifact_event_cid?,
                bypassed_node_cid: value.bypassed_node_cid?,
                cryptographic_null_hash: value.cryptographic_null_hash?,
                justification: value.justification?,
            })
        }
    }
    impl ::std::convert::From<super::BypassReceipt> for BypassReceipt {
        fn from(value: super::BypassReceipt) -> Self {
            Self {
                artifact_event_cid: Ok(value.artifact_event_cid),
                bypassed_node_cid: Ok(value.bypassed_node_cid),
                cryptographic_null_hash: Ok(value.cryptographic_null_hash),
                justification: Ok(value.justification),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CapabilityForgeTopologyManifest {
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        epistemic_enforcement: ::std::result::Result<
            ::std::option::Option<super::TruthMaintenancePolicy>,
            ::std::string::String,
        >,
        formal_verifier_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        fuzzing_engine_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        generator_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        human_supervisor_cid: ::std::result::Result<
            ::std::option::Option<super::NodeCidState>,
            ::std::string::String,
        >,
        isometry_verification: ::std::result::Result<
            ::std::option::Option<super::TeleologicalIsometryReceipt>,
            ::std::string::String,
        >,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        lifecycle_phase: ::std::result::Result<
            ::std::option::Option<super::LifecyclePhase>,
            ::std::string::String,
        >,
        nodes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            ::std::string::String,
        >,
        observability: ::std::result::Result<
            ::std::option::Option<super::ObservabilityLodPolicy>,
            ::std::string::String,
        >,
        semantic_flow: ::std::result::Result<
            ::std::option::Option<super::SemanticFlowPolicy>,
            ::std::string::String,
        >,
        shared_state_contract: ::std::result::Result<
            ::std::option::Option<super::StateContract>,
            ::std::string::String,
        >,
        target_epistemic_deficit:
            ::std::result::Result<super::SemanticDiscoveryIntent, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CapabilityForgeTopologyManifest {
        fn default() -> Self {
            Self {
                architectural_intent: Ok(Default::default()),
                epistemic_enforcement: Ok(Default::default()),
                formal_verifier_cid: Err("no value supplied for formal_verifier_cid".to_string()),
                fuzzing_engine_cid: Err("no value supplied for fuzzing_engine_cid".to_string()),
                generator_node_cid: Err("no value supplied for generator_node_cid".to_string()),
                human_supervisor_cid: Ok(Default::default()),
                isometry_verification: Ok(Default::default()),
                justification: Ok(Default::default()),
                lifecycle_phase: Ok(Default::default()),
                nodes: Err("no value supplied for nodes".to_string()),
                observability: Ok(Default::default()),
                semantic_flow: Ok(Default::default()),
                shared_state_contract: Ok(Default::default()),
                target_epistemic_deficit: Err(
                    "no value supplied for target_epistemic_deficit".to_string()
                ),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl CapabilityForgeTopologyManifest {
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn epistemic_enforcement<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TruthMaintenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_enforcement = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_enforcement: {e}")
            });
            self
        }
        pub fn formal_verifier_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.formal_verifier_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for formal_verifier_cid: {e}")
            });
            self
        }
        pub fn fuzzing_engine_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.fuzzing_engine_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for fuzzing_engine_cid: {e}")
            });
            self
        }
        pub fn generator_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.generator_node_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for generator_node_cid: {e}")
            });
            self
        }
        pub fn human_supervisor_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.human_supervisor_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for human_supervisor_cid: {e}")
            });
            self
        }
        pub fn isometry_verification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TeleologicalIsometryReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.isometry_verification = value.try_into().map_err(|e| {
                format!("error converting supplied value for isometry_verification: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn lifecycle_phase<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LifecyclePhase>>,
            T::Error: ::std::fmt::Display,
        {
            self.lifecycle_phase = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lifecycle_phase: {e}"));
            self
        }
        pub fn nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for nodes: {e}"));
            self
        }
        pub fn observability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ObservabilityLodPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.observability = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for observability: {e}"));
            self
        }
        pub fn semantic_flow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFlowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_flow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_flow: {e}"));
            self
        }
        pub fn shared_state_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.shared_state_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for shared_state_contract: {e}")
            });
            self
        }
        pub fn target_epistemic_deficit<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SemanticDiscoveryIntent>,
            T::Error: ::std::fmt::Display,
        {
            self.target_epistemic_deficit = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_epistemic_deficit: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CapabilityForgeTopologyManifest>
        for super::CapabilityForgeTopologyManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CapabilityForgeTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                architectural_intent: value.architectural_intent?,
                epistemic_enforcement: value.epistemic_enforcement?,
                formal_verifier_cid: value.formal_verifier_cid?,
                fuzzing_engine_cid: value.fuzzing_engine_cid?,
                generator_node_cid: value.generator_node_cid?,
                human_supervisor_cid: value.human_supervisor_cid?,
                isometry_verification: value.isometry_verification?,
                justification: value.justification?,
                lifecycle_phase: value.lifecycle_phase?,
                nodes: value.nodes?,
                observability: value.observability?,
                semantic_flow: value.semantic_flow?,
                shared_state_contract: value.shared_state_contract?,
                target_epistemic_deficit: value.target_epistemic_deficit?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::CapabilityForgeTopologyManifest>
        for CapabilityForgeTopologyManifest
    {
        fn from(value: super::CapabilityForgeTopologyManifest) -> Self {
            Self {
                architectural_intent: Ok(value.architectural_intent),
                epistemic_enforcement: Ok(value.epistemic_enforcement),
                formal_verifier_cid: Ok(value.formal_verifier_cid),
                fuzzing_engine_cid: Ok(value.fuzzing_engine_cid),
                generator_node_cid: Ok(value.generator_node_cid),
                human_supervisor_cid: Ok(value.human_supervisor_cid),
                isometry_verification: Ok(value.isometry_verification),
                justification: Ok(value.justification),
                lifecycle_phase: Ok(value.lifecycle_phase),
                nodes: Ok(value.nodes),
                observability: Ok(value.observability),
                semantic_flow: Ok(value.semantic_flow),
                shared_state_contract: Ok(value.shared_state_contract),
                target_epistemic_deficit: Ok(value.target_epistemic_deficit),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CausalAttributionState {
        influence_weight: ::std::result::Result<f64, ::std::string::String>,
        source_event_cid: ::std::result::Result<super::SourceEventCid, ::std::string::String>,
    }
    impl ::std::default::Default for CausalAttributionState {
        fn default() -> Self {
            Self {
                influence_weight: Err("no value supplied for influence_weight".to_string()),
                source_event_cid: Err("no value supplied for source_event_cid".to_string()),
            }
        }
    }
    impl CausalAttributionState {
        pub fn influence_weight<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.influence_weight = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for influence_weight: {e}"));
            self
        }
        pub fn source_event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceEventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_event_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CausalAttributionState> for super::CausalAttributionState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CausalAttributionState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                influence_weight: value.influence_weight?,
                source_event_cid: value.source_event_cid?,
            })
        }
    }
    impl ::std::convert::From<super::CausalAttributionState> for CausalAttributionState {
        fn from(value: super::CausalAttributionState) -> Self {
            Self {
                influence_weight: Ok(value.influence_weight),
                source_event_cid: Ok(value.source_event_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CausalDirectedEdgeState {
        belief_vector: ::std::result::Result<
            ::std::option::Option<super::DempsterShaferBeliefVector>,
            ::std::string::String,
        >,
        edge_class: ::std::result::Result<super::EdgeClass, ::std::string::String>,
        grounding_sla: ::std::result::Result<
            ::std::option::Option<super::EvidentiaryGroundingSla>,
            ::std::string::String,
        >,
        predicate_curie: ::std::result::Result<super::PredicateCurie, ::std::string::String>,
        source_variable: ::std::result::Result<super::SourceVariable, ::std::string::String>,
        target_variable: ::std::result::Result<super::TargetVariable, ::std::string::String>,
        volumetric_geometry: ::std::result::Result<
            ::std::option::Option<super::VolumetricEdgeProfile>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CausalDirectedEdgeState {
        fn default() -> Self {
            Self {
                belief_vector: Ok(Default::default()),
                edge_class: Err("no value supplied for edge_class".to_string()),
                grounding_sla: Ok(Default::default()),
                predicate_curie: Err("no value supplied for predicate_curie".to_string()),
                source_variable: Err("no value supplied for source_variable".to_string()),
                target_variable: Err("no value supplied for target_variable".to_string()),
                volumetric_geometry: Ok(Default::default()),
            }
        }
    }
    impl CausalDirectedEdgeState {
        pub fn belief_vector<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DempsterShaferBeliefVector>>,
            T::Error: ::std::fmt::Display,
        {
            self.belief_vector = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for belief_vector: {e}"));
            self
        }
        pub fn edge_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EdgeClass>,
            T::Error: ::std::fmt::Display,
        {
            self.edge_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for edge_class: {e}"));
            self
        }
        pub fn grounding_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EvidentiaryGroundingSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.grounding_sla = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for grounding_sla: {e}"));
            self
        }
        pub fn predicate_curie<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PredicateCurie>,
            T::Error: ::std::fmt::Display,
        {
            self.predicate_curie = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for predicate_curie: {e}"));
            self
        }
        pub fn source_variable<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceVariable>,
            T::Error: ::std::fmt::Display,
        {
            self.source_variable = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_variable: {e}"));
            self
        }
        pub fn target_variable<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetVariable>,
            T::Error: ::std::fmt::Display,
        {
            self.target_variable = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_variable: {e}"));
            self
        }
        pub fn volumetric_geometry<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VolumetricEdgeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.volumetric_geometry = value.try_into().map_err(|e| {
                format!("error converting supplied value for volumetric_geometry: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<CausalDirectedEdgeState> for super::CausalDirectedEdgeState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CausalDirectedEdgeState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                belief_vector: value.belief_vector?,
                edge_class: value.edge_class?,
                grounding_sla: value.grounding_sla?,
                predicate_curie: value.predicate_curie?,
                source_variable: value.source_variable?,
                target_variable: value.target_variable?,
                volumetric_geometry: value.volumetric_geometry?,
            })
        }
    }
    impl ::std::convert::From<super::CausalDirectedEdgeState> for CausalDirectedEdgeState {
        fn from(value: super::CausalDirectedEdgeState) -> Self {
            Self {
                belief_vector: Ok(value.belief_vector),
                edge_class: Ok(value.edge_class),
                grounding_sla: Ok(value.grounding_sla),
                predicate_curie: Ok(value.predicate_curie),
                source_variable: Ok(value.source_variable),
                target_variable: Ok(value.target_variable),
                volumetric_geometry: Ok(value.volumetric_geometry),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CausalExplanationEvent {
        agent_attributions: ::std::result::Result<
            ::std::vec::Vec<super::ShapleyAttributionReceipt>,
            ::std::string::String,
        >,
        collective_intelligence:
            ::std::result::Result<super::CollectiveIntelligenceProfile, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        target_outcome_event_cid:
            ::std::result::Result<super::TargetOutcomeEventCid, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CausalExplanationEvent {
        fn default() -> Self {
            Self {
                agent_attributions: Err("no value supplied for agent_attributions".to_string()),
                collective_intelligence: Err(
                    "no value supplied for collective_intelligence".to_string()
                ),
                event_cid: Err("no value supplied for event_cid".to_string()),
                prior_event_hash: Ok(Default::default()),
                target_outcome_event_cid: Err(
                    "no value supplied for target_outcome_event_cid".to_string()
                ),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl CausalExplanationEvent {
        pub fn agent_attributions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ShapleyAttributionReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.agent_attributions = value.try_into().map_err(|e| {
                format!("error converting supplied value for agent_attributions: {e}")
            });
            self
        }
        pub fn collective_intelligence<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CollectiveIntelligenceProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.collective_intelligence = value.try_into().map_err(|e| {
                format!("error converting supplied value for collective_intelligence: {e}")
            });
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn target_outcome_event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetOutcomeEventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_outcome_event_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_outcome_event_cid: {e}")
            });
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CausalExplanationEvent> for super::CausalExplanationEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CausalExplanationEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                agent_attributions: value.agent_attributions?,
                collective_intelligence: value.collective_intelligence?,
                event_cid: value.event_cid?,
                prior_event_hash: value.prior_event_hash?,
                target_outcome_event_cid: value.target_outcome_event_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::CausalExplanationEvent> for CausalExplanationEvent {
        fn from(value: super::CausalExplanationEvent) -> Self {
            Self {
                agent_attributions: Ok(value.agent_attributions),
                collective_intelligence: Ok(value.collective_intelligence),
                event_cid: Ok(value.event_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                target_outcome_event_cid: Ok(value.target_outcome_event_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CausalPropagationIntent {
        grounding_sla: ::std::result::Result<super::EvidentiaryGroundingSla, ::std::string::String>,
        target_graph_cid: ::std::result::Result<super::TargetGraphCid, ::std::string::String>,
        task_cid: ::std::result::Result<super::TaskCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        unverified_edges: ::std::result::Result<
            ::std::vec::Vec<super::CausalDirectedEdgeState>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CausalPropagationIntent {
        fn default() -> Self {
            Self {
                grounding_sla: Err("no value supplied for grounding_sla".to_string()),
                target_graph_cid: Err("no value supplied for target_graph_cid".to_string()),
                task_cid: Err("no value supplied for task_cid".to_string()),
                topology_class: Ok(Default::default()),
                unverified_edges: Err("no value supplied for unverified_edges".to_string()),
            }
        }
    }
    impl CausalPropagationIntent {
        pub fn grounding_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EvidentiaryGroundingSla>,
            T::Error: ::std::fmt::Display,
        {
            self.grounding_sla = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for grounding_sla: {e}"));
            self
        }
        pub fn target_graph_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetGraphCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_graph_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_graph_cid: {e}"));
            self
        }
        pub fn task_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TaskCid>,
            T::Error: ::std::fmt::Display,
        {
            self.task_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for task_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn unverified_edges<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::CausalDirectedEdgeState>>,
            T::Error: ::std::fmt::Display,
        {
            self.unverified_edges = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for unverified_edges: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CausalPropagationIntent> for super::CausalPropagationIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CausalPropagationIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                grounding_sla: value.grounding_sla?,
                target_graph_cid: value.target_graph_cid?,
                task_cid: value.task_cid?,
                topology_class: value.topology_class?,
                unverified_edges: value.unverified_edges?,
            })
        }
    }
    impl ::std::convert::From<super::CausalPropagationIntent> for CausalPropagationIntent {
        fn from(value: super::CausalPropagationIntent) -> Self {
            Self {
                grounding_sla: Ok(value.grounding_sla),
                target_graph_cid: Ok(value.target_graph_cid),
                task_cid: Ok(value.task_cid),
                topology_class: Ok(value.topology_class),
                unverified_edges: Ok(value.unverified_edges),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CircuitBreakerEvent {
        error_signature: ::std::result::Result<super::ErrorSignature, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        target_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CircuitBreakerEvent {
        fn default() -> Self {
            Self {
                error_signature: Err("no value supplied for error_signature".to_string()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                prior_event_hash: Ok(Default::default()),
                target_node_cid: Err("no value supplied for target_node_cid".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl CircuitBreakerEvent {
        pub fn error_signature<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ErrorSignature>,
            T::Error: ::std::fmt::Display,
        {
            self.error_signature = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for error_signature: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CircuitBreakerEvent> for super::CircuitBreakerEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CircuitBreakerEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                error_signature: value.error_signature?,
                event_cid: value.event_cid?,
                prior_event_hash: value.prior_event_hash?,
                target_node_cid: value.target_node_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::CircuitBreakerEvent> for CircuitBreakerEvent {
        fn from(value: super::CircuitBreakerEvent) -> Self {
            Self {
                error_signature: Ok(value.error_signature),
                event_cid: Ok(value.event_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                target_node_cid: Ok(value.target_node_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CoReasonSharedKernelOntology {
        activation_steering_contract: ::std::result::Result<
            ::std::option::Option<super::ActivationSteeringContract>,
            ::std::string::String,
        >,
        active_inference_contract: ::std::result::Result<
            ::std::option::Option<super::ActiveInferenceContract>,
            ::std::string::String,
        >,
        adjudication_intent: ::std::result::Result<
            ::std::option::Option<super::AdjudicationIntent>,
            ::std::string::String,
        >,
        adjudication_receipt: ::std::result::Result<
            ::std::option::Option<super::AdjudicationReceipt>,
            ::std::string::String,
        >,
        adjudication_rubric_profile: ::std::result::Result<
            ::std::option::Option<super::AdjudicationRubricProfile>,
            ::std::string::String,
        >,
        adversarial_market_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::AdversarialMarketTopologyManifest>,
            ::std::string::String,
        >,
        agent_attestation_receipt: ::std::result::Result<
            ::std::option::Option<super::AgentAttestationReceipt>,
            ::std::string::String,
        >,
        agent_bid_intent: ::std::result::Result<
            ::std::option::Option<super::AgentBidIntent>,
            ::std::string::String,
        >,
        algebraic_refinement_contract: ::std::result::Result<
            ::std::option::Option<super::AlgebraicRefinementContract>,
            ::std::string::String,
        >,
        ambient_state: ::std::result::Result<
            ::std::option::Option<super::AmbientState>,
            ::std::string::String,
        >,
        analogical_mapping_task: ::std::result::Result<
            ::std::option::Option<super::AnalogicalMappingTask>,
            ::std::string::String,
        >,
        anchoring_policy: ::std::result::Result<
            ::std::option::Option<super::AnchoringPolicy>,
            ::std::string::String,
        >,
        any_action_space_capability: ::std::result::Result<
            ::std::option::Option<super::AnyActionSpaceCapability>,
            ::std::string::String,
        >,
        any_exploration_branch: ::std::result::Result<
            ::std::option::Option<super::AnyExplorationBranch>,
            ::std::string::String,
        >,
        any_intent:
            ::std::result::Result<::std::option::Option<super::AnyIntent>, ::std::string::String>,
        any_node_profile: ::std::result::Result<
            ::std::option::Option<super::AnyNodeProfile>,
            ::std::string::String,
        >,
        any_panel_profile: ::std::result::Result<
            ::std::option::Option<super::AnyPanelProfile>,
            ::std::string::String,
        >,
        any_presentation_intent: ::std::result::Result<
            ::std::option::Option<super::AnyPresentationIntent>,
            ::std::string::String,
        >,
        any_state_event: ::std::result::Result<
            ::std::option::Option<super::AnyStateEvent>,
            ::std::string::String,
        >,
        any_toolchain_state: ::std::result::Result<
            ::std::option::Option<super::AnyToolchainState>,
            ::std::string::String,
        >,
        any_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::AnyTopologyManifest>,
            ::std::string::String,
        >,
        any_transition_edge: ::std::result::Result<
            ::std::option::Option<super::AnyTransitionEdge>,
            ::std::string::String,
        >,
        artifact_corruption_event: ::std::result::Result<
            ::std::option::Option<super::ArtifactCorruptionEvent>,
            ::std::string::String,
        >,
        ast_gradient_receipt: ::std::result::Result<
            ::std::option::Option<super::AstGradientReceipt>,
            ::std::string::String,
        >,
        asymptotic_complexity_receipt: ::std::result::Result<
            ::std::option::Option<super::AsymptoticComplexityReceipt>,
            ::std::string::String,
        >,
        atomic_proposition_state: ::std::result::Result<
            ::std::option::Option<super::AtomicPropositionState>,
            ::std::string::String,
        >,
        attack_vector_profile: ::std::result::Result<
            ::std::option::Option<super::AttackVectorProfile>,
            ::std::string::String,
        >,
        auction_mechanism_profile: ::std::result::Result<
            ::std::option::Option<super::AuctionMechanismProfile>,
            ::std::string::String,
        >,
        auction_policy: ::std::result::Result<
            ::std::option::Option<super::AuctionPolicy>,
            ::std::string::String,
        >,
        auction_state: ::std::result::Result<
            ::std::option::Option<super::AuctionState>,
            ::std::string::String,
        >,
        backpressure_policy: ::std::result::Result<
            ::std::option::Option<super::BackpressurePolicy>,
            ::std::string::String,
        >,
        barge_in_interrupt_event: ::std::result::Result<
            ::std::option::Option<super::BargeInInterruptEvent>,
            ::std::string::String,
        >,
        belief_modulation_receipt: ::std::result::Result<
            ::std::option::Option<super::BeliefModulationReceipt>,
            ::std::string::String,
        >,
        belief_mutation_event: ::std::result::Result<
            ::std::option::Option<super::BeliefMutationEvent>,
            ::std::string::String,
        >,
        bounded_intervention_scope_policy: ::std::result::Result<
            ::std::option::Option<super::BoundedInterventionScopePolicy>,
            ::std::string::String,
        >,
        bounded_jsonrpc_intent: ::std::result::Result<
            ::std::option::Option<super::BoundedJsonrpcIntent>,
            ::std::string::String,
        >,
        browser_dom_state: ::std::result::Result<
            ::std::option::Option<super::BrowserDomState>,
            ::std::string::String,
        >,
        budget_exhaustion_event: ::std::result::Result<
            ::std::option::Option<super::BudgetExhaustionEvent>,
            ::std::string::String,
        >,
        bundle_content_hash_state: ::std::result::Result<
            ::std::option::Option<super::BundleContentHashState>,
            ::std::string::String,
        >,
        bypass_receipt: ::std::result::Result<
            ::std::option::Option<super::BypassReceipt>,
            ::std::string::String,
        >,
        capability_forge_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::CapabilityForgeTopologyManifest>,
            ::std::string::String,
        >,
        capability_pointer_state: ::std::result::Result<
            ::std::option::Option<super::CapabilityPointerState>,
            ::std::string::String,
        >,
        causal_attribution_state: ::std::result::Result<
            ::std::option::Option<super::CausalAttributionState>,
            ::std::string::String,
        >,
        causal_directed_edge_state: ::std::result::Result<
            ::std::option::Option<super::CausalDirectedEdgeState>,
            ::std::string::String,
        >,
        causal_explanation_event: ::std::result::Result<
            ::std::option::Option<super::CausalExplanationEvent>,
            ::std::string::String,
        >,
        causal_interval_profile: ::std::result::Result<
            ::std::option::Option<super::CausalIntervalProfile>,
            ::std::string::String,
        >,
        causal_propagation_intent: ::std::result::Result<
            ::std::option::Option<super::CausalPropagationIntent>,
            ::std::string::String,
        >,
        circuit_breaker_event: ::std::result::Result<
            ::std::option::Option<super::CircuitBreakerEvent>,
            ::std::string::String,
        >,
        cognitive_action_space_manifest: ::std::result::Result<
            ::std::option::Option<super::CognitiveActionSpaceManifest>,
            ::std::string::String,
        >,
        cognitive_agent_node_profile: ::std::result::Result<
            ::std::option::Option<super::CognitiveAgentNodeProfile>,
            ::std::string::String,
        >,
        cognitive_critique_profile: ::std::result::Result<
            ::std::option::Option<super::CognitiveCritiqueProfile>,
            ::std::string::String,
        >,
        cognitive_detailed_balance_contract: ::std::result::Result<
            ::std::option::Option<super::CognitiveDetailedBalanceContract>,
            ::std::string::String,
        >,
        cognitive_dual_verification_receipt: ::std::result::Result<
            ::std::option::Option<super::CognitiveDualVerificationReceipt>,
            ::std::string::String,
        >,
        cognitive_human_node_profile: ::std::result::Result<
            ::std::option::Option<super::CognitiveHumanNodeProfile>,
            ::std::string::String,
        >,
        cognitive_prediction_receipt: ::std::result::Result<
            ::std::option::Option<super::CognitivePredictionReceipt>,
            ::std::string::String,
        >,
        cognitive_reasoning_trace_state: ::std::result::Result<
            ::std::option::Option<super::CognitiveReasoningTraceState>,
            ::std::string::String,
        >,
        cognitive_routing_contract: ::std::result::Result<
            ::std::option::Option<super::CognitiveRoutingContract>,
            ::std::string::String,
        >,
        cognitive_sampling_policy: ::std::result::Result<
            ::std::option::Option<super::CognitiveSamplingPolicy>,
            ::std::string::String,
        >,
        cognitive_state_profile: ::std::result::Result<
            ::std::option::Option<super::CognitiveStateProfile>,
            ::std::string::String,
        >,
        cognitive_swarm_deployment_manifest: ::std::result::Result<
            ::std::option::Option<super::CognitiveSwarmDeploymentManifest>,
            ::std::string::String,
        >,
        cognitive_system_node_profile: ::std::result::Result<
            ::std::option::Option<super::CognitiveSystemNodeProfile>,
            ::std::string::String,
        >,
        cognitive_tier_profile: ::std::result::Result<
            ::std::option::Option<super::CognitiveTierProfile>,
            ::std::string::String,
        >,
        cognitive_uncertainty_profile: ::std::result::Result<
            ::std::option::Option<super::CognitiveUncertaintyProfile>,
            ::std::string::String,
        >,
        collective_intelligence_profile: ::std::result::Result<
            ::std::option::Option<super::CollectiveIntelligenceProfile>,
            ::std::string::String,
        >,
        composite_node_profile: ::std::result::Result<
            ::std::option::Option<super::CompositeNodeProfile>,
            ::std::string::String,
        >,
        compute_engine_profile: ::std::result::Result<
            ::std::option::Option<super::ComputeEngineProfile>,
            ::std::string::String,
        >,
        compute_provisioning_intent: ::std::result::Result<
            ::std::option::Option<super::ComputeProvisioningIntent>,
            ::std::string::String,
        >,
        compute_rate_contract: ::std::result::Result<
            ::std::option::Option<super::ComputeRateContract>,
            ::std::string::String,
        >,
        consensus_federation_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::ConsensusFederationTopologyManifest>,
            ::std::string::String,
        >,
        consensus_policy: ::std::result::Result<
            ::std::option::Option<super::ConsensusPolicy>,
            ::std::string::String,
        >,
        constitutional_amendment_intent: ::std::result::Result<
            ::std::option::Option<super::ConstitutionalAmendmentIntent>,
            ::std::string::String,
        >,
        constrained_decoding_policy: ::std::result::Result<
            ::std::option::Option<super::ConstrainedDecodingPolicy>,
            ::std::string::String,
        >,
        context_expansion_policy: ::std::result::Result<
            ::std::option::Option<super::ContextExpansionPolicy>,
            ::std::string::String,
        >,
        contextual_semantic_resolution_intent: ::std::result::Result<
            ::std::option::Option<super::ContextualSemanticResolutionIntent>,
            ::std::string::String,
        >,
        contextualized_source_state: ::std::result::Result<
            ::std::option::Option<super::ContextualizedSourceState>,
            ::std::string::String,
        >,
        continuous_manifold_mapping_contract: ::std::result::Result<
            ::std::option::Option<super::ContinuousManifoldMappingContract>,
            ::std::string::String,
        >,
        continuous_mutation_policy: ::std::result::Result<
            ::std::option::Option<super::ContinuousMutationPolicy>,
            ::std::string::String,
        >,
        continuous_observation_state: ::std::result::Result<
            ::std::option::Option<super::ContinuousObservationState>,
            ::std::string::String,
        >,
        continuous_spatial_mutation_intent: ::std::result::Result<
            ::std::option::Option<super::ContinuousSpatialMutationIntent>,
            ::std::string::String,
        >,
        council_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::CouncilTopologyManifest>,
            ::std::string::String,
        >,
        counterfactual_regret_event: ::std::result::Result<
            ::std::option::Option<super::CounterfactualRegretEvent>,
            ::std::string::String,
        >,
        crossover_mechanism_profile: ::std::result::Result<
            ::std::option::Option<super::CrossoverMechanismProfile>,
            ::std::string::String,
        >,
        crossover_policy: ::std::result::Result<
            ::std::option::Option<super::CrossoverPolicy>,
            ::std::string::String,
        >,
        crosswalk_resolution_receipt: ::std::result::Result<
            ::std::option::Option<super::CrosswalkResolutionReceipt>,
            ::std::string::String,
        >,
        cryptographic_provenance_policy: ::std::result::Result<
            ::std::option::Option<super::CryptographicProvenancePolicy>,
            ::std::string::String,
        >,
        crystallization_policy: ::std::result::Result<
            ::std::option::Option<super::CrystallizationPolicy>,
            ::std::string::String,
        >,
        custody_receipt: ::std::result::Result<
            ::std::option::Option<super::CustodyReceipt>,
            ::std::string::String,
        >,
        cyclic_edge_profile: ::std::result::Result<
            ::std::option::Option<super::CyclicEdgeProfile>,
            ::std::string::String,
        >,
        dag_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::DagTopologyManifest>,
            ::std::string::String,
        >,
        defeasible_attack_event: ::std::result::Result<
            ::std::option::Option<super::DefeasibleAttackEvent>,
            ::std::string::String,
        >,
        defeasible_cascade_event: ::std::result::Result<
            ::std::option::Option<super::DefeasibleCascadeEvent>,
            ::std::string::String,
        >,
        delegated_capability_manifest: ::std::result::Result<
            ::std::option::Option<super::DelegatedCapabilityManifest>,
            ::std::string::String,
        >,
        deliberative_envelope: ::std::result::Result<
            ::std::option::Option<super::DeliberativeEnvelope>,
            ::std::string::String,
        >,
        dempster_shafer_belief_vector: ::std::result::Result<
            ::std::option::Option<super::DempsterShaferBeliefVector>,
            ::std::string::String,
        >,
        derivation_mode_profile: ::std::result::Result<
            ::std::option::Option<super::DerivationModeProfile>,
            ::std::string::String,
        >,
        differentiable_logic_policy: ::std::result::Result<
            ::std::option::Option<super::DifferentiableLogicPolicy>,
            ::std::string::String,
        >,
        digital_twin_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::DigitalTwinTopologyManifest>,
            ::std::string::String,
        >,
        discourse_node_state: ::std::result::Result<
            ::std::option::Option<super::DiscourseNodeState>,
            ::std::string::String,
        >,
        discourse_tree_manifest: ::std::result::Result<
            ::std::option::Option<super::DiscourseTreeManifest>,
            ::std::string::String,
        >,
        distribution_profile: ::std::result::Result<
            ::std::option::Option<super::DistributionProfile>,
            ::std::string::String,
        >,
        distribution_shape_profile: ::std::result::Result<
            ::std::option::Option<super::DistributionShapeProfile>,
            ::std::string::String,
        >,
        diversity_policy: ::std::result::Result<
            ::std::option::Option<super::DiversityPolicy>,
            ::std::string::String,
        >,
        document_knowledge_graph_manifest: ::std::result::Result<
            ::std::option::Option<super::DocumentKnowledgeGraphManifest>,
            ::std::string::String,
        >,
        document_layout_manifest: ::std::result::Result<
            ::std::option::Option<super::DocumentLayoutManifest>,
            ::std::string::String,
        >,
        document_layout_region_state: ::std::result::Result<
            ::std::option::Option<super::DocumentLayoutRegionState>,
            ::std::string::String,
        >,
        drafting_intent: ::std::result::Result<
            ::std::option::Option<super::DraftingIntent>,
            ::std::string::String,
        >,
        dynamic_convergence_sla: ::std::result::Result<
            ::std::option::Option<super::DynamicConvergenceSla>,
            ::std::string::String,
        >,
        dynamic_layout_manifest: ::std::result::Result<
            ::std::option::Option<super::DynamicLayoutManifest>,
            ::std::string::String,
        >,
        dynamic_manifold_projection_manifest: ::std::result::Result<
            ::std::option::Option<super::DynamicManifoldProjectionManifest>,
            ::std::string::String,
        >,
        dynamic_routing_manifest: ::std::result::Result<
            ::std::option::Option<super::DynamicRoutingManifest>,
            ::std::string::String,
        >,
        edge_mapping_contract: ::std::result::Result<
            ::std::option::Option<super::EdgeMappingContract>,
            ::std::string::String,
        >,
        embodied_sensory_vector_profile: ::std::result::Result<
            ::std::option::Option<super::EmbodiedSensoryVectorProfile>,
            ::std::string::String,
        >,
        empirical_falsification_contract: ::std::result::Result<
            ::std::option::Option<super::EmpiricalFalsificationContract>,
            ::std::string::String,
        >,
        empirical_statistical_profile: ::std::result::Result<
            ::std::option::Option<super::EmpiricalStatisticalProfile>,
            ::std::string::String,
        >,
        ensemble_topology_profile: ::std::result::Result<
            ::std::option::Option<super::EnsembleTopologyProfile>,
            ::std::string::String,
        >,
        ephemeral_namespace_partition_state: ::std::result::Result<
            ::std::option::Option<super::EphemeralNamespacePartitionState>,
            ::std::string::String,
        >,
        epistemic_argument_claim_state: ::std::result::Result<
            ::std::option::Option<super::EpistemicArgumentClaimState>,
            ::std::string::String,
        >,
        epistemic_argument_graph_state: ::std::result::Result<
            ::std::option::Option<super::EpistemicArgumentGraphState>,
            ::std::string::String,
        >,
        epistemic_attention_state: ::std::result::Result<
            ::std::option::Option<super::EpistemicAttentionState>,
            ::std::string::String,
        >,
        epistemic_axiom_state: ::std::result::Result<
            ::std::option::Option<super::EpistemicAxiomState>,
            ::std::string::String,
        >,
        epistemic_axiom_verification_receipt: ::std::result::Result<
            ::std::option::Option<super::EpistemicAxiomVerificationReceipt>,
            ::std::string::String,
        >,
        epistemic_chain_graph_state: ::std::result::Result<
            ::std::option::Option<super::EpistemicChainGraphState>,
            ::std::string::String,
        >,
        epistemic_compression_sla: ::std::result::Result<
            ::std::option::Option<super::EpistemicCompressionSla>,
            ::std::string::String,
        >,
        epistemic_constraint_policy: ::std::result::Result<
            ::std::option::Option<super::EpistemicConstraintPolicy>,
            ::std::string::String,
        >,
        epistemic_curriculum_manifest: ::std::result::Result<
            ::std::option::Option<super::EpistemicCurriculumManifest>,
            ::std::string::String,
        >,
        epistemic_domain_graph_manifest: ::std::result::Result<
            ::std::option::Option<super::EpistemicDomainGraphManifest>,
            ::std::string::String,
        >,
        epistemic_escalation_contract: ::std::result::Result<
            ::std::option::Option<super::EpistemicEscalationContract>,
            ::std::string::String,
        >,
        epistemic_flow_state_receipt: ::std::result::Result<
            ::std::option::Option<super::EpistemicFlowStateReceipt>,
            ::std::string::String,
        >,
        epistemic_grounded_task_manifest: ::std::result::Result<
            ::std::option::Option<super::EpistemicGroundedTaskManifest>,
            ::std::string::String,
        >,
        epistemic_guardrails_manifest: ::std::result::Result<
            ::std::option::Option<super::EpistemicGuardrailsManifest>,
            ::std::string::String,
        >,
        epistemic_hydration_policy: ::std::result::Result<
            ::std::option::Option<super::EpistemicHydrationPolicy>,
            ::std::string::String,
        >,
        epistemic_ledger_state: ::std::result::Result<
            ::std::option::Option<super::EpistemicLedgerState>,
            ::std::string::String,
        >,
        epistemic_log_event: ::std::result::Result<
            ::std::option::Option<super::EpistemicLogEvent>,
            ::std::string::String,
        >,
        epistemic_promotion_event: ::std::result::Result<
            ::std::option::Option<super::EpistemicPromotionEvent>,
            ::std::string::String,
        >,
        epistemic_provenance_receipt: ::std::result::Result<
            ::std::option::Option<super::EpistemicProvenanceReceipt>,
            ::std::string::String,
        >,
        epistemic_proxy_state: ::std::result::Result<
            ::std::option::Option<super::EpistemicProxyState>,
            ::std::string::String,
        >,
        epistemic_proxy_state_any: ::std::result::Result<
            ::std::option::Option<super::EpistemicProxyStateAny>,
            ::std::string::String,
        >,
        epistemic_quarantine_snapshot: ::std::result::Result<
            ::std::option::Option<super::EpistemicQuarantineSnapshot>,
            ::std::string::String,
        >,
        epistemic_rejection_receipt: ::std::result::Result<
            ::std::option::Option<super::EpistemicRejectionReceipt>,
            ::std::string::String,
        >,
        epistemic_rigidity_policy: ::std::result::Result<
            ::std::option::Option<super::EpistemicRigidityPolicy>,
            ::std::string::String,
        >,
        epistemic_scanning_policy: ::std::result::Result<
            ::std::option::Option<super::EpistemicScanningPolicy>,
            ::std::string::String,
        >,
        epistemic_security_policy: ::std::result::Result<
            ::std::option::Option<super::EpistemicSecurityPolicy>,
            ::std::string::String,
        >,
        epistemic_security_profile: ::std::result::Result<
            ::std::option::Option<super::EpistemicSecurityProfile>,
            ::std::string::String,
        >,
        epistemic_seed_injection_policy: ::std::result::Result<
            ::std::option::Option<super::EpistemicSeedInjectionPolicy>,
            ::std::string::String,
        >,
        epistemic_sop_manifest: ::std::result::Result<
            ::std::option::Option<super::EpistemicSopManifest>,
            ::std::string::String,
        >,
        epistemic_starvation_event: ::std::result::Result<
            ::std::option::Option<super::EpistemicStarvationEvent>,
            ::std::string::String,
        >,
        epistemic_telemetry_event: ::std::result::Result<
            ::std::option::Option<super::EpistemicTelemetryEvent>,
            ::std::string::String,
        >,
        epistemic_topological_proof_manifest: ::std::result::Result<
            ::std::option::Option<super::EpistemicTopologicalProofManifest>,
            ::std::string::String,
        >,
        epistemic_transmutation_task: ::std::result::Result<
            ::std::option::Option<super::EpistemicTransmutationTask>,
            ::std::string::String,
        >,
        epistemic_upsampling_task: ::std::result::Result<
            ::std::option::Option<super::EpistemicUpsamplingTask>,
            ::std::string::String,
        >,
        epistemic_zero_trust_contract: ::std::result::Result<
            ::std::option::Option<super::EpistemicZeroTrustContract>,
            ::std::string::String,
        >,
        epistemic_zero_trust_receipt: ::std::result::Result<
            ::std::option::Option<super::EpistemicZeroTrustReceipt>,
            ::std::string::String,
        >,
        escalation_contract: ::std::result::Result<
            ::std::option::Option<super::EscalationContract>,
            ::std::string::String,
        >,
        escalation_intent: ::std::result::Result<
            ::std::option::Option<super::EscalationIntent>,
            ::std::string::String,
        >,
        escrow_policy: ::std::result::Result<
            ::std::option::Option<super::EscrowPolicy>,
            ::std::string::String,
        >,
        evaluator_optimizer_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::EvaluatorOptimizerTopologyManifest>,
            ::std::string::String,
        >,
        eviction_policy: ::std::result::Result<
            ::std::option::Option<super::EvictionPolicy>,
            ::std::string::String,
        >,
        evidentiary_citation_state: ::std::result::Result<
            ::std::option::Option<super::EvidentiaryCitationState>,
            ::std::string::String,
        >,
        evidentiary_grounding_sla: ::std::result::Result<
            ::std::option::Option<super::EvidentiaryGroundingSla>,
            ::std::string::String,
        >,
        evidentiary_warrant_state: ::std::result::Result<
            ::std::option::Option<super::EvidentiaryWarrantState>,
            ::std::string::String,
        >,
        evolutionary_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::EvolutionaryTopologyManifest>,
            ::std::string::String,
        >,
        execution_envelope_state: ::std::result::Result<
            ::std::option::Option<super::ExecutionEnvelopeState>,
            ::std::string::String,
        >,
        execution_sla: ::std::result::Result<
            ::std::option::Option<super::ExecutionSla>,
            ::std::string::String,
        >,
        execution_substrate_profile: ::std::result::Result<
            ::std::option::Option<super::ExecutionSubstrateProfile>,
            ::std::string::String,
        >,
        exogenous_epistemic_event: ::std::result::Result<
            ::std::option::Option<super::ExogenousEpistemicEvent>,
            ::std::string::String,
        >,
        facet_matrix_profile: ::std::result::Result<
            ::std::option::Option<super::FacetMatrixProfile>,
            ::std::string::String,
        >,
        fallback_intent: ::std::result::Result<
            ::std::option::Option<super::FallbackIntent>,
            ::std::string::String,
        >,
        fallback_sla:
            ::std::result::Result<::std::option::Option<super::FallbackSla>, ::std::string::String>,
        falsification_contract: ::std::result::Result<
            ::std::option::Option<super::FalsificationContract>,
            ::std::string::String,
        >,
        fitness_objective_profile: ::std::result::Result<
            ::std::option::Option<super::FitnessObjectiveProfile>,
            ::std::string::String,
        >,
        formal_logic_premise: ::std::result::Result<
            ::std::option::Option<super::FormalLogicPremise>,
            ::std::string::String,
        >,
        formal_verification_contract: ::std::result::Result<
            ::std::option::Option<super::FormalVerificationContract>,
            ::std::string::String,
        >,
        formal_verification_receipt: ::std::result::Result<
            ::std::option::Option<super::FormalVerificationReceipt>,
            ::std::string::String,
        >,
        fyi_intent:
            ::std::result::Result<::std::option::Option<super::FyiIntent>, ::std::string::String>,
        generative_manifold_sla: ::std::result::Result<
            ::std::option::Option<super::GenerativeManifoldSla>,
            ::std::string::String,
        >,
        generative_taxonomy_manifest: ::std::result::Result<
            ::std::option::Option<super::GenerativeTaxonomyManifest>,
            ::std::string::String,
        >,
        global_governance_policy: ::std::result::Result<
            ::std::option::Option<super::GlobalGovernancePolicy>,
            ::std::string::String,
        >,
        global_semantic_invariant_profile: ::std::result::Result<
            ::std::option::Option<super::GlobalSemanticInvariantProfile>,
            ::std::string::String,
        >,
        global_semantic_profile: ::std::result::Result<
            ::std::option::Option<super::GlobalSemanticProfile>,
            ::std::string::String,
        >,
        grading_criterion_profile: ::std::result::Result<
            ::std::option::Option<super::GradingCriterionProfile>,
            ::std::string::String,
        >,
        grammar_panel_profile: ::std::result::Result<
            ::std::option::Option<super::GrammarPanelProfile>,
            ::std::string::String,
        >,
        graph_flattening_policy: ::std::result::Result<
            ::std::option::Option<super::GraphFlatteningPolicy>,
            ::std::string::String,
        >,
        guardrail_violation_event: ::std::result::Result<
            ::std::option::Option<super::GuardrailViolationEvent>,
            ::std::string::String,
        >,
        hardware_enclave_receipt: ::std::result::Result<
            ::std::option::Option<super::HardwareEnclaveReceipt>,
            ::std::string::String,
        >,
        hierarchical_dom_manifest: ::std::result::Result<
            ::std::option::Option<super::HierarchicalDomManifest>,
            ::std::string::String,
        >,
        hoare_logic_proof_receipt: ::std::result::Result<
            ::std::option::Option<super::HoareLogicProofReceipt>,
            ::std::string::String,
        >,
        homomorphic_encryption_profile: ::std::result::Result<
            ::std::option::Option<super::HomomorphicEncryptionProfile>,
            ::std::string::String,
        >,
        http_transport_profile: ::std::result::Result<
            ::std::option::Option<super::HttpTransportProfile>,
            ::std::string::String,
        >,
        human_directive_intent: ::std::result::Result<
            ::std::option::Option<super::HumanDirectiveIntent>,
            ::std::string::String,
        >,
        hypothesis_generation_event: ::std::result::Result<
            ::std::option::Option<super::HypothesisGenerationEvent>,
            ::std::string::String,
        >,
        hypothesis_stake_receipt: ::std::result::Result<
            ::std::option::Option<super::HypothesisStakeReceipt>,
            ::std::string::String,
        >,
        hypothesis_superposition_state: ::std::result::Result<
            ::std::option::Option<super::HypothesisSuperpositionState>,
            ::std::string::String,
        >,
        ideation_phase_profile: ::std::result::Result<
            ::std::option::Option<super::IdeationPhaseProfile>,
            ::std::string::String,
        >,
        illocutionary_force_profile: ::std::result::Result<
            ::std::option::Option<super::IllocutionaryForceProfile>,
            ::std::string::String,
        >,
        input_mapping_contract: ::std::result::Result<
            ::std::option::Option<super::InputMappingContract>,
            ::std::string::String,
        >,
        insight_card_profile: ::std::result::Result<
            ::std::option::Option<super::InsightCardProfile>,
            ::std::string::String,
        >,
        intent_classification_receipt: ::std::result::Result<
            ::std::option::Option<super::IntentClassificationReceipt>,
            ::std::string::String,
        >,
        intent_elicitation_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::IntentElicitationTopologyManifest>,
            ::std::string::String,
        >,
        intervention_intent: ::std::result::Result<
            ::std::option::Option<super::InterventionIntent>,
            ::std::string::String,
        >,
        intervention_policy: ::std::result::Result<
            ::std::option::Option<super::InterventionPolicy>,
            ::std::string::String,
        >,
        intervention_receipt: ::std::result::Result<
            ::std::option::Option<super::InterventionReceipt>,
            ::std::string::String,
        >,
        interventional_causal_task: ::std::result::Result<
            ::std::option::Option<super::InterventionalCausalTask>,
            ::std::string::String,
        >,
        json_primitive_state: ::std::result::Result<
            ::std::option::Option<super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        jsonrpc_error_response_state: ::std::result::Result<
            ::std::option::Option<super::JsonrpcErrorResponseState>,
            ::std::string::String,
        >,
        jsonrpc_error_state: ::std::result::Result<
            ::std::option::Option<super::JsonrpcErrorState>,
            ::std::string::String,
        >,
        kinematic_delta_manifest: ::std::result::Result<
            ::std::option::Option<super::KinematicDeltaManifest>,
            ::std::string::String,
        >,
        kinematic_derivative_profile: ::std::result::Result<
            ::std::option::Option<super::KinematicDerivativeProfile>,
            ::std::string::String,
        >,
        kinetic_budget_policy: ::std::result::Result<
            ::std::option::Option<super::KineticBudgetPolicy>,
            ::std::string::String,
        >,
        kinetic_separation_policy: ::std::result::Result<
            ::std::option::Option<super::KineticSeparationPolicy>,
            ::std::string::String,
        >,
        latent_projection_intent: ::std::result::Result<
            ::std::option::Option<super::LatentProjectionIntent>,
            ::std::string::String,
        >,
        latent_schema_inference_intent: ::std::result::Result<
            ::std::option::Option<super::LatentSchemaInferenceIntent>,
            ::std::string::String,
        >,
        latent_scratchpad_receipt: ::std::result::Result<
            ::std::option::Option<super::LatentScratchpadReceipt>,
            ::std::string::String,
        >,
        latent_smoothing_profile: ::std::result::Result<
            ::std::option::Option<super::LatentSmoothingProfile>,
            ::std::string::String,
        >,
        lifecycle_trigger_event: ::std::result::Result<
            ::std::option::Option<super::LifecycleTriggerEvent>,
            ::std::string::String,
        >,
        lineage_watermark_receipt: ::std::result::Result<
            ::std::option::Option<super::LineageWatermarkReceipt>,
            ::std::string::String,
        >,
        link_ml_validation_sla: ::std::result::Result<
            ::std::option::Option<super::LinkMlValidationSla>,
            ::std::string::String,
        >,
        logit_steganography_contract: ::std::result::Result<
            ::std::option::Option<super::LogitSteganographyContract>,
            ::std::string::String,
        >,
        macro_grid_profile: ::std::result::Result<
            ::std::option::Option<super::MacroGridProfile>,
            ::std::string::String,
        >,
        manifest_violation_receipt: ::std::result::Result<
            ::std::option::Option<super::ManifestViolationReceipt>,
            ::std::string::String,
        >,
        manifold_alignment_metric_profile: ::std::result::Result<
            ::std::option::Option<super::ManifoldAlignmentMetricProfile>,
            ::std::string::String,
        >,
        market_contract: ::std::result::Result<
            ::std::option::Option<super::MarketContract>,
            ::std::string::String,
        >,
        market_resolution_state: ::std::result::Result<
            ::std::option::Option<super::MarketResolutionState>,
            ::std::string::String,
        >,
        markov_blanket_rendering_policy: ::std::result::Result<
            ::std::option::Option<super::MarkovBlanketRenderingPolicy>,
            ::std::string::String,
        >,
        mcp_capability_whitelist_policy: ::std::result::Result<
            ::std::option::Option<super::McpCapabilityWhitelistPolicy>,
            ::std::string::String,
        >,
        mcp_client_intent: ::std::result::Result<
            ::std::option::Option<super::McpClientIntent>,
            ::std::string::String,
        >,
        mcp_prompt_reference_state: ::std::result::Result<
            ::std::option::Option<super::McpPromptReferenceState>,
            ::std::string::String,
        >,
        mcp_resource_manifest: ::std::result::Result<
            ::std::option::Option<super::McpResourceManifest>,
            ::std::string::String,
        >,
        mcp_server_manifest: ::std::result::Result<
            ::std::option::Option<super::McpServerManifest>,
            ::std::string::String,
        >,
        mcp_tool_definition: ::std::result::Result<
            ::std::option::Option<super::McpToolDefinition>,
            ::std::string::String,
        >,
        mechanistic_audit_contract: ::std::result::Result<
            ::std::option::Option<super::MechanisticAuditContract>,
            ::std::string::String,
        >,
        memoized_node_profile: ::std::result::Result<
            ::std::option::Option<super::MemoizedNodeProfile>,
            ::std::string::String,
        >,
        multimodal_artifact_receipt: ::std::result::Result<
            ::std::option::Option<super::MultimodalArtifactReceipt>,
            ::std::string::String,
        >,
        multimodal_token_anchor_state: ::std::result::Result<
            ::std::option::Option<super::MultimodalTokenAnchorState>,
            ::std::string::String,
        >,
        mutation_policy: ::std::result::Result<
            ::std::option::Option<super::MutationPolicy>,
            ::std::string::String,
        >,
        n_dimensional_tensor_manifest: ::std::result::Result<
            ::std::option::Option<super::NDimensionalTensorManifest>,
            ::std::string::String,
        >,
        neural_audit_attestation_receipt: ::std::result::Result<
            ::std::option::Option<super::NeuralAuditAttestationReceipt>,
            ::std::string::String,
        >,
        neuro_symbolic_handoff_contract: ::std::result::Result<
            ::std::option::Option<super::NeuroSymbolicHandoffContract>,
            ::std::string::String,
        >,
        neurosymbolic_inference_intent: ::std::result::Result<
            ::std::option::Option<super::NeurosymbolicInferenceIntent>,
            ::std::string::String,
        >,
        neurosymbolic_ingestion_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::NeurosymbolicIngestionTopologyManifest>,
            ::std::string::String,
        >,
        neurosymbolic_verification_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::NeurosymbolicVerificationTopologyManifest>,
            ::std::string::String,
        >,
        node_cid_state: ::std::result::Result<
            ::std::option::Option<super::NodeCidState>,
            ::std::string::String,
        >,
        observability_lod_policy: ::std::result::Result<
            ::std::option::Option<super::ObservabilityLodPolicy>,
            ::std::string::String,
        >,
        observation_event: ::std::result::Result<
            ::std::option::Option<super::ObservationEvent>,
            ::std::string::String,
        >,
        ontological_alignment_policy: ::std::result::Result<
            ::std::option::Option<super::OntologicalAlignmentPolicy>,
            ::std::string::String,
        >,
        ontological_crosswalk_intent: ::std::result::Result<
            ::std::option::Option<super::OntologicalCrosswalkIntent>,
            ::std::string::String,
        >,
        ontological_normalization_intent: ::std::result::Result<
            ::std::option::Option<super::OntologicalNormalizationIntent>,
            ::std::string::String,
        >,
        ontological_reification_receipt: ::std::result::Result<
            ::std::option::Option<super::OntologicalReificationReceipt>,
            ::std::string::String,
        >,
        ontological_surface_projection_manifest: ::std::result::Result<
            ::std::option::Option<super::OntologicalSurfaceProjectionManifest>,
            ::std::string::String,
        >,
        ontology_discovery_intent: ::std::result::Result<
            ::std::option::Option<super::OntologyDiscoveryIntent>,
            ::std::string::String,
        >,
        optical_mapping_contract: ::std::result::Result<
            ::std::option::Option<super::OpticalMappingContract>,
            ::std::string::String,
        >,
        optical_parsing_sla: ::std::result::Result<
            ::std::option::Option<super::OpticalParsingSla>,
            ::std::string::String,
        >,
        optimization_direction_profile: ::std::result::Result<
            ::std::option::Option<super::OptimizationDirectionProfile>,
            ::std::string::String,
        >,
        oracle_execution_receipt: ::std::result::Result<
            ::std::option::Option<super::OracleExecutionReceipt>,
            ::std::string::String,
        >,
        output_mapping_contract: ::std::result::Result<
            ::std::option::Option<super::OutputMappingContract>,
            ::std::string::String,
        >,
        override_intent: ::std::result::Result<
            ::std::option::Option<super::OverrideIntent>,
            ::std::string::String,
        >,
        patch_operation_profile: ::std::result::Result<
            ::std::option::Option<super::PatchOperationProfile>,
            ::std::string::String,
        >,
        peft_adapter_contract: ::std::result::Result<
            ::std::option::Option<super::PeftAdapterContract>,
            ::std::string::String,
        >,
        permission_boundary_policy: ::std::result::Result<
            ::std::option::Option<super::PermissionBoundaryPolicy>,
            ::std::string::String,
        >,
        persistence_commit_receipt: ::std::result::Result<
            ::std::option::Option<super::PersistenceCommitReceipt>,
            ::std::string::String,
        >,
        post_coordinated_semantic_state: ::std::result::Result<
            ::std::option::Option<super::PostCoordinatedSemanticState>,
            ::std::string::String,
        >,
        post_quantum_signature_receipt: ::std::result::Result<
            ::std::option::Option<super::PostQuantumSignatureReceipt>,
            ::std::string::String,
        >,
        prediction_market_policy: ::std::result::Result<
            ::std::option::Option<super::PredictionMarketPolicy>,
            ::std::string::String,
        >,
        prediction_market_state: ::std::result::Result<
            ::std::option::Option<super::PredictionMarketState>,
            ::std::string::String,
        >,
        presentation_manifest: ::std::result::Result<
            ::std::option::Option<super::PresentationManifest>,
            ::std::string::String,
        >,
        procedural_metadata_manifest: ::std::result::Result<
            ::std::option::Option<super::ProceduralMetadataManifest>,
            ::std::string::String,
        >,
        process_reward_contract: ::std::result::Result<
            ::std::option::Option<super::ProcessRewardContract>,
            ::std::string::String,
        >,
        profile_cid_state: ::std::result::Result<
            ::std::option::Option<super::ProfileCidState>,
            ::std::string::String,
        >,
        qo_s_classification_profile: ::std::result::Result<
            ::std::option::Option<super::QoSClassificationProfile>,
            ::std::string::String,
        >,
        quarantine_intent: ::std::result::Result<
            ::std::option::Option<super::QuarantineIntent>,
            ::std::string::String,
        >,
        quorum_policy: ::std::result::Result<
            ::std::option::Option<super::QuorumPolicy>,
            ::std::string::String,
        >,
        rdf_export_receipt: ::std::result::Result<
            ::std::option::Option<super::RdfExportReceipt>,
            ::std::string::String,
        >,
        rdf_serialization_intent: ::std::result::Result<
            ::std::option::Option<super::RdfSerializationIntent>,
            ::std::string::String,
        >,
        reasoning_engineering_policy: ::std::result::Result<
            ::std::option::Option<super::ReasoningEngineeringPolicy>,
            ::std::string::String,
        >,
        rhetorical_structure_profile: ::std::result::Result<
            ::std::option::Option<super::RhetoricalStructureProfile>,
            ::std::string::String,
        >,
        risk_level_policy: ::std::result::Result<
            ::std::option::Option<super::RiskLevelPolicy>,
            ::std::string::String,
        >,
        rollback_intent: ::std::result::Result<
            ::std::option::Option<super::RollbackIntent>,
            ::std::string::String,
        >,
        routing_frontier_policy: ::std::result::Result<
            ::std::option::Option<super::RoutingFrontierPolicy>,
            ::std::string::String,
        >,
        sae_feature_activation_state: ::std::result::Result<
            ::std::option::Option<super::SaeFeatureActivationState>,
            ::std::string::String,
        >,
        sae_latent_policy: ::std::result::Result<
            ::std::option::Option<super::SaeLatentPolicy>,
            ::std::string::String,
        >,
        salience_profile: ::std::result::Result<
            ::std::option::Option<super::SalienceProfile>,
            ::std::string::String,
        >,
        scale_policy:
            ::std::result::Result<::std::option::Option<super::ScalePolicy>, ::std::string::String>,
        schema_driven_extraction_sla: ::std::result::Result<
            ::std::option::Option<super::SchemaDrivenExtractionSla>,
            ::std::string::String,
        >,
        se3_transform_profile: ::std::result::Result<
            ::std::option::Option<super::Se3TransformProfile>,
            ::std::string::String,
        >,
        secure_sub_session_state: ::std::result::Result<
            ::std::option::Option<super::SecureSubSessionState>,
            ::std::string::String,
        >,
        self_correction_policy: ::std::result::Result<
            ::std::option::Option<super::SelfCorrectionPolicy>,
            ::std::string::String,
        >,
        semantic_discovery_intent: ::std::result::Result<
            ::std::option::Option<super::SemanticDiscoveryIntent>,
            ::std::string::String,
        >,
        semantic_edge_state: ::std::result::Result<
            ::std::option::Option<super::SemanticEdgeState>,
            ::std::string::String,
        >,
        semantic_firewall_policy: ::std::result::Result<
            ::std::option::Option<super::SemanticFirewallPolicy>,
            ::std::string::String,
        >,
        semantic_flow_policy: ::std::result::Result<
            ::std::option::Option<super::SemanticFlowPolicy>,
            ::std::string::String,
        >,
        semantic_intent: ::std::result::Result<
            ::std::option::Option<super::SemanticIntent>,
            ::std::string::String,
        >,
        semantic_mapping_heuristic_intent: ::std::result::Result<
            ::std::option::Option<super::SemanticMappingHeuristicIntent>,
            ::std::string::String,
        >,
        semantic_node_state: ::std::result::Result<
            ::std::option::Option<super::SemanticNodeState>,
            ::std::string::String,
        >,
        semantic_relational_vector_state: ::std::result::Result<
            ::std::option::Option<super::SemanticRelationalVectorState>,
            ::std::string::String,
        >,
        semantic_slicing_policy: ::std::result::Result<
            ::std::option::Option<super::SemanticSlicingPolicy>,
            ::std::string::String,
        >,
        semantic_version_state: ::std::result::Result<
            ::std::option::Option<super::SemanticVersionState>,
            ::std::string::String,
        >,
        semantic_zoom_profile: ::std::result::Result<
            ::std::option::Option<super::SemanticZoomProfile>,
            ::std::string::String,
        >,
        shacl_validation_sla: ::std::result::Result<
            ::std::option::Option<super::ShaclValidationSla>,
            ::std::string::String,
        >,
        shapley_attribution_receipt: ::std::result::Result<
            ::std::option::Option<super::ShapleyAttributionReceipt>,
            ::std::string::String,
        >,
        side_effect_profile: ::std::result::Result<
            ::std::option::Option<super::SideEffectProfile>,
            ::std::string::String,
        >,
        simulation_convergence_sla: ::std::result::Result<
            ::std::option::Option<super::SimulationConvergenceSla>,
            ::std::string::String,
        >,
        simulation_escrow_contract: ::std::result::Result<
            ::std::option::Option<super::SimulationEscrowContract>,
            ::std::string::String,
        >,
        smpc_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::SmpcTopologyManifest>,
            ::std::string::String,
        >,
        sparql_query_intent: ::std::result::Result<
            ::std::option::Option<super::SparqlQueryIntent>,
            ::std::string::String,
        >,
        sparql_query_result_receipt: ::std::result::Result<
            ::std::option::Option<super::SparqlQueryResultReceipt>,
            ::std::string::String,
        >,
        spatial_billboard_contract: ::std::result::Result<
            ::std::option::Option<super::SpatialBillboardContract>,
            ::std::string::String,
        >,
        spatial_hardware_profile: ::std::result::Result<
            ::std::option::Option<super::SpatialHardwareProfile>,
            ::std::string::String,
        >,
        spatial_kinematic_action_intent: ::std::result::Result<
            ::std::option::Option<super::SpatialKinematicActionIntent>,
            ::std::string::String,
        >,
        spatial_reference_frame_manifest: ::std::result::Result<
            ::std::option::Option<super::SpatialReferenceFrameManifest>,
            ::std::string::String,
        >,
        spatial_render_material: ::std::result::Result<
            ::std::option::Option<super::SpatialRenderMaterial>,
            ::std::string::String,
        >,
        spatial_tool_manifest: ::std::result::Result<
            ::std::option::Option<super::SpatialToolManifest>,
            ::std::string::String,
        >,
        speculative_execution_policy: ::std::result::Result<
            ::std::option::Option<super::SpeculativeExecutionPolicy>,
            ::std::string::String,
        >,
        sse_transport_profile: ::std::result::Result<
            ::std::option::Option<super::SseTransportProfile>,
            ::std::string::String,
        >,
        state_contract: ::std::result::Result<
            ::std::option::Option<super::StateContract>,
            ::std::string::String,
        >,
        state_differential_manifest: ::std::result::Result<
            ::std::option::Option<super::StateDifferentialManifest>,
            ::std::string::String,
        >,
        state_hydration_manifest: ::std::result::Result<
            ::std::option::Option<super::StateHydrationManifest>,
            ::std::string::String,
        >,
        state_mutation_intent: ::std::result::Result<
            ::std::option::Option<super::StateMutationIntent>,
            ::std::string::String,
        >,
        state_vector_profile: ::std::result::Result<
            ::std::option::Option<super::StateVectorProfile>,
            ::std::string::String,
        >,
        stdio_transport_profile: ::std::result::Result<
            ::std::option::Option<super::StdioTransportProfile>,
            ::std::string::String,
        >,
        stochastic_node_state: ::std::result::Result<
            ::std::option::Option<super::StochasticNodeState>,
            ::std::string::String,
        >,
        stochastic_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::StochasticTopologyManifest>,
            ::std::string::String,
        >,
        strategic_thought_node_intent: ::std::result::Result<
            ::std::option::Option<super::StrategicThoughtNodeIntent>,
            ::std::string::String,
        >,
        streaming_disfluency_contract: ::std::result::Result<
            ::std::option::Option<super::StreamingDisfluencyContract>,
            ::std::string::String,
        >,
        structural_causal_graph_profile: ::std::result::Result<
            ::std::option::Option<super::StructuralCausalGraphProfile>,
            ::std::string::String,
        >,
        substrate_hydration_manifest: ::std::result::Result<
            ::std::option::Option<super::SubstrateHydrationManifest>,
            ::std::string::String,
        >,
        swarm_topology_manifest: ::std::result::Result<
            ::std::option::Option<super::SwarmTopologyManifest>,
            ::std::string::String,
        >,
        synthetic_generation_profile: ::std::result::Result<
            ::std::option::Option<super::SyntheticGenerationProfile>,
            ::std::string::String,
        >,
        system1_reflex_policy: ::std::result::Result<
            ::std::option::Option<super::System1ReflexPolicy>,
            ::std::string::String,
        >,
        system2_remediation_intent: ::std::result::Result<
            ::std::option::Option<super::System2RemediationIntent>,
            ::std::string::String,
        >,
        system_fault_event: ::std::result::Result<
            ::std::option::Option<super::SystemFaultEvent>,
            ::std::string::String,
        >,
        tabular_cell_state: ::std::result::Result<
            ::std::option::Option<super::TabularCellState>,
            ::std::string::String,
        >,
        tabular_encoding_profile: ::std::result::Result<
            ::std::option::Option<super::TabularEncodingProfile>,
            ::std::string::String,
        >,
        tabular_matrix_profile: ::std::result::Result<
            ::std::option::Option<super::TabularMatrixProfile>,
            ::std::string::String,
        >,
        target_topology_profile: ::std::result::Result<
            ::std::option::Option<super::TargetTopologyProfile>,
            ::std::string::String,
        >,
        task_announcement_intent: ::std::result::Result<
            ::std::option::Option<super::TaskAnnouncementIntent>,
            ::std::string::String,
        >,
        task_award_receipt: ::std::result::Result<
            ::std::option::Option<super::TaskAwardReceipt>,
            ::std::string::String,
        >,
        taxonomic_node_state: ::std::result::Result<
            ::std::option::Option<super::TaxonomicNodeState>,
            ::std::string::String,
        >,
        taxonomic_restructure_intent: ::std::result::Result<
            ::std::option::Option<super::TaxonomicRestructureIntent>,
            ::std::string::String,
        >,
        taxonomic_routing_policy: ::std::result::Result<
            ::std::option::Option<super::TaxonomicRoutingPolicy>,
            ::std::string::String,
        >,
        telemetry_backpressure_contract: ::std::result::Result<
            ::std::option::Option<super::TelemetryBackpressureContract>,
            ::std::string::String,
        >,
        telemetry_context_profile: ::std::result::Result<
            ::std::option::Option<super::TelemetryContextProfile>,
            ::std::string::String,
        >,
        telemetry_scalar_state: ::std::result::Result<
            ::std::option::Option<super::TelemetryScalarState>,
            ::std::string::String,
        >,
        teleological_isometry_receipt: ::std::result::Result<
            ::std::option::Option<super::TeleologicalIsometryReceipt>,
            ::std::string::String,
        >,
        temporal_bounds_profile: ::std::result::Result<
            ::std::option::Option<super::TemporalBoundsProfile>,
            ::std::string::String,
        >,
        temporal_checkpoint_state: ::std::result::Result<
            ::std::option::Option<super::TemporalCheckpointState>,
            ::std::string::String,
        >,
        temporal_conflict_resolution_policy: ::std::result::Result<
            ::std::option::Option<super::TemporalConflictResolutionPolicy>,
            ::std::string::String,
        >,
        temporal_edge_invalidation_intent: ::std::result::Result<
            ::std::option::Option<super::TemporalEdgeInvalidationIntent>,
            ::std::string::String,
        >,
        temporal_graph_crdt_manifest: ::std::result::Result<
            ::std::option::Option<super::TemporalGraphCrdtManifest>,
            ::std::string::String,
        >,
        tensor_structural_format_profile: ::std::result::Result<
            ::std::option::Option<super::TensorStructuralFormatProfile>,
            ::std::string::String,
        >,
        terminal_buffer_state: ::std::result::Result<
            ::std::option::Option<super::TerminalBufferState>,
            ::std::string::String,
        >,
        terminal_cognitive_event: ::std::result::Result<
            ::std::option::Option<super::TerminalCognitiveEvent>,
            ::std::string::String,
        >,
        terminal_condition_contract: ::std::result::Result<
            ::std::option::Option<super::TerminalConditionContract>,
            ::std::string::String,
        >,
        theory_of_mind_snapshot: ::std::result::Result<
            ::std::option::Option<super::TheoryOfMindSnapshot>,
            ::std::string::String,
        >,
        thought_branch_state: ::std::result::Result<
            ::std::option::Option<super::ThoughtBranchState>,
            ::std::string::String,
        >,
        tie_breaker_policy: ::std::result::Result<
            ::std::option::Option<super::TieBreakerPolicy>,
            ::std::string::String,
        >,
        token_burn_receipt: ::std::result::Result<
            ::std::option::Option<super::TokenBurnReceipt>,
            ::std::string::String,
        >,
        tool_invocation_event: ::std::result::Result<
            ::std::option::Option<super::ToolInvocationEvent>,
            ::std::string::String,
        >,
        topological_fidelity_receipt: ::std::result::Result<
            ::std::option::Option<super::TopologicalFidelityReceipt>,
            ::std::string::String,
        >,
        topological_projection_intent: ::std::result::Result<
            ::std::option::Option<super::TopologicalProjectionIntent>,
            ::std::string::String,
        >,
        topological_retrieval_contract: ::std::result::Result<
            ::std::option::Option<super::TopologicalRetrievalContract>,
            ::std::string::String,
        >,
        topology_hash_receipt: ::std::result::Result<
            ::std::option::Option<super::TopologyHashReceipt>,
            ::std::string::String,
        >,
        trace_context_state: ::std::result::Result<
            ::std::option::Option<super::TraceContextState>,
            ::std::string::String,
        >,
        transformation_mechanism_profile: ::std::result::Result<
            ::std::option::Option<super::TransformationMechanismProfile>,
            ::std::string::String,
        >,
        transition_edge_profile: ::std::result::Result<
            ::std::option::Option<super::TransitionEdgeProfile>,
            ::std::string::String,
        >,
        truth_maintenance_policy: ::std::result::Result<
            ::std::option::Option<super::TruthMaintenancePolicy>,
            ::std::string::String,
        >,
        upper_ontology_class_profile: ::std::result::Result<
            ::std::option::Option<super::UpperOntologyClassProfile>,
            ::std::string::String,
        >,
        utility_justification_graph_receipt: ::std::result::Result<
            ::std::option::Option<super::UtilityJustificationGraphReceipt>,
            ::std::string::String,
        >,
        vector_embedding_state: ::std::result::Result<
            ::std::option::Option<super::VectorEmbeddingState>,
            ::std::string::String,
        >,
        verifiable_credential_presentation_receipt: ::std::result::Result<
            ::std::option::Option<super::VerifiableCredentialPresentationReceipt>,
            ::std::string::String,
        >,
        verifiable_entropy_receipt: ::std::result::Result<
            ::std::option::Option<super::VerifiableEntropyReceipt>,
            ::std::string::String,
        >,
        viewport_projection_contract: ::std::result::Result<
            ::std::option::Option<super::ViewportProjectionContract>,
            ::std::string::String,
        >,
        visual_encoding_profile: ::std::result::Result<
            ::std::option::Option<super::VisualEncodingProfile>,
            ::std::string::String,
        >,
        volumetric_bounding_profile: ::std::result::Result<
            ::std::option::Option<super::VolumetricBoundingProfile>,
            ::std::string::String,
        >,
        volumetric_edge_profile: ::std::result::Result<
            ::std::option::Option<super::VolumetricEdgeProfile>,
            ::std::string::String,
        >,
        volumetric_partition_state: ::std::result::Result<
            ::std::option::Option<super::VolumetricPartitionState>,
            ::std::string::String,
        >,
        wetware_attestation_contract: ::std::result::Result<
            ::std::option::Option<super::WetwareAttestationContract>,
            ::std::string::String,
        >,
        workflow_manifest: ::std::result::Result<
            ::std::option::Option<super::WorkflowManifest>,
            ::std::string::String,
        >,
        zero_knowledge_receipt: ::std::result::Result<
            ::std::option::Option<super::ZeroKnowledgeReceipt>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CoReasonSharedKernelOntology {
        fn default() -> Self {
            Self {
                activation_steering_contract: Ok(Default::default()),
                active_inference_contract: Ok(Default::default()),
                adjudication_intent: Ok(Default::default()),
                adjudication_receipt: Ok(Default::default()),
                adjudication_rubric_profile: Ok(Default::default()),
                adversarial_market_topology_manifest: Ok(Default::default()),
                agent_attestation_receipt: Ok(Default::default()),
                agent_bid_intent: Ok(Default::default()),
                algebraic_refinement_contract: Ok(Default::default()),
                ambient_state: Ok(Default::default()),
                analogical_mapping_task: Ok(Default::default()),
                anchoring_policy: Ok(Default::default()),
                any_action_space_capability: Ok(Default::default()),
                any_exploration_branch: Ok(Default::default()),
                any_intent: Ok(Default::default()),
                any_node_profile: Ok(Default::default()),
                any_panel_profile: Ok(Default::default()),
                any_presentation_intent: Ok(Default::default()),
                any_state_event: Ok(Default::default()),
                any_toolchain_state: Ok(Default::default()),
                any_topology_manifest: Ok(Default::default()),
                any_transition_edge: Ok(Default::default()),
                artifact_corruption_event: Ok(Default::default()),
                ast_gradient_receipt: Ok(Default::default()),
                asymptotic_complexity_receipt: Ok(Default::default()),
                atomic_proposition_state: Ok(Default::default()),
                attack_vector_profile: Ok(Default::default()),
                auction_mechanism_profile: Ok(Default::default()),
                auction_policy: Ok(Default::default()),
                auction_state: Ok(Default::default()),
                backpressure_policy: Ok(Default::default()),
                barge_in_interrupt_event: Ok(Default::default()),
                belief_modulation_receipt: Ok(Default::default()),
                belief_mutation_event: Ok(Default::default()),
                bounded_intervention_scope_policy: Ok(Default::default()),
                bounded_jsonrpc_intent: Ok(Default::default()),
                browser_dom_state: Ok(Default::default()),
                budget_exhaustion_event: Ok(Default::default()),
                bundle_content_hash_state: Ok(Default::default()),
                bypass_receipt: Ok(Default::default()),
                capability_forge_topology_manifest: Ok(Default::default()),
                capability_pointer_state: Ok(Default::default()),
                causal_attribution_state: Ok(Default::default()),
                causal_directed_edge_state: Ok(Default::default()),
                causal_explanation_event: Ok(Default::default()),
                causal_interval_profile: Ok(Default::default()),
                causal_propagation_intent: Ok(Default::default()),
                circuit_breaker_event: Ok(Default::default()),
                cognitive_action_space_manifest: Ok(Default::default()),
                cognitive_agent_node_profile: Ok(Default::default()),
                cognitive_critique_profile: Ok(Default::default()),
                cognitive_detailed_balance_contract: Ok(Default::default()),
                cognitive_dual_verification_receipt: Ok(Default::default()),
                cognitive_human_node_profile: Ok(Default::default()),
                cognitive_prediction_receipt: Ok(Default::default()),
                cognitive_reasoning_trace_state: Ok(Default::default()),
                cognitive_routing_contract: Ok(Default::default()),
                cognitive_sampling_policy: Ok(Default::default()),
                cognitive_state_profile: Ok(Default::default()),
                cognitive_swarm_deployment_manifest: Ok(Default::default()),
                cognitive_system_node_profile: Ok(Default::default()),
                cognitive_tier_profile: Ok(Default::default()),
                cognitive_uncertainty_profile: Ok(Default::default()),
                collective_intelligence_profile: Ok(Default::default()),
                composite_node_profile: Ok(Default::default()),
                compute_engine_profile: Ok(Default::default()),
                compute_provisioning_intent: Ok(Default::default()),
                compute_rate_contract: Ok(Default::default()),
                consensus_federation_topology_manifest: Ok(Default::default()),
                consensus_policy: Ok(Default::default()),
                constitutional_amendment_intent: Ok(Default::default()),
                constrained_decoding_policy: Ok(Default::default()),
                context_expansion_policy: Ok(Default::default()),
                contextual_semantic_resolution_intent: Ok(Default::default()),
                contextualized_source_state: Ok(Default::default()),
                continuous_manifold_mapping_contract: Ok(Default::default()),
                continuous_mutation_policy: Ok(Default::default()),
                continuous_observation_state: Ok(Default::default()),
                continuous_spatial_mutation_intent: Ok(Default::default()),
                council_topology_manifest: Ok(Default::default()),
                counterfactual_regret_event: Ok(Default::default()),
                crossover_mechanism_profile: Ok(Default::default()),
                crossover_policy: Ok(Default::default()),
                crosswalk_resolution_receipt: Ok(Default::default()),
                cryptographic_provenance_policy: Ok(Default::default()),
                crystallization_policy: Ok(Default::default()),
                custody_receipt: Ok(Default::default()),
                cyclic_edge_profile: Ok(Default::default()),
                dag_topology_manifest: Ok(Default::default()),
                defeasible_attack_event: Ok(Default::default()),
                defeasible_cascade_event: Ok(Default::default()),
                delegated_capability_manifest: Ok(Default::default()),
                deliberative_envelope: Ok(Default::default()),
                dempster_shafer_belief_vector: Ok(Default::default()),
                derivation_mode_profile: Ok(Default::default()),
                differentiable_logic_policy: Ok(Default::default()),
                digital_twin_topology_manifest: Ok(Default::default()),
                discourse_node_state: Ok(Default::default()),
                discourse_tree_manifest: Ok(Default::default()),
                distribution_profile: Ok(Default::default()),
                distribution_shape_profile: Ok(Default::default()),
                diversity_policy: Ok(Default::default()),
                document_knowledge_graph_manifest: Ok(Default::default()),
                document_layout_manifest: Ok(Default::default()),
                document_layout_region_state: Ok(Default::default()),
                drafting_intent: Ok(Default::default()),
                dynamic_convergence_sla: Ok(Default::default()),
                dynamic_layout_manifest: Ok(Default::default()),
                dynamic_manifold_projection_manifest: Ok(Default::default()),
                dynamic_routing_manifest: Ok(Default::default()),
                edge_mapping_contract: Ok(Default::default()),
                embodied_sensory_vector_profile: Ok(Default::default()),
                empirical_falsification_contract: Ok(Default::default()),
                empirical_statistical_profile: Ok(Default::default()),
                ensemble_topology_profile: Ok(Default::default()),
                ephemeral_namespace_partition_state: Ok(Default::default()),
                epistemic_argument_claim_state: Ok(Default::default()),
                epistemic_argument_graph_state: Ok(Default::default()),
                epistemic_attention_state: Ok(Default::default()),
                epistemic_axiom_state: Ok(Default::default()),
                epistemic_axiom_verification_receipt: Ok(Default::default()),
                epistemic_chain_graph_state: Ok(Default::default()),
                epistemic_compression_sla: Ok(Default::default()),
                epistemic_constraint_policy: Ok(Default::default()),
                epistemic_curriculum_manifest: Ok(Default::default()),
                epistemic_domain_graph_manifest: Ok(Default::default()),
                epistemic_escalation_contract: Ok(Default::default()),
                epistemic_flow_state_receipt: Ok(Default::default()),
                epistemic_grounded_task_manifest: Ok(Default::default()),
                epistemic_guardrails_manifest: Ok(Default::default()),
                epistemic_hydration_policy: Ok(Default::default()),
                epistemic_ledger_state: Ok(Default::default()),
                epistemic_log_event: Ok(Default::default()),
                epistemic_promotion_event: Ok(Default::default()),
                epistemic_provenance_receipt: Ok(Default::default()),
                epistemic_proxy_state: Ok(Default::default()),
                epistemic_proxy_state_any: Ok(Default::default()),
                epistemic_quarantine_snapshot: Ok(Default::default()),
                epistemic_rejection_receipt: Ok(Default::default()),
                epistemic_rigidity_policy: Ok(Default::default()),
                epistemic_scanning_policy: Ok(Default::default()),
                epistemic_security_policy: Ok(Default::default()),
                epistemic_security_profile: Ok(Default::default()),
                epistemic_seed_injection_policy: Ok(Default::default()),
                epistemic_sop_manifest: Ok(Default::default()),
                epistemic_starvation_event: Ok(Default::default()),
                epistemic_telemetry_event: Ok(Default::default()),
                epistemic_topological_proof_manifest: Ok(Default::default()),
                epistemic_transmutation_task: Ok(Default::default()),
                epistemic_upsampling_task: Ok(Default::default()),
                epistemic_zero_trust_contract: Ok(Default::default()),
                epistemic_zero_trust_receipt: Ok(Default::default()),
                escalation_contract: Ok(Default::default()),
                escalation_intent: Ok(Default::default()),
                escrow_policy: Ok(Default::default()),
                evaluator_optimizer_topology_manifest: Ok(Default::default()),
                eviction_policy: Ok(Default::default()),
                evidentiary_citation_state: Ok(Default::default()),
                evidentiary_grounding_sla: Ok(Default::default()),
                evidentiary_warrant_state: Ok(Default::default()),
                evolutionary_topology_manifest: Ok(Default::default()),
                execution_envelope_state: Ok(Default::default()),
                execution_sla: Ok(Default::default()),
                execution_substrate_profile: Ok(Default::default()),
                exogenous_epistemic_event: Ok(Default::default()),
                facet_matrix_profile: Ok(Default::default()),
                fallback_intent: Ok(Default::default()),
                fallback_sla: Ok(Default::default()),
                falsification_contract: Ok(Default::default()),
                fitness_objective_profile: Ok(Default::default()),
                formal_logic_premise: Ok(Default::default()),
                formal_verification_contract: Ok(Default::default()),
                formal_verification_receipt: Ok(Default::default()),
                fyi_intent: Ok(Default::default()),
                generative_manifold_sla: Ok(Default::default()),
                generative_taxonomy_manifest: Ok(Default::default()),
                global_governance_policy: Ok(Default::default()),
                global_semantic_invariant_profile: Ok(Default::default()),
                global_semantic_profile: Ok(Default::default()),
                grading_criterion_profile: Ok(Default::default()),
                grammar_panel_profile: Ok(Default::default()),
                graph_flattening_policy: Ok(Default::default()),
                guardrail_violation_event: Ok(Default::default()),
                hardware_enclave_receipt: Ok(Default::default()),
                hierarchical_dom_manifest: Ok(Default::default()),
                hoare_logic_proof_receipt: Ok(Default::default()),
                homomorphic_encryption_profile: Ok(Default::default()),
                http_transport_profile: Ok(Default::default()),
                human_directive_intent: Ok(Default::default()),
                hypothesis_generation_event: Ok(Default::default()),
                hypothesis_stake_receipt: Ok(Default::default()),
                hypothesis_superposition_state: Ok(Default::default()),
                ideation_phase_profile: Ok(Default::default()),
                illocutionary_force_profile: Ok(Default::default()),
                input_mapping_contract: Ok(Default::default()),
                insight_card_profile: Ok(Default::default()),
                intent_classification_receipt: Ok(Default::default()),
                intent_elicitation_topology_manifest: Ok(Default::default()),
                intervention_intent: Ok(Default::default()),
                intervention_policy: Ok(Default::default()),
                intervention_receipt: Ok(Default::default()),
                interventional_causal_task: Ok(Default::default()),
                json_primitive_state: Ok(Default::default()),
                jsonrpc_error_response_state: Ok(Default::default()),
                jsonrpc_error_state: Ok(Default::default()),
                kinematic_delta_manifest: Ok(Default::default()),
                kinematic_derivative_profile: Ok(Default::default()),
                kinetic_budget_policy: Ok(Default::default()),
                kinetic_separation_policy: Ok(Default::default()),
                latent_projection_intent: Ok(Default::default()),
                latent_schema_inference_intent: Ok(Default::default()),
                latent_scratchpad_receipt: Ok(Default::default()),
                latent_smoothing_profile: Ok(Default::default()),
                lifecycle_trigger_event: Ok(Default::default()),
                lineage_watermark_receipt: Ok(Default::default()),
                link_ml_validation_sla: Ok(Default::default()),
                logit_steganography_contract: Ok(Default::default()),
                macro_grid_profile: Ok(Default::default()),
                manifest_violation_receipt: Ok(Default::default()),
                manifold_alignment_metric_profile: Ok(Default::default()),
                market_contract: Ok(Default::default()),
                market_resolution_state: Ok(Default::default()),
                markov_blanket_rendering_policy: Ok(Default::default()),
                mcp_capability_whitelist_policy: Ok(Default::default()),
                mcp_client_intent: Ok(Default::default()),
                mcp_prompt_reference_state: Ok(Default::default()),
                mcp_resource_manifest: Ok(Default::default()),
                mcp_server_manifest: Ok(Default::default()),
                mcp_tool_definition: Ok(Default::default()),
                mechanistic_audit_contract: Ok(Default::default()),
                memoized_node_profile: Ok(Default::default()),
                multimodal_artifact_receipt: Ok(Default::default()),
                multimodal_token_anchor_state: Ok(Default::default()),
                mutation_policy: Ok(Default::default()),
                n_dimensional_tensor_manifest: Ok(Default::default()),
                neural_audit_attestation_receipt: Ok(Default::default()),
                neuro_symbolic_handoff_contract: Ok(Default::default()),
                neurosymbolic_inference_intent: Ok(Default::default()),
                neurosymbolic_ingestion_topology_manifest: Ok(Default::default()),
                neurosymbolic_verification_topology_manifest: Ok(Default::default()),
                node_cid_state: Ok(Default::default()),
                observability_lod_policy: Ok(Default::default()),
                observation_event: Ok(Default::default()),
                ontological_alignment_policy: Ok(Default::default()),
                ontological_crosswalk_intent: Ok(Default::default()),
                ontological_normalization_intent: Ok(Default::default()),
                ontological_reification_receipt: Ok(Default::default()),
                ontological_surface_projection_manifest: Ok(Default::default()),
                ontology_discovery_intent: Ok(Default::default()),
                optical_mapping_contract: Ok(Default::default()),
                optical_parsing_sla: Ok(Default::default()),
                optimization_direction_profile: Ok(Default::default()),
                oracle_execution_receipt: Ok(Default::default()),
                output_mapping_contract: Ok(Default::default()),
                override_intent: Ok(Default::default()),
                patch_operation_profile: Ok(Default::default()),
                peft_adapter_contract: Ok(Default::default()),
                permission_boundary_policy: Ok(Default::default()),
                persistence_commit_receipt: Ok(Default::default()),
                post_coordinated_semantic_state: Ok(Default::default()),
                post_quantum_signature_receipt: Ok(Default::default()),
                prediction_market_policy: Ok(Default::default()),
                prediction_market_state: Ok(Default::default()),
                presentation_manifest: Ok(Default::default()),
                procedural_metadata_manifest: Ok(Default::default()),
                process_reward_contract: Ok(Default::default()),
                profile_cid_state: Ok(Default::default()),
                qo_s_classification_profile: Ok(Default::default()),
                quarantine_intent: Ok(Default::default()),
                quorum_policy: Ok(Default::default()),
                rdf_export_receipt: Ok(Default::default()),
                rdf_serialization_intent: Ok(Default::default()),
                reasoning_engineering_policy: Ok(Default::default()),
                rhetorical_structure_profile: Ok(Default::default()),
                risk_level_policy: Ok(Default::default()),
                rollback_intent: Ok(Default::default()),
                routing_frontier_policy: Ok(Default::default()),
                sae_feature_activation_state: Ok(Default::default()),
                sae_latent_policy: Ok(Default::default()),
                salience_profile: Ok(Default::default()),
                scale_policy: Ok(Default::default()),
                schema_driven_extraction_sla: Ok(Default::default()),
                se3_transform_profile: Ok(Default::default()),
                secure_sub_session_state: Ok(Default::default()),
                self_correction_policy: Ok(Default::default()),
                semantic_discovery_intent: Ok(Default::default()),
                semantic_edge_state: Ok(Default::default()),
                semantic_firewall_policy: Ok(Default::default()),
                semantic_flow_policy: Ok(Default::default()),
                semantic_intent: Ok(Default::default()),
                semantic_mapping_heuristic_intent: Ok(Default::default()),
                semantic_node_state: Ok(Default::default()),
                semantic_relational_vector_state: Ok(Default::default()),
                semantic_slicing_policy: Ok(Default::default()),
                semantic_version_state: Ok(Default::default()),
                semantic_zoom_profile: Ok(Default::default()),
                shacl_validation_sla: Ok(Default::default()),
                shapley_attribution_receipt: Ok(Default::default()),
                side_effect_profile: Ok(Default::default()),
                simulation_convergence_sla: Ok(Default::default()),
                simulation_escrow_contract: Ok(Default::default()),
                smpc_topology_manifest: Ok(Default::default()),
                sparql_query_intent: Ok(Default::default()),
                sparql_query_result_receipt: Ok(Default::default()),
                spatial_billboard_contract: Ok(Default::default()),
                spatial_hardware_profile: Ok(Default::default()),
                spatial_kinematic_action_intent: Ok(Default::default()),
                spatial_reference_frame_manifest: Ok(Default::default()),
                spatial_render_material: Ok(Default::default()),
                spatial_tool_manifest: Ok(Default::default()),
                speculative_execution_policy: Ok(Default::default()),
                sse_transport_profile: Ok(Default::default()),
                state_contract: Ok(Default::default()),
                state_differential_manifest: Ok(Default::default()),
                state_hydration_manifest: Ok(Default::default()),
                state_mutation_intent: Ok(Default::default()),
                state_vector_profile: Ok(Default::default()),
                stdio_transport_profile: Ok(Default::default()),
                stochastic_node_state: Ok(Default::default()),
                stochastic_topology_manifest: Ok(Default::default()),
                strategic_thought_node_intent: Ok(Default::default()),
                streaming_disfluency_contract: Ok(Default::default()),
                structural_causal_graph_profile: Ok(Default::default()),
                substrate_hydration_manifest: Ok(Default::default()),
                swarm_topology_manifest: Ok(Default::default()),
                synthetic_generation_profile: Ok(Default::default()),
                system1_reflex_policy: Ok(Default::default()),
                system2_remediation_intent: Ok(Default::default()),
                system_fault_event: Ok(Default::default()),
                tabular_cell_state: Ok(Default::default()),
                tabular_encoding_profile: Ok(Default::default()),
                tabular_matrix_profile: Ok(Default::default()),
                target_topology_profile: Ok(Default::default()),
                task_announcement_intent: Ok(Default::default()),
                task_award_receipt: Ok(Default::default()),
                taxonomic_node_state: Ok(Default::default()),
                taxonomic_restructure_intent: Ok(Default::default()),
                taxonomic_routing_policy: Ok(Default::default()),
                telemetry_backpressure_contract: Ok(Default::default()),
                telemetry_context_profile: Ok(Default::default()),
                telemetry_scalar_state: Ok(Default::default()),
                teleological_isometry_receipt: Ok(Default::default()),
                temporal_bounds_profile: Ok(Default::default()),
                temporal_checkpoint_state: Ok(Default::default()),
                temporal_conflict_resolution_policy: Ok(Default::default()),
                temporal_edge_invalidation_intent: Ok(Default::default()),
                temporal_graph_crdt_manifest: Ok(Default::default()),
                tensor_structural_format_profile: Ok(Default::default()),
                terminal_buffer_state: Ok(Default::default()),
                terminal_cognitive_event: Ok(Default::default()),
                terminal_condition_contract: Ok(Default::default()),
                theory_of_mind_snapshot: Ok(Default::default()),
                thought_branch_state: Ok(Default::default()),
                tie_breaker_policy: Ok(Default::default()),
                token_burn_receipt: Ok(Default::default()),
                tool_invocation_event: Ok(Default::default()),
                topological_fidelity_receipt: Ok(Default::default()),
                topological_projection_intent: Ok(Default::default()),
                topological_retrieval_contract: Ok(Default::default()),
                topology_hash_receipt: Ok(Default::default()),
                trace_context_state: Ok(Default::default()),
                transformation_mechanism_profile: Ok(Default::default()),
                transition_edge_profile: Ok(Default::default()),
                truth_maintenance_policy: Ok(Default::default()),
                upper_ontology_class_profile: Ok(Default::default()),
                utility_justification_graph_receipt: Ok(Default::default()),
                vector_embedding_state: Ok(Default::default()),
                verifiable_credential_presentation_receipt: Ok(Default::default()),
                verifiable_entropy_receipt: Ok(Default::default()),
                viewport_projection_contract: Ok(Default::default()),
                visual_encoding_profile: Ok(Default::default()),
                volumetric_bounding_profile: Ok(Default::default()),
                volumetric_edge_profile: Ok(Default::default()),
                volumetric_partition_state: Ok(Default::default()),
                wetware_attestation_contract: Ok(Default::default()),
                workflow_manifest: Ok(Default::default()),
                zero_knowledge_receipt: Ok(Default::default()),
            }
        }
    }
    impl CoReasonSharedKernelOntology {
        pub fn activation_steering_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ActivationSteeringContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.activation_steering_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for activation_steering_contract: {e}")
            });
            self
        }
        pub fn active_inference_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ActiveInferenceContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.active_inference_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for active_inference_contract: {e}")
            });
            self
        }
        pub fn adjudication_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AdjudicationIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.adjudication_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for adjudication_intent: {e}")
            });
            self
        }
        pub fn adjudication_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AdjudicationReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.adjudication_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for adjudication_receipt: {e}")
            });
            self
        }
        pub fn adjudication_rubric_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AdjudicationRubricProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.adjudication_rubric_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for adjudication_rubric_profile: {e}")
            });
            self
        }
        pub fn adversarial_market_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::AdversarialMarketTopologyManifest>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.adversarial_market_topology_manifest = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for adversarial_market_topology_manifest: {e}"
                )
            });
            self
        }
        pub fn agent_attestation_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AgentAttestationReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.agent_attestation_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for agent_attestation_receipt: {e}")
            });
            self
        }
        pub fn agent_bid_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AgentBidIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.agent_bid_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for agent_bid_intent: {e}"));
            self
        }
        pub fn algebraic_refinement_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AlgebraicRefinementContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.algebraic_refinement_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for algebraic_refinement_contract: {e}")
            });
            self
        }
        pub fn ambient_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AmbientState>>,
            T::Error: ::std::fmt::Display,
        {
            self.ambient_state = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for ambient_state: {e}"));
            self
        }
        pub fn analogical_mapping_task<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnalogicalMappingTask>>,
            T::Error: ::std::fmt::Display,
        {
            self.analogical_mapping_task = value.try_into().map_err(|e| {
                format!("error converting supplied value for analogical_mapping_task: {e}")
            });
            self
        }
        pub fn anchoring_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnchoringPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.anchoring_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for anchoring_policy: {e}"));
            self
        }
        pub fn any_action_space_capability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnyActionSpaceCapability>>,
            T::Error: ::std::fmt::Display,
        {
            self.any_action_space_capability = value.try_into().map_err(|e| {
                format!("error converting supplied value for any_action_space_capability: {e}")
            });
            self
        }
        pub fn any_exploration_branch<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnyExplorationBranch>>,
            T::Error: ::std::fmt::Display,
        {
            self.any_exploration_branch = value.try_into().map_err(|e| {
                format!("error converting supplied value for any_exploration_branch: {e}")
            });
            self
        }
        pub fn any_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnyIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.any_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for any_intent: {e}"));
            self
        }
        pub fn any_node_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnyNodeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.any_node_profile = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for any_node_profile: {e}"));
            self
        }
        pub fn any_panel_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnyPanelProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.any_panel_profile = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for any_panel_profile: {e}"));
            self
        }
        pub fn any_presentation_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnyPresentationIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.any_presentation_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for any_presentation_intent: {e}")
            });
            self
        }
        pub fn any_state_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnyStateEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.any_state_event = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for any_state_event: {e}"));
            self
        }
        pub fn any_toolchain_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnyToolchainState>>,
            T::Error: ::std::fmt::Display,
        {
            self.any_toolchain_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for any_toolchain_state: {e}")
            });
            self
        }
        pub fn any_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnyTopologyManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.any_topology_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for any_topology_manifest: {e}")
            });
            self
        }
        pub fn any_transition_edge<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnyTransitionEdge>>,
            T::Error: ::std::fmt::Display,
        {
            self.any_transition_edge = value.try_into().map_err(|e| {
                format!("error converting supplied value for any_transition_edge: {e}")
            });
            self
        }
        pub fn artifact_corruption_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ArtifactCorruptionEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.artifact_corruption_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for artifact_corruption_event: {e}")
            });
            self
        }
        pub fn ast_gradient_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AstGradientReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.ast_gradient_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for ast_gradient_receipt: {e}")
            });
            self
        }
        pub fn asymptotic_complexity_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AsymptoticComplexityReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.asymptotic_complexity_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for asymptotic_complexity_receipt: {e}")
            });
            self
        }
        pub fn atomic_proposition_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AtomicPropositionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.atomic_proposition_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for atomic_proposition_state: {e}")
            });
            self
        }
        pub fn attack_vector_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AttackVectorProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.attack_vector_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for attack_vector_profile: {e}")
            });
            self
        }
        pub fn auction_mechanism_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AuctionMechanismProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.auction_mechanism_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for auction_mechanism_profile: {e}")
            });
            self
        }
        pub fn auction_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AuctionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.auction_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for auction_policy: {e}"));
            self
        }
        pub fn auction_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AuctionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.auction_state = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for auction_state: {e}"));
            self
        }
        pub fn backpressure_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::BackpressurePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.backpressure_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for backpressure_policy: {e}")
            });
            self
        }
        pub fn barge_in_interrupt_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::BargeInInterruptEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.barge_in_interrupt_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for barge_in_interrupt_event: {e}")
            });
            self
        }
        pub fn belief_modulation_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::BeliefModulationReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.belief_modulation_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for belief_modulation_receipt: {e}")
            });
            self
        }
        pub fn belief_mutation_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::BeliefMutationEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.belief_mutation_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for belief_mutation_event: {e}")
            });
            self
        }
        pub fn bounded_intervention_scope_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::BoundedInterventionScopePolicy>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.bounded_intervention_scope_policy = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for bounded_intervention_scope_policy: {e}"
                )
            });
            self
        }
        pub fn bounded_jsonrpc_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::BoundedJsonrpcIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.bounded_jsonrpc_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for bounded_jsonrpc_intent: {e}")
            });
            self
        }
        pub fn browser_dom_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::BrowserDomState>>,
            T::Error: ::std::fmt::Display,
        {
            self.browser_dom_state = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for browser_dom_state: {e}"));
            self
        }
        pub fn budget_exhaustion_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::BudgetExhaustionEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.budget_exhaustion_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for budget_exhaustion_event: {e}")
            });
            self
        }
        pub fn bundle_content_hash_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::BundleContentHashState>>,
            T::Error: ::std::fmt::Display,
        {
            self.bundle_content_hash_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for bundle_content_hash_state: {e}")
            });
            self
        }
        pub fn bypass_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::BypassReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.bypass_receipt = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for bypass_receipt: {e}"));
            self
        }
        pub fn capability_forge_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::CapabilityForgeTopologyManifest>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.capability_forge_topology_manifest = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for capability_forge_topology_manifest: {e}"
                )
            });
            self
        }
        pub fn capability_pointer_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CapabilityPointerState>>,
            T::Error: ::std::fmt::Display,
        {
            self.capability_pointer_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for capability_pointer_state: {e}")
            });
            self
        }
        pub fn causal_attribution_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CausalAttributionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_attribution_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for causal_attribution_state: {e}")
            });
            self
        }
        pub fn causal_directed_edge_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CausalDirectedEdgeState>>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_directed_edge_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for causal_directed_edge_state: {e}")
            });
            self
        }
        pub fn causal_explanation_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CausalExplanationEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_explanation_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for causal_explanation_event: {e}")
            });
            self
        }
        pub fn causal_interval_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CausalIntervalProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_interval_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for causal_interval_profile: {e}")
            });
            self
        }
        pub fn causal_propagation_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CausalPropagationIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_propagation_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for causal_propagation_intent: {e}")
            });
            self
        }
        pub fn circuit_breaker_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CircuitBreakerEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.circuit_breaker_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for circuit_breaker_event: {e}")
            });
            self
        }
        pub fn cognitive_action_space_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveActionSpaceManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_action_space_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for cognitive_action_space_manifest: {e}")
            });
            self
        }
        pub fn cognitive_agent_node_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveAgentNodeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_agent_node_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for cognitive_agent_node_profile: {e}")
            });
            self
        }
        pub fn cognitive_critique_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveCritiqueProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_critique_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for cognitive_critique_profile: {e}")
            });
            self
        }
        pub fn cognitive_detailed_balance_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::CognitiveDetailedBalanceContract>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_detailed_balance_contract = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for cognitive_detailed_balance_contract: {e}"
                )
            });
            self
        }
        pub fn cognitive_dual_verification_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::CognitiveDualVerificationReceipt>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_dual_verification_receipt = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for cognitive_dual_verification_receipt: {e}"
                )
            });
            self
        }
        pub fn cognitive_human_node_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveHumanNodeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_human_node_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for cognitive_human_node_profile: {e}")
            });
            self
        }
        pub fn cognitive_prediction_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitivePredictionReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_prediction_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for cognitive_prediction_receipt: {e}")
            });
            self
        }
        pub fn cognitive_reasoning_trace_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveReasoningTraceState>>,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_reasoning_trace_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for cognitive_reasoning_trace_state: {e}")
            });
            self
        }
        pub fn cognitive_routing_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveRoutingContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_routing_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for cognitive_routing_contract: {e}")
            });
            self
        }
        pub fn cognitive_sampling_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveSamplingPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_sampling_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for cognitive_sampling_policy: {e}")
            });
            self
        }
        pub fn cognitive_state_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveStateProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_state_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for cognitive_state_profile: {e}")
            });
            self
        }
        pub fn cognitive_swarm_deployment_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::CognitiveSwarmDeploymentManifest>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_swarm_deployment_manifest = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for cognitive_swarm_deployment_manifest: {e}"
                )
            });
            self
        }
        pub fn cognitive_system_node_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveSystemNodeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_system_node_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for cognitive_system_node_profile: {e}")
            });
            self
        }
        pub fn cognitive_tier_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveTierProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_tier_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for cognitive_tier_profile: {e}")
            });
            self
        }
        pub fn cognitive_uncertainty_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveUncertaintyProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_uncertainty_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for cognitive_uncertainty_profile: {e}")
            });
            self
        }
        pub fn collective_intelligence_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CollectiveIntelligenceProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.collective_intelligence_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for collective_intelligence_profile: {e}")
            });
            self
        }
        pub fn composite_node_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CompositeNodeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.composite_node_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for composite_node_profile: {e}")
            });
            self
        }
        pub fn compute_engine_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ComputeEngineProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.compute_engine_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for compute_engine_profile: {e}")
            });
            self
        }
        pub fn compute_provisioning_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ComputeProvisioningIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.compute_provisioning_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for compute_provisioning_intent: {e}")
            });
            self
        }
        pub fn compute_rate_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ComputeRateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.compute_rate_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for compute_rate_contract: {e}")
            });
            self
        }
        pub fn consensus_federation_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::ConsensusFederationTopologyManifest>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self . consensus_federation_topology_manifest = value . try_into () . map_err (| e | format ! ("error converting supplied value for consensus_federation_topology_manifest: {e}")) ;
            self
        }
        pub fn consensus_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ConsensusPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.consensus_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for consensus_policy: {e}"));
            self
        }
        pub fn constitutional_amendment_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ConstitutionalAmendmentIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.constitutional_amendment_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for constitutional_amendment_intent: {e}")
            });
            self
        }
        pub fn constrained_decoding_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ConstrainedDecodingPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.constrained_decoding_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for constrained_decoding_policy: {e}")
            });
            self
        }
        pub fn context_expansion_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ContextExpansionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.context_expansion_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for context_expansion_policy: {e}")
            });
            self
        }
        pub fn contextual_semantic_resolution_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::ContextualSemanticResolutionIntent>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self . contextual_semantic_resolution_intent = value . try_into () . map_err (| e | format ! ("error converting supplied value for contextual_semantic_resolution_intent: {e}")) ;
            self
        }
        pub fn contextualized_source_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ContextualizedSourceState>>,
            T::Error: ::std::fmt::Display,
        {
            self.contextualized_source_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for contextualized_source_state: {e}")
            });
            self
        }
        pub fn continuous_manifold_mapping_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::ContinuousManifoldMappingContract>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.continuous_manifold_mapping_contract = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for continuous_manifold_mapping_contract: {e}"
                )
            });
            self
        }
        pub fn continuous_mutation_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ContinuousMutationPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.continuous_mutation_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for continuous_mutation_policy: {e}")
            });
            self
        }
        pub fn continuous_observation_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ContinuousObservationState>>,
            T::Error: ::std::fmt::Display,
        {
            self.continuous_observation_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for continuous_observation_state: {e}")
            });
            self
        }
        pub fn continuous_spatial_mutation_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::ContinuousSpatialMutationIntent>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.continuous_spatial_mutation_intent = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for continuous_spatial_mutation_intent: {e}"
                )
            });
            self
        }
        pub fn council_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CouncilTopologyManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.council_topology_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for council_topology_manifest: {e}")
            });
            self
        }
        pub fn counterfactual_regret_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CounterfactualRegretEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.counterfactual_regret_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for counterfactual_regret_event: {e}")
            });
            self
        }
        pub fn crossover_mechanism_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CrossoverMechanismProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.crossover_mechanism_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for crossover_mechanism_profile: {e}")
            });
            self
        }
        pub fn crossover_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CrossoverPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.crossover_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for crossover_policy: {e}"));
            self
        }
        pub fn crosswalk_resolution_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CrosswalkResolutionReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.crosswalk_resolution_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for crosswalk_resolution_receipt: {e}")
            });
            self
        }
        pub fn cryptographic_provenance_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CryptographicProvenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.cryptographic_provenance_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for cryptographic_provenance_policy: {e}")
            });
            self
        }
        pub fn crystallization_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CrystallizationPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.crystallization_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for crystallization_policy: {e}")
            });
            self
        }
        pub fn custody_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CustodyReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.custody_receipt = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for custody_receipt: {e}"));
            self
        }
        pub fn cyclic_edge_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CyclicEdgeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.cyclic_edge_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for cyclic_edge_profile: {e}")
            });
            self
        }
        pub fn dag_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DagTopologyManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.dag_topology_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for dag_topology_manifest: {e}")
            });
            self
        }
        pub fn defeasible_attack_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DefeasibleAttackEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.defeasible_attack_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for defeasible_attack_event: {e}")
            });
            self
        }
        pub fn defeasible_cascade_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DefeasibleCascadeEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.defeasible_cascade_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for defeasible_cascade_event: {e}")
            });
            self
        }
        pub fn delegated_capability_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DelegatedCapabilityManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.delegated_capability_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for delegated_capability_manifest: {e}")
            });
            self
        }
        pub fn deliberative_envelope<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DeliberativeEnvelope>>,
            T::Error: ::std::fmt::Display,
        {
            self.deliberative_envelope = value.try_into().map_err(|e| {
                format!("error converting supplied value for deliberative_envelope: {e}")
            });
            self
        }
        pub fn dempster_shafer_belief_vector<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DempsterShaferBeliefVector>>,
            T::Error: ::std::fmt::Display,
        {
            self.dempster_shafer_belief_vector = value.try_into().map_err(|e| {
                format!("error converting supplied value for dempster_shafer_belief_vector: {e}")
            });
            self
        }
        pub fn derivation_mode_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DerivationModeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.derivation_mode_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for derivation_mode_profile: {e}")
            });
            self
        }
        pub fn differentiable_logic_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DifferentiableLogicPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.differentiable_logic_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for differentiable_logic_policy: {e}")
            });
            self
        }
        pub fn digital_twin_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DigitalTwinTopologyManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.digital_twin_topology_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for digital_twin_topology_manifest: {e}")
            });
            self
        }
        pub fn discourse_node_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DiscourseNodeState>>,
            T::Error: ::std::fmt::Display,
        {
            self.discourse_node_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for discourse_node_state: {e}")
            });
            self
        }
        pub fn discourse_tree_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DiscourseTreeManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.discourse_tree_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for discourse_tree_manifest: {e}")
            });
            self
        }
        pub fn distribution_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DistributionProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.distribution_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for distribution_profile: {e}")
            });
            self
        }
        pub fn distribution_shape_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DistributionShapeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.distribution_shape_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for distribution_shape_profile: {e}")
            });
            self
        }
        pub fn diversity_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DiversityPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.diversity_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for diversity_policy: {e}"));
            self
        }
        pub fn document_knowledge_graph_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::DocumentKnowledgeGraphManifest>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.document_knowledge_graph_manifest = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for document_knowledge_graph_manifest: {e}"
                )
            });
            self
        }
        pub fn document_layout_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DocumentLayoutManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.document_layout_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for document_layout_manifest: {e}")
            });
            self
        }
        pub fn document_layout_region_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DocumentLayoutRegionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.document_layout_region_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for document_layout_region_state: {e}")
            });
            self
        }
        pub fn drafting_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DraftingIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.drafting_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for drafting_intent: {e}"));
            self
        }
        pub fn dynamic_convergence_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DynamicConvergenceSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.dynamic_convergence_sla = value.try_into().map_err(|e| {
                format!("error converting supplied value for dynamic_convergence_sla: {e}")
            });
            self
        }
        pub fn dynamic_layout_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DynamicLayoutManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.dynamic_layout_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for dynamic_layout_manifest: {e}")
            });
            self
        }
        pub fn dynamic_manifold_projection_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::DynamicManifoldProjectionManifest>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.dynamic_manifold_projection_manifest = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for dynamic_manifold_projection_manifest: {e}"
                )
            });
            self
        }
        pub fn dynamic_routing_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DynamicRoutingManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.dynamic_routing_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for dynamic_routing_manifest: {e}")
            });
            self
        }
        pub fn edge_mapping_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EdgeMappingContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.edge_mapping_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for edge_mapping_contract: {e}")
            });
            self
        }
        pub fn embodied_sensory_vector_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EmbodiedSensoryVectorProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.embodied_sensory_vector_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for embodied_sensory_vector_profile: {e}")
            });
            self
        }
        pub fn empirical_falsification_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::EmpiricalFalsificationContract>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.empirical_falsification_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for empirical_falsification_contract: {e}")
            });
            self
        }
        pub fn empirical_statistical_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EmpiricalStatisticalProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.empirical_statistical_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for empirical_statistical_profile: {e}")
            });
            self
        }
        pub fn ensemble_topology_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EnsembleTopologyProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.ensemble_topology_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for ensemble_topology_profile: {e}")
            });
            self
        }
        pub fn ephemeral_namespace_partition_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::EphemeralNamespacePartitionState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.ephemeral_namespace_partition_state = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for ephemeral_namespace_partition_state: {e}"
                )
            });
            self
        }
        pub fn epistemic_argument_claim_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicArgumentClaimState>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_argument_claim_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_argument_claim_state: {e}")
            });
            self
        }
        pub fn epistemic_argument_graph_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicArgumentGraphState>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_argument_graph_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_argument_graph_state: {e}")
            });
            self
        }
        pub fn epistemic_attention_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicAttentionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_attention_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_attention_state: {e}")
            });
            self
        }
        pub fn epistemic_axiom_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicAxiomState>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_axiom_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_axiom_state: {e}")
            });
            self
        }
        pub fn epistemic_axiom_verification_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::EpistemicAxiomVerificationReceipt>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_axiom_verification_receipt = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for epistemic_axiom_verification_receipt: {e}"
                )
            });
            self
        }
        pub fn epistemic_chain_graph_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicChainGraphState>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_chain_graph_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_chain_graph_state: {e}")
            });
            self
        }
        pub fn epistemic_compression_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicCompressionSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_compression_sla = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_compression_sla: {e}")
            });
            self
        }
        pub fn epistemic_constraint_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicConstraintPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_constraint_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_constraint_policy: {e}")
            });
            self
        }
        pub fn epistemic_curriculum_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicCurriculumManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_curriculum_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_curriculum_manifest: {e}")
            });
            self
        }
        pub fn epistemic_domain_graph_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicDomainGraphManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_domain_graph_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_domain_graph_manifest: {e}")
            });
            self
        }
        pub fn epistemic_escalation_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicEscalationContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_escalation_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_escalation_contract: {e}")
            });
            self
        }
        pub fn epistemic_flow_state_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicFlowStateReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_flow_state_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_flow_state_receipt: {e}")
            });
            self
        }
        pub fn epistemic_grounded_task_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicGroundedTaskManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_grounded_task_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_grounded_task_manifest: {e}")
            });
            self
        }
        pub fn epistemic_guardrails_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicGuardrailsManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_guardrails_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_guardrails_manifest: {e}")
            });
            self
        }
        pub fn epistemic_hydration_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicHydrationPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_hydration_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_hydration_policy: {e}")
            });
            self
        }
        pub fn epistemic_ledger_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicLedgerState>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_ledger_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_ledger_state: {e}")
            });
            self
        }
        pub fn epistemic_log_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicLogEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_log_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_log_event: {e}")
            });
            self
        }
        pub fn epistemic_promotion_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicPromotionEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_promotion_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_promotion_event: {e}")
            });
            self
        }
        pub fn epistemic_provenance_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicProvenanceReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_provenance_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_provenance_receipt: {e}")
            });
            self
        }
        pub fn epistemic_proxy_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicProxyState>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_proxy_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_proxy_state: {e}")
            });
            self
        }
        pub fn epistemic_proxy_state_any<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicProxyStateAny>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_proxy_state_any = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_proxy_state_any: {e}")
            });
            self
        }
        pub fn epistemic_quarantine_snapshot<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicQuarantineSnapshot>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_quarantine_snapshot = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_quarantine_snapshot: {e}")
            });
            self
        }
        pub fn epistemic_rejection_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicRejectionReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_rejection_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_rejection_receipt: {e}")
            });
            self
        }
        pub fn epistemic_rigidity_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicRigidityPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_rigidity_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_rigidity_policy: {e}")
            });
            self
        }
        pub fn epistemic_scanning_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicScanningPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_scanning_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_scanning_policy: {e}")
            });
            self
        }
        pub fn epistemic_security_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicSecurityPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_security_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_security_policy: {e}")
            });
            self
        }
        pub fn epistemic_security_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicSecurityProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_security_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_security_profile: {e}")
            });
            self
        }
        pub fn epistemic_seed_injection_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicSeedInjectionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_seed_injection_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_seed_injection_policy: {e}")
            });
            self
        }
        pub fn epistemic_sop_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicSopManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_sop_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_sop_manifest: {e}")
            });
            self
        }
        pub fn epistemic_starvation_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicStarvationEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_starvation_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_starvation_event: {e}")
            });
            self
        }
        pub fn epistemic_telemetry_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicTelemetryEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_telemetry_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_telemetry_event: {e}")
            });
            self
        }
        pub fn epistemic_topological_proof_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::EpistemicTopologicalProofManifest>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_topological_proof_manifest = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for epistemic_topological_proof_manifest: {e}"
                )
            });
            self
        }
        pub fn epistemic_transmutation_task<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicTransmutationTask>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_transmutation_task = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_transmutation_task: {e}")
            });
            self
        }
        pub fn epistemic_upsampling_task<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicUpsamplingTask>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_upsampling_task = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_upsampling_task: {e}")
            });
            self
        }
        pub fn epistemic_zero_trust_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicZeroTrustContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_zero_trust_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_zero_trust_contract: {e}")
            });
            self
        }
        pub fn epistemic_zero_trust_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicZeroTrustReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_zero_trust_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_zero_trust_receipt: {e}")
            });
            self
        }
        pub fn escalation_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EscalationContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.escalation_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for escalation_contract: {e}")
            });
            self
        }
        pub fn escalation_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EscalationIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.escalation_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for escalation_intent: {e}"));
            self
        }
        pub fn escrow_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EscrowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.escrow_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for escrow_policy: {e}"));
            self
        }
        pub fn evaluator_optimizer_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::EvaluatorOptimizerTopologyManifest>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self . evaluator_optimizer_topology_manifest = value . try_into () . map_err (| e | format ! ("error converting supplied value for evaluator_optimizer_topology_manifest: {e}")) ;
            self
        }
        pub fn eviction_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EvictionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.eviction_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for eviction_policy: {e}"));
            self
        }
        pub fn evidentiary_citation_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EvidentiaryCitationState>>,
            T::Error: ::std::fmt::Display,
        {
            self.evidentiary_citation_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for evidentiary_citation_state: {e}")
            });
            self
        }
        pub fn evidentiary_grounding_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EvidentiaryGroundingSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.evidentiary_grounding_sla = value.try_into().map_err(|e| {
                format!("error converting supplied value for evidentiary_grounding_sla: {e}")
            });
            self
        }
        pub fn evidentiary_warrant_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EvidentiaryWarrantState>>,
            T::Error: ::std::fmt::Display,
        {
            self.evidentiary_warrant_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for evidentiary_warrant_state: {e}")
            });
            self
        }
        pub fn evolutionary_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EvolutionaryTopologyManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.evolutionary_topology_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for evolutionary_topology_manifest: {e}")
            });
            self
        }
        pub fn execution_envelope_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ExecutionEnvelopeState>>,
            T::Error: ::std::fmt::Display,
        {
            self.execution_envelope_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for execution_envelope_state: {e}")
            });
            self
        }
        pub fn execution_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ExecutionSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.execution_sla = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for execution_sla: {e}"));
            self
        }
        pub fn execution_substrate_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ExecutionSubstrateProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.execution_substrate_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for execution_substrate_profile: {e}")
            });
            self
        }
        pub fn exogenous_epistemic_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ExogenousEpistemicEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.exogenous_epistemic_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for exogenous_epistemic_event: {e}")
            });
            self
        }
        pub fn facet_matrix_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::FacetMatrixProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.facet_matrix_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for facet_matrix_profile: {e}")
            });
            self
        }
        pub fn fallback_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::FallbackIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.fallback_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for fallback_intent: {e}"));
            self
        }
        pub fn fallback_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::FallbackSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.fallback_sla = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for fallback_sla: {e}"));
            self
        }
        pub fn falsification_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::FalsificationContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.falsification_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for falsification_contract: {e}")
            });
            self
        }
        pub fn fitness_objective_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::FitnessObjectiveProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.fitness_objective_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for fitness_objective_profile: {e}")
            });
            self
        }
        pub fn formal_logic_premise<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::FormalLogicPremise>>,
            T::Error: ::std::fmt::Display,
        {
            self.formal_logic_premise = value.try_into().map_err(|e| {
                format!("error converting supplied value for formal_logic_premise: {e}")
            });
            self
        }
        pub fn formal_verification_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::FormalVerificationContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.formal_verification_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for formal_verification_contract: {e}")
            });
            self
        }
        pub fn formal_verification_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::FormalVerificationReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.formal_verification_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for formal_verification_receipt: {e}")
            });
            self
        }
        pub fn fyi_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::FyiIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.fyi_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for fyi_intent: {e}"));
            self
        }
        pub fn generative_manifold_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::GenerativeManifoldSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.generative_manifold_sla = value.try_into().map_err(|e| {
                format!("error converting supplied value for generative_manifold_sla: {e}")
            });
            self
        }
        pub fn generative_taxonomy_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::GenerativeTaxonomyManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.generative_taxonomy_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for generative_taxonomy_manifest: {e}")
            });
            self
        }
        pub fn global_governance_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::GlobalGovernancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.global_governance_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for global_governance_policy: {e}")
            });
            self
        }
        pub fn global_semantic_invariant_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::GlobalSemanticInvariantProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.global_semantic_invariant_profile = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for global_semantic_invariant_profile: {e}"
                )
            });
            self
        }
        pub fn global_semantic_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::GlobalSemanticProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.global_semantic_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for global_semantic_profile: {e}")
            });
            self
        }
        pub fn grading_criterion_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::GradingCriterionProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.grading_criterion_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for grading_criterion_profile: {e}")
            });
            self
        }
        pub fn grammar_panel_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::GrammarPanelProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.grammar_panel_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for grammar_panel_profile: {e}")
            });
            self
        }
        pub fn graph_flattening_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::GraphFlatteningPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.graph_flattening_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for graph_flattening_policy: {e}")
            });
            self
        }
        pub fn guardrail_violation_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::GuardrailViolationEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.guardrail_violation_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for guardrail_violation_event: {e}")
            });
            self
        }
        pub fn hardware_enclave_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HardwareEnclaveReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.hardware_enclave_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for hardware_enclave_receipt: {e}")
            });
            self
        }
        pub fn hierarchical_dom_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HierarchicalDomManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.hierarchical_dom_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for hierarchical_dom_manifest: {e}")
            });
            self
        }
        pub fn hoare_logic_proof_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HoareLogicProofReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.hoare_logic_proof_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for hoare_logic_proof_receipt: {e}")
            });
            self
        }
        pub fn homomorphic_encryption_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HomomorphicEncryptionProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.homomorphic_encryption_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for homomorphic_encryption_profile: {e}")
            });
            self
        }
        pub fn http_transport_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HttpTransportProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.http_transport_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for http_transport_profile: {e}")
            });
            self
        }
        pub fn human_directive_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HumanDirectiveIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.human_directive_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for human_directive_intent: {e}")
            });
            self
        }
        pub fn hypothesis_generation_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HypothesisGenerationEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.hypothesis_generation_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for hypothesis_generation_event: {e}")
            });
            self
        }
        pub fn hypothesis_stake_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HypothesisStakeReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.hypothesis_stake_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for hypothesis_stake_receipt: {e}")
            });
            self
        }
        pub fn hypothesis_superposition_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HypothesisSuperpositionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.hypothesis_superposition_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for hypothesis_superposition_state: {e}")
            });
            self
        }
        pub fn ideation_phase_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::IdeationPhaseProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.ideation_phase_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for ideation_phase_profile: {e}")
            });
            self
        }
        pub fn illocutionary_force_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::IllocutionaryForceProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.illocutionary_force_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for illocutionary_force_profile: {e}")
            });
            self
        }
        pub fn input_mapping_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::InputMappingContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.input_mapping_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for input_mapping_contract: {e}")
            });
            self
        }
        pub fn insight_card_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::InsightCardProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.insight_card_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for insight_card_profile: {e}")
            });
            self
        }
        pub fn intent_classification_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::IntentClassificationReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.intent_classification_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for intent_classification_receipt: {e}")
            });
            self
        }
        pub fn intent_elicitation_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::IntentElicitationTopologyManifest>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.intent_elicitation_topology_manifest = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for intent_elicitation_topology_manifest: {e}"
                )
            });
            self
        }
        pub fn intervention_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::InterventionIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.intervention_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for intervention_intent: {e}")
            });
            self
        }
        pub fn intervention_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::InterventionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.intervention_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for intervention_policy: {e}")
            });
            self
        }
        pub fn intervention_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::InterventionReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.intervention_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for intervention_receipt: {e}")
            });
            self
        }
        pub fn interventional_causal_task<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::InterventionalCausalTask>>,
            T::Error: ::std::fmt::Display,
        {
            self.interventional_causal_task = value.try_into().map_err(|e| {
                format!("error converting supplied value for interventional_causal_task: {e}")
            });
            self
        }
        pub fn json_primitive_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::JsonPrimitiveState>>,
            T::Error: ::std::fmt::Display,
        {
            self.json_primitive_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for json_primitive_state: {e}")
            });
            self
        }
        pub fn jsonrpc_error_response_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::JsonrpcErrorResponseState>>,
            T::Error: ::std::fmt::Display,
        {
            self.jsonrpc_error_response_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for jsonrpc_error_response_state: {e}")
            });
            self
        }
        pub fn jsonrpc_error_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::JsonrpcErrorState>>,
            T::Error: ::std::fmt::Display,
        {
            self.jsonrpc_error_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for jsonrpc_error_state: {e}")
            });
            self
        }
        pub fn kinematic_delta_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::KinematicDeltaManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.kinematic_delta_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for kinematic_delta_manifest: {e}")
            });
            self
        }
        pub fn kinematic_derivative_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::KinematicDerivativeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.kinematic_derivative_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for kinematic_derivative_profile: {e}")
            });
            self
        }
        pub fn kinetic_budget_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::KineticBudgetPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.kinetic_budget_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for kinetic_budget_policy: {e}")
            });
            self
        }
        pub fn kinetic_separation_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::KineticSeparationPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.kinetic_separation_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for kinetic_separation_policy: {e}")
            });
            self
        }
        pub fn latent_projection_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LatentProjectionIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.latent_projection_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for latent_projection_intent: {e}")
            });
            self
        }
        pub fn latent_schema_inference_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LatentSchemaInferenceIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.latent_schema_inference_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for latent_schema_inference_intent: {e}")
            });
            self
        }
        pub fn latent_scratchpad_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LatentScratchpadReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.latent_scratchpad_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for latent_scratchpad_receipt: {e}")
            });
            self
        }
        pub fn latent_smoothing_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LatentSmoothingProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.latent_smoothing_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for latent_smoothing_profile: {e}")
            });
            self
        }
        pub fn lifecycle_trigger_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LifecycleTriggerEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.lifecycle_trigger_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for lifecycle_trigger_event: {e}")
            });
            self
        }
        pub fn lineage_watermark_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LineageWatermarkReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.lineage_watermark_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for lineage_watermark_receipt: {e}")
            });
            self
        }
        pub fn link_ml_validation_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LinkMlValidationSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.link_ml_validation_sla = value.try_into().map_err(|e| {
                format!("error converting supplied value for link_ml_validation_sla: {e}")
            });
            self
        }
        pub fn logit_steganography_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LogitSteganographyContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.logit_steganography_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for logit_steganography_contract: {e}")
            });
            self
        }
        pub fn macro_grid_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MacroGridProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.macro_grid_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for macro_grid_profile: {e}")
            });
            self
        }
        pub fn manifest_violation_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ManifestViolationReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.manifest_violation_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for manifest_violation_receipt: {e}")
            });
            self
        }
        pub fn manifold_alignment_metric_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::ManifoldAlignmentMetricProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.manifold_alignment_metric_profile = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for manifold_alignment_metric_profile: {e}"
                )
            });
            self
        }
        pub fn market_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MarketContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.market_contract = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for market_contract: {e}"));
            self
        }
        pub fn market_resolution_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MarketResolutionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.market_resolution_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for market_resolution_state: {e}")
            });
            self
        }
        pub fn markov_blanket_rendering_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MarkovBlanketRenderingPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.markov_blanket_rendering_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for markov_blanket_rendering_policy: {e}")
            });
            self
        }
        pub fn mcp_capability_whitelist_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::McpCapabilityWhitelistPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.mcp_capability_whitelist_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for mcp_capability_whitelist_policy: {e}")
            });
            self
        }
        pub fn mcp_client_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::McpClientIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.mcp_client_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for mcp_client_intent: {e}"));
            self
        }
        pub fn mcp_prompt_reference_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::McpPromptReferenceState>>,
            T::Error: ::std::fmt::Display,
        {
            self.mcp_prompt_reference_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for mcp_prompt_reference_state: {e}")
            });
            self
        }
        pub fn mcp_resource_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::McpResourceManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.mcp_resource_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for mcp_resource_manifest: {e}")
            });
            self
        }
        pub fn mcp_server_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::McpServerManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.mcp_server_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for mcp_server_manifest: {e}")
            });
            self
        }
        pub fn mcp_tool_definition<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::McpToolDefinition>>,
            T::Error: ::std::fmt::Display,
        {
            self.mcp_tool_definition = value.try_into().map_err(|e| {
                format!("error converting supplied value for mcp_tool_definition: {e}")
            });
            self
        }
        pub fn mechanistic_audit_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MechanisticAuditContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.mechanistic_audit_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for mechanistic_audit_contract: {e}")
            });
            self
        }
        pub fn memoized_node_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MemoizedNodeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.memoized_node_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for memoized_node_profile: {e}")
            });
            self
        }
        pub fn multimodal_artifact_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MultimodalArtifactReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.multimodal_artifact_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for multimodal_artifact_receipt: {e}")
            });
            self
        }
        pub fn multimodal_token_anchor_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MultimodalTokenAnchorState>>,
            T::Error: ::std::fmt::Display,
        {
            self.multimodal_token_anchor_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for multimodal_token_anchor_state: {e}")
            });
            self
        }
        pub fn mutation_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MutationPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.mutation_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for mutation_policy: {e}"));
            self
        }
        pub fn n_dimensional_tensor_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NDimensionalTensorManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.n_dimensional_tensor_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for n_dimensional_tensor_manifest: {e}")
            });
            self
        }
        pub fn neural_audit_attestation_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NeuralAuditAttestationReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.neural_audit_attestation_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for neural_audit_attestation_receipt: {e}")
            });
            self
        }
        pub fn neuro_symbolic_handoff_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NeuroSymbolicHandoffContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.neuro_symbolic_handoff_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for neuro_symbolic_handoff_contract: {e}")
            });
            self
        }
        pub fn neurosymbolic_inference_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NeurosymbolicInferenceIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.neurosymbolic_inference_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for neurosymbolic_inference_intent: {e}")
            });
            self
        }
        pub fn neurosymbolic_ingestion_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::NeurosymbolicIngestionTopologyManifest>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self . neurosymbolic_ingestion_topology_manifest = value . try_into () . map_err (| e | format ! ("error converting supplied value for neurosymbolic_ingestion_topology_manifest: {e}")) ;
            self
        }
        pub fn neurosymbolic_verification_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::NeurosymbolicVerificationTopologyManifest>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self . neurosymbolic_verification_topology_manifest = value . try_into () . map_err (| e | format ! ("error converting supplied value for neurosymbolic_verification_topology_manifest: {e}")) ;
            self
        }
        pub fn node_cid_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.node_cid_state = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for node_cid_state: {e}"));
            self
        }
        pub fn observability_lod_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ObservabilityLodPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.observability_lod_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for observability_lod_policy: {e}")
            });
            self
        }
        pub fn observation_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ObservationEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.observation_event = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for observation_event: {e}"));
            self
        }
        pub fn ontological_alignment_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::OntologicalAlignmentPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.ontological_alignment_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for ontological_alignment_policy: {e}")
            });
            self
        }
        pub fn ontological_crosswalk_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::OntologicalCrosswalkIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.ontological_crosswalk_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for ontological_crosswalk_intent: {e}")
            });
            self
        }
        pub fn ontological_normalization_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::OntologicalNormalizationIntent>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.ontological_normalization_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for ontological_normalization_intent: {e}")
            });
            self
        }
        pub fn ontological_reification_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::OntologicalReificationReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.ontological_reification_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for ontological_reification_receipt: {e}")
            });
            self
        }
        pub fn ontological_surface_projection_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::OntologicalSurfaceProjectionManifest>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self . ontological_surface_projection_manifest = value . try_into () . map_err (| e | format ! ("error converting supplied value for ontological_surface_projection_manifest: {e}")) ;
            self
        }
        pub fn ontology_discovery_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::OntologyDiscoveryIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.ontology_discovery_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for ontology_discovery_intent: {e}")
            });
            self
        }
        pub fn optical_mapping_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::OpticalMappingContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.optical_mapping_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for optical_mapping_contract: {e}")
            });
            self
        }
        pub fn optical_parsing_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::OpticalParsingSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.optical_parsing_sla = value.try_into().map_err(|e| {
                format!("error converting supplied value for optical_parsing_sla: {e}")
            });
            self
        }
        pub fn optimization_direction_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::OptimizationDirectionProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.optimization_direction_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for optimization_direction_profile: {e}")
            });
            self
        }
        pub fn oracle_execution_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::OracleExecutionReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.oracle_execution_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for oracle_execution_receipt: {e}")
            });
            self
        }
        pub fn output_mapping_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::OutputMappingContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.output_mapping_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for output_mapping_contract: {e}")
            });
            self
        }
        pub fn override_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::OverrideIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.override_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for override_intent: {e}"));
            self
        }
        pub fn patch_operation_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::PatchOperationProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.patch_operation_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for patch_operation_profile: {e}")
            });
            self
        }
        pub fn peft_adapter_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::PeftAdapterContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.peft_adapter_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for peft_adapter_contract: {e}")
            });
            self
        }
        pub fn permission_boundary_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::PermissionBoundaryPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.permission_boundary_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for permission_boundary_policy: {e}")
            });
            self
        }
        pub fn persistence_commit_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::PersistenceCommitReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.persistence_commit_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for persistence_commit_receipt: {e}")
            });
            self
        }
        pub fn post_coordinated_semantic_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::PostCoordinatedSemanticState>>,
            T::Error: ::std::fmt::Display,
        {
            self.post_coordinated_semantic_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for post_coordinated_semantic_state: {e}")
            });
            self
        }
        pub fn post_quantum_signature_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::PostQuantumSignatureReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.post_quantum_signature_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for post_quantum_signature_receipt: {e}")
            });
            self
        }
        pub fn prediction_market_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::PredictionMarketPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.prediction_market_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for prediction_market_policy: {e}")
            });
            self
        }
        pub fn prediction_market_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::PredictionMarketState>>,
            T::Error: ::std::fmt::Display,
        {
            self.prediction_market_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for prediction_market_state: {e}")
            });
            self
        }
        pub fn presentation_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::PresentationManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.presentation_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for presentation_manifest: {e}")
            });
            self
        }
        pub fn procedural_metadata_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ProceduralMetadataManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.procedural_metadata_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for procedural_metadata_manifest: {e}")
            });
            self
        }
        pub fn process_reward_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ProcessRewardContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.process_reward_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for process_reward_contract: {e}")
            });
            self
        }
        pub fn profile_cid_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ProfileCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.profile_cid_state = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for profile_cid_state: {e}"));
            self
        }
        pub fn qo_s_classification_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::QoSClassificationProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.qo_s_classification_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for qo_s_classification_profile: {e}")
            });
            self
        }
        pub fn quarantine_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::QuarantineIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.quarantine_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for quarantine_intent: {e}"));
            self
        }
        pub fn quorum_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::QuorumPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.quorum_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for quorum_policy: {e}"));
            self
        }
        pub fn rdf_export_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::RdfExportReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.rdf_export_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for rdf_export_receipt: {e}")
            });
            self
        }
        pub fn rdf_serialization_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::RdfSerializationIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.rdf_serialization_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for rdf_serialization_intent: {e}")
            });
            self
        }
        pub fn reasoning_engineering_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ReasoningEngineeringPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.reasoning_engineering_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for reasoning_engineering_policy: {e}")
            });
            self
        }
        pub fn rhetorical_structure_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::RhetoricalStructureProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.rhetorical_structure_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for rhetorical_structure_profile: {e}")
            });
            self
        }
        pub fn risk_level_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::RiskLevelPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.risk_level_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for risk_level_policy: {e}"));
            self
        }
        pub fn rollback_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::RollbackIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.rollback_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for rollback_intent: {e}"));
            self
        }
        pub fn routing_frontier_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::RoutingFrontierPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.routing_frontier_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for routing_frontier_policy: {e}")
            });
            self
        }
        pub fn sae_feature_activation_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SaeFeatureActivationState>>,
            T::Error: ::std::fmt::Display,
        {
            self.sae_feature_activation_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for sae_feature_activation_state: {e}")
            });
            self
        }
        pub fn sae_latent_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SaeLatentPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.sae_latent_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for sae_latent_policy: {e}"));
            self
        }
        pub fn salience_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SalienceProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.salience_profile = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for salience_profile: {e}"));
            self
        }
        pub fn scale_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ScalePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.scale_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for scale_policy: {e}"));
            self
        }
        pub fn schema_driven_extraction_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SchemaDrivenExtractionSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.schema_driven_extraction_sla = value.try_into().map_err(|e| {
                format!("error converting supplied value for schema_driven_extraction_sla: {e}")
            });
            self
        }
        pub fn se3_transform_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::Se3TransformProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.se3_transform_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for se3_transform_profile: {e}")
            });
            self
        }
        pub fn secure_sub_session_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SecureSubSessionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.secure_sub_session_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for secure_sub_session_state: {e}")
            });
            self
        }
        pub fn self_correction_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SelfCorrectionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.self_correction_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for self_correction_policy: {e}")
            });
            self
        }
        pub fn semantic_discovery_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticDiscoveryIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_discovery_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for semantic_discovery_intent: {e}")
            });
            self
        }
        pub fn semantic_edge_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticEdgeState>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_edge_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for semantic_edge_state: {e}")
            });
            self
        }
        pub fn semantic_firewall_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFirewallPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_firewall_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for semantic_firewall_policy: {e}")
            });
            self
        }
        pub fn semantic_flow_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFlowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_flow_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for semantic_flow_policy: {e}")
            });
            self
        }
        pub fn semantic_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_intent: {e}"));
            self
        }
        pub fn semantic_mapping_heuristic_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::SemanticMappingHeuristicIntent>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_mapping_heuristic_intent = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for semantic_mapping_heuristic_intent: {e}"
                )
            });
            self
        }
        pub fn semantic_node_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticNodeState>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_node_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for semantic_node_state: {e}")
            });
            self
        }
        pub fn semantic_relational_vector_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticRelationalVectorState>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_relational_vector_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for semantic_relational_vector_state: {e}")
            });
            self
        }
        pub fn semantic_slicing_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticSlicingPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_slicing_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for semantic_slicing_policy: {e}")
            });
            self
        }
        pub fn semantic_version_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticVersionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_version_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for semantic_version_state: {e}")
            });
            self
        }
        pub fn semantic_zoom_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticZoomProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_zoom_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for semantic_zoom_profile: {e}")
            });
            self
        }
        pub fn shacl_validation_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ShaclValidationSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.shacl_validation_sla = value.try_into().map_err(|e| {
                format!("error converting supplied value for shacl_validation_sla: {e}")
            });
            self
        }
        pub fn shapley_attribution_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ShapleyAttributionReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.shapley_attribution_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for shapley_attribution_receipt: {e}")
            });
            self
        }
        pub fn side_effect_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SideEffectProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.side_effect_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for side_effect_profile: {e}")
            });
            self
        }
        pub fn simulation_convergence_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SimulationConvergenceSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.simulation_convergence_sla = value.try_into().map_err(|e| {
                format!("error converting supplied value for simulation_convergence_sla: {e}")
            });
            self
        }
        pub fn simulation_escrow_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SimulationEscrowContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.simulation_escrow_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for simulation_escrow_contract: {e}")
            });
            self
        }
        pub fn smpc_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SmpcTopologyManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.smpc_topology_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for smpc_topology_manifest: {e}")
            });
            self
        }
        pub fn sparql_query_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SparqlQueryIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.sparql_query_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for sparql_query_intent: {e}")
            });
            self
        }
        pub fn sparql_query_result_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SparqlQueryResultReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.sparql_query_result_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for sparql_query_result_receipt: {e}")
            });
            self
        }
        pub fn spatial_billboard_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialBillboardContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.spatial_billboard_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for spatial_billboard_contract: {e}")
            });
            self
        }
        pub fn spatial_hardware_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialHardwareProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.spatial_hardware_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for spatial_hardware_profile: {e}")
            });
            self
        }
        pub fn spatial_kinematic_action_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialKinematicActionIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.spatial_kinematic_action_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for spatial_kinematic_action_intent: {e}")
            });
            self
        }
        pub fn spatial_reference_frame_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialReferenceFrameManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.spatial_reference_frame_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for spatial_reference_frame_manifest: {e}")
            });
            self
        }
        pub fn spatial_render_material<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialRenderMaterial>>,
            T::Error: ::std::fmt::Display,
        {
            self.spatial_render_material = value.try_into().map_err(|e| {
                format!("error converting supplied value for spatial_render_material: {e}")
            });
            self
        }
        pub fn spatial_tool_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialToolManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.spatial_tool_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for spatial_tool_manifest: {e}")
            });
            self
        }
        pub fn speculative_execution_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpeculativeExecutionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.speculative_execution_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for speculative_execution_policy: {e}")
            });
            self
        }
        pub fn sse_transport_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SseTransportProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.sse_transport_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for sse_transport_profile: {e}")
            });
            self
        }
        pub fn state_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.state_contract = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for state_contract: {e}"));
            self
        }
        pub fn state_differential_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateDifferentialManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.state_differential_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for state_differential_manifest: {e}")
            });
            self
        }
        pub fn state_hydration_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateHydrationManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.state_hydration_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for state_hydration_manifest: {e}")
            });
            self
        }
        pub fn state_mutation_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateMutationIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.state_mutation_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for state_mutation_intent: {e}")
            });
            self
        }
        pub fn state_vector_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateVectorProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.state_vector_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for state_vector_profile: {e}")
            });
            self
        }
        pub fn stdio_transport_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StdioTransportProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.stdio_transport_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for stdio_transport_profile: {e}")
            });
            self
        }
        pub fn stochastic_node_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StochasticNodeState>>,
            T::Error: ::std::fmt::Display,
        {
            self.stochastic_node_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for stochastic_node_state: {e}")
            });
            self
        }
        pub fn stochastic_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StochasticTopologyManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.stochastic_topology_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for stochastic_topology_manifest: {e}")
            });
            self
        }
        pub fn strategic_thought_node_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StrategicThoughtNodeIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.strategic_thought_node_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for strategic_thought_node_intent: {e}")
            });
            self
        }
        pub fn streaming_disfluency_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StreamingDisfluencyContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.streaming_disfluency_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for streaming_disfluency_contract: {e}")
            });
            self
        }
        pub fn structural_causal_graph_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StructuralCausalGraphProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.structural_causal_graph_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for structural_causal_graph_profile: {e}")
            });
            self
        }
        pub fn substrate_hydration_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SubstrateHydrationManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.substrate_hydration_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for substrate_hydration_manifest: {e}")
            });
            self
        }
        pub fn swarm_topology_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SwarmTopologyManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.swarm_topology_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for swarm_topology_manifest: {e}")
            });
            self
        }
        pub fn synthetic_generation_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SyntheticGenerationProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.synthetic_generation_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for synthetic_generation_profile: {e}")
            });
            self
        }
        pub fn system1_reflex_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::System1ReflexPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.system1_reflex_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for system1_reflex_policy: {e}")
            });
            self
        }
        pub fn system2_remediation_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::System2RemediationIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.system2_remediation_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for system2_remediation_intent: {e}")
            });
            self
        }
        pub fn system_fault_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SystemFaultEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.system_fault_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for system_fault_event: {e}")
            });
            self
        }
        pub fn tabular_cell_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TabularCellState>>,
            T::Error: ::std::fmt::Display,
        {
            self.tabular_cell_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for tabular_cell_state: {e}")
            });
            self
        }
        pub fn tabular_encoding_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TabularEncodingProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.tabular_encoding_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for tabular_encoding_profile: {e}")
            });
            self
        }
        pub fn tabular_matrix_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TabularMatrixProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.tabular_matrix_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for tabular_matrix_profile: {e}")
            });
            self
        }
        pub fn target_topology_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TargetTopologyProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.target_topology_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_topology_profile: {e}")
            });
            self
        }
        pub fn task_announcement_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TaskAnnouncementIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.task_announcement_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for task_announcement_intent: {e}")
            });
            self
        }
        pub fn task_award_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TaskAwardReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.task_award_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for task_award_receipt: {e}")
            });
            self
        }
        pub fn taxonomic_node_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TaxonomicNodeState>>,
            T::Error: ::std::fmt::Display,
        {
            self.taxonomic_node_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for taxonomic_node_state: {e}")
            });
            self
        }
        pub fn taxonomic_restructure_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TaxonomicRestructureIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.taxonomic_restructure_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for taxonomic_restructure_intent: {e}")
            });
            self
        }
        pub fn taxonomic_routing_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TaxonomicRoutingPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.taxonomic_routing_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for taxonomic_routing_policy: {e}")
            });
            self
        }
        pub fn telemetry_backpressure_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TelemetryBackpressureContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.telemetry_backpressure_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for telemetry_backpressure_contract: {e}")
            });
            self
        }
        pub fn telemetry_context_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TelemetryContextProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.telemetry_context_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for telemetry_context_profile: {e}")
            });
            self
        }
        pub fn telemetry_scalar_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TelemetryScalarState>>,
            T::Error: ::std::fmt::Display,
        {
            self.telemetry_scalar_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for telemetry_scalar_state: {e}")
            });
            self
        }
        pub fn teleological_isometry_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TeleologicalIsometryReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.teleological_isometry_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for teleological_isometry_receipt: {e}")
            });
            self
        }
        pub fn temporal_bounds_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TemporalBoundsProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_bounds_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_bounds_profile: {e}")
            });
            self
        }
        pub fn temporal_checkpoint_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TemporalCheckpointState>>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_checkpoint_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_checkpoint_state: {e}")
            });
            self
        }
        pub fn temporal_conflict_resolution_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::TemporalConflictResolutionPolicy>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_conflict_resolution_policy = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for temporal_conflict_resolution_policy: {e}"
                )
            });
            self
        }
        pub fn temporal_edge_invalidation_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::TemporalEdgeInvalidationIntent>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_edge_invalidation_intent = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for temporal_edge_invalidation_intent: {e}"
                )
            });
            self
        }
        pub fn temporal_graph_crdt_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TemporalGraphCrdtManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_graph_crdt_manifest = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_graph_crdt_manifest: {e}")
            });
            self
        }
        pub fn tensor_structural_format_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TensorStructuralFormatProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.tensor_structural_format_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for tensor_structural_format_profile: {e}")
            });
            self
        }
        pub fn terminal_buffer_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TerminalBufferState>>,
            T::Error: ::std::fmt::Display,
        {
            self.terminal_buffer_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for terminal_buffer_state: {e}")
            });
            self
        }
        pub fn terminal_cognitive_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TerminalCognitiveEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.terminal_cognitive_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for terminal_cognitive_event: {e}")
            });
            self
        }
        pub fn terminal_condition_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TerminalConditionContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.terminal_condition_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for terminal_condition_contract: {e}")
            });
            self
        }
        pub fn theory_of_mind_snapshot<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TheoryOfMindSnapshot>>,
            T::Error: ::std::fmt::Display,
        {
            self.theory_of_mind_snapshot = value.try_into().map_err(|e| {
                format!("error converting supplied value for theory_of_mind_snapshot: {e}")
            });
            self
        }
        pub fn thought_branch_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ThoughtBranchState>>,
            T::Error: ::std::fmt::Display,
        {
            self.thought_branch_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for thought_branch_state: {e}")
            });
            self
        }
        pub fn tie_breaker_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TieBreakerPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.tie_breaker_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for tie_breaker_policy: {e}")
            });
            self
        }
        pub fn token_burn_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TokenBurnReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.token_burn_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for token_burn_receipt: {e}")
            });
            self
        }
        pub fn tool_invocation_event<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ToolInvocationEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.tool_invocation_event = value.try_into().map_err(|e| {
                format!("error converting supplied value for tool_invocation_event: {e}")
            });
            self
        }
        pub fn topological_fidelity_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TopologicalFidelityReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.topological_fidelity_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for topological_fidelity_receipt: {e}")
            });
            self
        }
        pub fn topological_projection_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TopologicalProjectionIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.topological_projection_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for topological_projection_intent: {e}")
            });
            self
        }
        pub fn topological_retrieval_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TopologicalRetrievalContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.topological_retrieval_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for topological_retrieval_contract: {e}")
            });
            self
        }
        pub fn topology_hash_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TopologyHashReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_hash_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for topology_hash_receipt: {e}")
            });
            self
        }
        pub fn trace_context_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TraceContextState>>,
            T::Error: ::std::fmt::Display,
        {
            self.trace_context_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for trace_context_state: {e}")
            });
            self
        }
        pub fn transformation_mechanism_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::TransformationMechanismProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.transformation_mechanism_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for transformation_mechanism_profile: {e}")
            });
            self
        }
        pub fn transition_edge_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TransitionEdgeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.transition_edge_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for transition_edge_profile: {e}")
            });
            self
        }
        pub fn truth_maintenance_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TruthMaintenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.truth_maintenance_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for truth_maintenance_policy: {e}")
            });
            self
        }
        pub fn upper_ontology_class_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::UpperOntologyClassProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.upper_ontology_class_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for upper_ontology_class_profile: {e}")
            });
            self
        }
        pub fn utility_justification_graph_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::UtilityJustificationGraphReceipt>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.utility_justification_graph_receipt = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for utility_justification_graph_receipt: {e}"
                )
            });
            self
        }
        pub fn vector_embedding_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VectorEmbeddingState>>,
            T::Error: ::std::fmt::Display,
        {
            self.vector_embedding_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for vector_embedding_state: {e}")
            });
            self
        }
        pub fn verifiable_credential_presentation_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::VerifiableCredentialPresentationReceipt>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self . verifiable_credential_presentation_receipt = value . try_into () . map_err (| e | format ! ("error converting supplied value for verifiable_credential_presentation_receipt: {e}")) ;
            self
        }
        pub fn verifiable_entropy_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VerifiableEntropyReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.verifiable_entropy_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for verifiable_entropy_receipt: {e}")
            });
            self
        }
        pub fn viewport_projection_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ViewportProjectionContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.viewport_projection_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for viewport_projection_contract: {e}")
            });
            self
        }
        pub fn visual_encoding_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VisualEncodingProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.visual_encoding_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for visual_encoding_profile: {e}")
            });
            self
        }
        pub fn volumetric_bounding_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VolumetricBoundingProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.volumetric_bounding_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for volumetric_bounding_profile: {e}")
            });
            self
        }
        pub fn volumetric_edge_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VolumetricEdgeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.volumetric_edge_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for volumetric_edge_profile: {e}")
            });
            self
        }
        pub fn volumetric_partition_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VolumetricPartitionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.volumetric_partition_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for volumetric_partition_state: {e}")
            });
            self
        }
        pub fn wetware_attestation_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::WetwareAttestationContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.wetware_attestation_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for wetware_attestation_contract: {e}")
            });
            self
        }
        pub fn workflow_manifest<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::WorkflowManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.workflow_manifest = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for workflow_manifest: {e}"));
            self
        }
        pub fn zero_knowledge_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ZeroKnowledgeReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.zero_knowledge_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for zero_knowledge_receipt: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<CoReasonSharedKernelOntology> for super::CoReasonSharedKernelOntology {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CoReasonSharedKernelOntology,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                activation_steering_contract: value.activation_steering_contract?,
                active_inference_contract: value.active_inference_contract?,
                adjudication_intent: value.adjudication_intent?,
                adjudication_receipt: value.adjudication_receipt?,
                adjudication_rubric_profile: value.adjudication_rubric_profile?,
                adversarial_market_topology_manifest: value.adversarial_market_topology_manifest?,
                agent_attestation_receipt: value.agent_attestation_receipt?,
                agent_bid_intent: value.agent_bid_intent?,
                algebraic_refinement_contract: value.algebraic_refinement_contract?,
                ambient_state: value.ambient_state?,
                analogical_mapping_task: value.analogical_mapping_task?,
                anchoring_policy: value.anchoring_policy?,
                any_action_space_capability: value.any_action_space_capability?,
                any_exploration_branch: value.any_exploration_branch?,
                any_intent: value.any_intent?,
                any_node_profile: value.any_node_profile?,
                any_panel_profile: value.any_panel_profile?,
                any_presentation_intent: value.any_presentation_intent?,
                any_state_event: value.any_state_event?,
                any_toolchain_state: value.any_toolchain_state?,
                any_topology_manifest: value.any_topology_manifest?,
                any_transition_edge: value.any_transition_edge?,
                artifact_corruption_event: value.artifact_corruption_event?,
                ast_gradient_receipt: value.ast_gradient_receipt?,
                asymptotic_complexity_receipt: value.asymptotic_complexity_receipt?,
                atomic_proposition_state: value.atomic_proposition_state?,
                attack_vector_profile: value.attack_vector_profile?,
                auction_mechanism_profile: value.auction_mechanism_profile?,
                auction_policy: value.auction_policy?,
                auction_state: value.auction_state?,
                backpressure_policy: value.backpressure_policy?,
                barge_in_interrupt_event: value.barge_in_interrupt_event?,
                belief_modulation_receipt: value.belief_modulation_receipt?,
                belief_mutation_event: value.belief_mutation_event?,
                bounded_intervention_scope_policy: value.bounded_intervention_scope_policy?,
                bounded_jsonrpc_intent: value.bounded_jsonrpc_intent?,
                browser_dom_state: value.browser_dom_state?,
                budget_exhaustion_event: value.budget_exhaustion_event?,
                bundle_content_hash_state: value.bundle_content_hash_state?,
                bypass_receipt: value.bypass_receipt?,
                capability_forge_topology_manifest: value.capability_forge_topology_manifest?,
                capability_pointer_state: value.capability_pointer_state?,
                causal_attribution_state: value.causal_attribution_state?,
                causal_directed_edge_state: value.causal_directed_edge_state?,
                causal_explanation_event: value.causal_explanation_event?,
                causal_interval_profile: value.causal_interval_profile?,
                causal_propagation_intent: value.causal_propagation_intent?,
                circuit_breaker_event: value.circuit_breaker_event?,
                cognitive_action_space_manifest: value.cognitive_action_space_manifest?,
                cognitive_agent_node_profile: value.cognitive_agent_node_profile?,
                cognitive_critique_profile: value.cognitive_critique_profile?,
                cognitive_detailed_balance_contract: value.cognitive_detailed_balance_contract?,
                cognitive_dual_verification_receipt: value.cognitive_dual_verification_receipt?,
                cognitive_human_node_profile: value.cognitive_human_node_profile?,
                cognitive_prediction_receipt: value.cognitive_prediction_receipt?,
                cognitive_reasoning_trace_state: value.cognitive_reasoning_trace_state?,
                cognitive_routing_contract: value.cognitive_routing_contract?,
                cognitive_sampling_policy: value.cognitive_sampling_policy?,
                cognitive_state_profile: value.cognitive_state_profile?,
                cognitive_swarm_deployment_manifest: value.cognitive_swarm_deployment_manifest?,
                cognitive_system_node_profile: value.cognitive_system_node_profile?,
                cognitive_tier_profile: value.cognitive_tier_profile?,
                cognitive_uncertainty_profile: value.cognitive_uncertainty_profile?,
                collective_intelligence_profile: value.collective_intelligence_profile?,
                composite_node_profile: value.composite_node_profile?,
                compute_engine_profile: value.compute_engine_profile?,
                compute_provisioning_intent: value.compute_provisioning_intent?,
                compute_rate_contract: value.compute_rate_contract?,
                consensus_federation_topology_manifest: value
                    .consensus_federation_topology_manifest?,
                consensus_policy: value.consensus_policy?,
                constitutional_amendment_intent: value.constitutional_amendment_intent?,
                constrained_decoding_policy: value.constrained_decoding_policy?,
                context_expansion_policy: value.context_expansion_policy?,
                contextual_semantic_resolution_intent: value
                    .contextual_semantic_resolution_intent?,
                contextualized_source_state: value.contextualized_source_state?,
                continuous_manifold_mapping_contract: value.continuous_manifold_mapping_contract?,
                continuous_mutation_policy: value.continuous_mutation_policy?,
                continuous_observation_state: value.continuous_observation_state?,
                continuous_spatial_mutation_intent: value.continuous_spatial_mutation_intent?,
                council_topology_manifest: value.council_topology_manifest?,
                counterfactual_regret_event: value.counterfactual_regret_event?,
                crossover_mechanism_profile: value.crossover_mechanism_profile?,
                crossover_policy: value.crossover_policy?,
                crosswalk_resolution_receipt: value.crosswalk_resolution_receipt?,
                cryptographic_provenance_policy: value.cryptographic_provenance_policy?,
                crystallization_policy: value.crystallization_policy?,
                custody_receipt: value.custody_receipt?,
                cyclic_edge_profile: value.cyclic_edge_profile?,
                dag_topology_manifest: value.dag_topology_manifest?,
                defeasible_attack_event: value.defeasible_attack_event?,
                defeasible_cascade_event: value.defeasible_cascade_event?,
                delegated_capability_manifest: value.delegated_capability_manifest?,
                deliberative_envelope: value.deliberative_envelope?,
                dempster_shafer_belief_vector: value.dempster_shafer_belief_vector?,
                derivation_mode_profile: value.derivation_mode_profile?,
                differentiable_logic_policy: value.differentiable_logic_policy?,
                digital_twin_topology_manifest: value.digital_twin_topology_manifest?,
                discourse_node_state: value.discourse_node_state?,
                discourse_tree_manifest: value.discourse_tree_manifest?,
                distribution_profile: value.distribution_profile?,
                distribution_shape_profile: value.distribution_shape_profile?,
                diversity_policy: value.diversity_policy?,
                document_knowledge_graph_manifest: value.document_knowledge_graph_manifest?,
                document_layout_manifest: value.document_layout_manifest?,
                document_layout_region_state: value.document_layout_region_state?,
                drafting_intent: value.drafting_intent?,
                dynamic_convergence_sla: value.dynamic_convergence_sla?,
                dynamic_layout_manifest: value.dynamic_layout_manifest?,
                dynamic_manifold_projection_manifest: value.dynamic_manifold_projection_manifest?,
                dynamic_routing_manifest: value.dynamic_routing_manifest?,
                edge_mapping_contract: value.edge_mapping_contract?,
                embodied_sensory_vector_profile: value.embodied_sensory_vector_profile?,
                empirical_falsification_contract: value.empirical_falsification_contract?,
                empirical_statistical_profile: value.empirical_statistical_profile?,
                ensemble_topology_profile: value.ensemble_topology_profile?,
                ephemeral_namespace_partition_state: value.ephemeral_namespace_partition_state?,
                epistemic_argument_claim_state: value.epistemic_argument_claim_state?,
                epistemic_argument_graph_state: value.epistemic_argument_graph_state?,
                epistemic_attention_state: value.epistemic_attention_state?,
                epistemic_axiom_state: value.epistemic_axiom_state?,
                epistemic_axiom_verification_receipt: value.epistemic_axiom_verification_receipt?,
                epistemic_chain_graph_state: value.epistemic_chain_graph_state?,
                epistemic_compression_sla: value.epistemic_compression_sla?,
                epistemic_constraint_policy: value.epistemic_constraint_policy?,
                epistemic_curriculum_manifest: value.epistemic_curriculum_manifest?,
                epistemic_domain_graph_manifest: value.epistemic_domain_graph_manifest?,
                epistemic_escalation_contract: value.epistemic_escalation_contract?,
                epistemic_flow_state_receipt: value.epistemic_flow_state_receipt?,
                epistemic_grounded_task_manifest: value.epistemic_grounded_task_manifest?,
                epistemic_guardrails_manifest: value.epistemic_guardrails_manifest?,
                epistemic_hydration_policy: value.epistemic_hydration_policy?,
                epistemic_ledger_state: value.epistemic_ledger_state?,
                epistemic_log_event: value.epistemic_log_event?,
                epistemic_promotion_event: value.epistemic_promotion_event?,
                epistemic_provenance_receipt: value.epistemic_provenance_receipt?,
                epistemic_proxy_state: value.epistemic_proxy_state?,
                epistemic_proxy_state_any: value.epistemic_proxy_state_any?,
                epistemic_quarantine_snapshot: value.epistemic_quarantine_snapshot?,
                epistemic_rejection_receipt: value.epistemic_rejection_receipt?,
                epistemic_rigidity_policy: value.epistemic_rigidity_policy?,
                epistemic_scanning_policy: value.epistemic_scanning_policy?,
                epistemic_security_policy: value.epistemic_security_policy?,
                epistemic_security_profile: value.epistemic_security_profile?,
                epistemic_seed_injection_policy: value.epistemic_seed_injection_policy?,
                epistemic_sop_manifest: value.epistemic_sop_manifest?,
                epistemic_starvation_event: value.epistemic_starvation_event?,
                epistemic_telemetry_event: value.epistemic_telemetry_event?,
                epistemic_topological_proof_manifest: value.epistemic_topological_proof_manifest?,
                epistemic_transmutation_task: value.epistemic_transmutation_task?,
                epistemic_upsampling_task: value.epistemic_upsampling_task?,
                epistemic_zero_trust_contract: value.epistemic_zero_trust_contract?,
                epistemic_zero_trust_receipt: value.epistemic_zero_trust_receipt?,
                escalation_contract: value.escalation_contract?,
                escalation_intent: value.escalation_intent?,
                escrow_policy: value.escrow_policy?,
                evaluator_optimizer_topology_manifest: value
                    .evaluator_optimizer_topology_manifest?,
                eviction_policy: value.eviction_policy?,
                evidentiary_citation_state: value.evidentiary_citation_state?,
                evidentiary_grounding_sla: value.evidentiary_grounding_sla?,
                evidentiary_warrant_state: value.evidentiary_warrant_state?,
                evolutionary_topology_manifest: value.evolutionary_topology_manifest?,
                execution_envelope_state: value.execution_envelope_state?,
                execution_sla: value.execution_sla?,
                execution_substrate_profile: value.execution_substrate_profile?,
                exogenous_epistemic_event: value.exogenous_epistemic_event?,
                facet_matrix_profile: value.facet_matrix_profile?,
                fallback_intent: value.fallback_intent?,
                fallback_sla: value.fallback_sla?,
                falsification_contract: value.falsification_contract?,
                fitness_objective_profile: value.fitness_objective_profile?,
                formal_logic_premise: value.formal_logic_premise?,
                formal_verification_contract: value.formal_verification_contract?,
                formal_verification_receipt: value.formal_verification_receipt?,
                fyi_intent: value.fyi_intent?,
                generative_manifold_sla: value.generative_manifold_sla?,
                generative_taxonomy_manifest: value.generative_taxonomy_manifest?,
                global_governance_policy: value.global_governance_policy?,
                global_semantic_invariant_profile: value.global_semantic_invariant_profile?,
                global_semantic_profile: value.global_semantic_profile?,
                grading_criterion_profile: value.grading_criterion_profile?,
                grammar_panel_profile: value.grammar_panel_profile?,
                graph_flattening_policy: value.graph_flattening_policy?,
                guardrail_violation_event: value.guardrail_violation_event?,
                hardware_enclave_receipt: value.hardware_enclave_receipt?,
                hierarchical_dom_manifest: value.hierarchical_dom_manifest?,
                hoare_logic_proof_receipt: value.hoare_logic_proof_receipt?,
                homomorphic_encryption_profile: value.homomorphic_encryption_profile?,
                http_transport_profile: value.http_transport_profile?,
                human_directive_intent: value.human_directive_intent?,
                hypothesis_generation_event: value.hypothesis_generation_event?,
                hypothesis_stake_receipt: value.hypothesis_stake_receipt?,
                hypothesis_superposition_state: value.hypothesis_superposition_state?,
                ideation_phase_profile: value.ideation_phase_profile?,
                illocutionary_force_profile: value.illocutionary_force_profile?,
                input_mapping_contract: value.input_mapping_contract?,
                insight_card_profile: value.insight_card_profile?,
                intent_classification_receipt: value.intent_classification_receipt?,
                intent_elicitation_topology_manifest: value.intent_elicitation_topology_manifest?,
                intervention_intent: value.intervention_intent?,
                intervention_policy: value.intervention_policy?,
                intervention_receipt: value.intervention_receipt?,
                interventional_causal_task: value.interventional_causal_task?,
                json_primitive_state: value.json_primitive_state?,
                jsonrpc_error_response_state: value.jsonrpc_error_response_state?,
                jsonrpc_error_state: value.jsonrpc_error_state?,
                kinematic_delta_manifest: value.kinematic_delta_manifest?,
                kinematic_derivative_profile: value.kinematic_derivative_profile?,
                kinetic_budget_policy: value.kinetic_budget_policy?,
                kinetic_separation_policy: value.kinetic_separation_policy?,
                latent_projection_intent: value.latent_projection_intent?,
                latent_schema_inference_intent: value.latent_schema_inference_intent?,
                latent_scratchpad_receipt: value.latent_scratchpad_receipt?,
                latent_smoothing_profile: value.latent_smoothing_profile?,
                lifecycle_trigger_event: value.lifecycle_trigger_event?,
                lineage_watermark_receipt: value.lineage_watermark_receipt?,
                link_ml_validation_sla: value.link_ml_validation_sla?,
                logit_steganography_contract: value.logit_steganography_contract?,
                macro_grid_profile: value.macro_grid_profile?,
                manifest_violation_receipt: value.manifest_violation_receipt?,
                manifold_alignment_metric_profile: value.manifold_alignment_metric_profile?,
                market_contract: value.market_contract?,
                market_resolution_state: value.market_resolution_state?,
                markov_blanket_rendering_policy: value.markov_blanket_rendering_policy?,
                mcp_capability_whitelist_policy: value.mcp_capability_whitelist_policy?,
                mcp_client_intent: value.mcp_client_intent?,
                mcp_prompt_reference_state: value.mcp_prompt_reference_state?,
                mcp_resource_manifest: value.mcp_resource_manifest?,
                mcp_server_manifest: value.mcp_server_manifest?,
                mcp_tool_definition: value.mcp_tool_definition?,
                mechanistic_audit_contract: value.mechanistic_audit_contract?,
                memoized_node_profile: value.memoized_node_profile?,
                multimodal_artifact_receipt: value.multimodal_artifact_receipt?,
                multimodal_token_anchor_state: value.multimodal_token_anchor_state?,
                mutation_policy: value.mutation_policy?,
                n_dimensional_tensor_manifest: value.n_dimensional_tensor_manifest?,
                neural_audit_attestation_receipt: value.neural_audit_attestation_receipt?,
                neuro_symbolic_handoff_contract: value.neuro_symbolic_handoff_contract?,
                neurosymbolic_inference_intent: value.neurosymbolic_inference_intent?,
                neurosymbolic_ingestion_topology_manifest: value
                    .neurosymbolic_ingestion_topology_manifest?,
                neurosymbolic_verification_topology_manifest: value
                    .neurosymbolic_verification_topology_manifest?,
                node_cid_state: value.node_cid_state?,
                observability_lod_policy: value.observability_lod_policy?,
                observation_event: value.observation_event?,
                ontological_alignment_policy: value.ontological_alignment_policy?,
                ontological_crosswalk_intent: value.ontological_crosswalk_intent?,
                ontological_normalization_intent: value.ontological_normalization_intent?,
                ontological_reification_receipt: value.ontological_reification_receipt?,
                ontological_surface_projection_manifest: value
                    .ontological_surface_projection_manifest?,
                ontology_discovery_intent: value.ontology_discovery_intent?,
                optical_mapping_contract: value.optical_mapping_contract?,
                optical_parsing_sla: value.optical_parsing_sla?,
                optimization_direction_profile: value.optimization_direction_profile?,
                oracle_execution_receipt: value.oracle_execution_receipt?,
                output_mapping_contract: value.output_mapping_contract?,
                override_intent: value.override_intent?,
                patch_operation_profile: value.patch_operation_profile?,
                peft_adapter_contract: value.peft_adapter_contract?,
                permission_boundary_policy: value.permission_boundary_policy?,
                persistence_commit_receipt: value.persistence_commit_receipt?,
                post_coordinated_semantic_state: value.post_coordinated_semantic_state?,
                post_quantum_signature_receipt: value.post_quantum_signature_receipt?,
                prediction_market_policy: value.prediction_market_policy?,
                prediction_market_state: value.prediction_market_state?,
                presentation_manifest: value.presentation_manifest?,
                procedural_metadata_manifest: value.procedural_metadata_manifest?,
                process_reward_contract: value.process_reward_contract?,
                profile_cid_state: value.profile_cid_state?,
                qo_s_classification_profile: value.qo_s_classification_profile?,
                quarantine_intent: value.quarantine_intent?,
                quorum_policy: value.quorum_policy?,
                rdf_export_receipt: value.rdf_export_receipt?,
                rdf_serialization_intent: value.rdf_serialization_intent?,
                reasoning_engineering_policy: value.reasoning_engineering_policy?,
                rhetorical_structure_profile: value.rhetorical_structure_profile?,
                risk_level_policy: value.risk_level_policy?,
                rollback_intent: value.rollback_intent?,
                routing_frontier_policy: value.routing_frontier_policy?,
                sae_feature_activation_state: value.sae_feature_activation_state?,
                sae_latent_policy: value.sae_latent_policy?,
                salience_profile: value.salience_profile?,
                scale_policy: value.scale_policy?,
                schema_driven_extraction_sla: value.schema_driven_extraction_sla?,
                se3_transform_profile: value.se3_transform_profile?,
                secure_sub_session_state: value.secure_sub_session_state?,
                self_correction_policy: value.self_correction_policy?,
                semantic_discovery_intent: value.semantic_discovery_intent?,
                semantic_edge_state: value.semantic_edge_state?,
                semantic_firewall_policy: value.semantic_firewall_policy?,
                semantic_flow_policy: value.semantic_flow_policy?,
                semantic_intent: value.semantic_intent?,
                semantic_mapping_heuristic_intent: value.semantic_mapping_heuristic_intent?,
                semantic_node_state: value.semantic_node_state?,
                semantic_relational_vector_state: value.semantic_relational_vector_state?,
                semantic_slicing_policy: value.semantic_slicing_policy?,
                semantic_version_state: value.semantic_version_state?,
                semantic_zoom_profile: value.semantic_zoom_profile?,
                shacl_validation_sla: value.shacl_validation_sla?,
                shapley_attribution_receipt: value.shapley_attribution_receipt?,
                side_effect_profile: value.side_effect_profile?,
                simulation_convergence_sla: value.simulation_convergence_sla?,
                simulation_escrow_contract: value.simulation_escrow_contract?,
                smpc_topology_manifest: value.smpc_topology_manifest?,
                sparql_query_intent: value.sparql_query_intent?,
                sparql_query_result_receipt: value.sparql_query_result_receipt?,
                spatial_billboard_contract: value.spatial_billboard_contract?,
                spatial_hardware_profile: value.spatial_hardware_profile?,
                spatial_kinematic_action_intent: value.spatial_kinematic_action_intent?,
                spatial_reference_frame_manifest: value.spatial_reference_frame_manifest?,
                spatial_render_material: value.spatial_render_material?,
                spatial_tool_manifest: value.spatial_tool_manifest?,
                speculative_execution_policy: value.speculative_execution_policy?,
                sse_transport_profile: value.sse_transport_profile?,
                state_contract: value.state_contract?,
                state_differential_manifest: value.state_differential_manifest?,
                state_hydration_manifest: value.state_hydration_manifest?,
                state_mutation_intent: value.state_mutation_intent?,
                state_vector_profile: value.state_vector_profile?,
                stdio_transport_profile: value.stdio_transport_profile?,
                stochastic_node_state: value.stochastic_node_state?,
                stochastic_topology_manifest: value.stochastic_topology_manifest?,
                strategic_thought_node_intent: value.strategic_thought_node_intent?,
                streaming_disfluency_contract: value.streaming_disfluency_contract?,
                structural_causal_graph_profile: value.structural_causal_graph_profile?,
                substrate_hydration_manifest: value.substrate_hydration_manifest?,
                swarm_topology_manifest: value.swarm_topology_manifest?,
                synthetic_generation_profile: value.synthetic_generation_profile?,
                system1_reflex_policy: value.system1_reflex_policy?,
                system2_remediation_intent: value.system2_remediation_intent?,
                system_fault_event: value.system_fault_event?,
                tabular_cell_state: value.tabular_cell_state?,
                tabular_encoding_profile: value.tabular_encoding_profile?,
                tabular_matrix_profile: value.tabular_matrix_profile?,
                target_topology_profile: value.target_topology_profile?,
                task_announcement_intent: value.task_announcement_intent?,
                task_award_receipt: value.task_award_receipt?,
                taxonomic_node_state: value.taxonomic_node_state?,
                taxonomic_restructure_intent: value.taxonomic_restructure_intent?,
                taxonomic_routing_policy: value.taxonomic_routing_policy?,
                telemetry_backpressure_contract: value.telemetry_backpressure_contract?,
                telemetry_context_profile: value.telemetry_context_profile?,
                telemetry_scalar_state: value.telemetry_scalar_state?,
                teleological_isometry_receipt: value.teleological_isometry_receipt?,
                temporal_bounds_profile: value.temporal_bounds_profile?,
                temporal_checkpoint_state: value.temporal_checkpoint_state?,
                temporal_conflict_resolution_policy: value.temporal_conflict_resolution_policy?,
                temporal_edge_invalidation_intent: value.temporal_edge_invalidation_intent?,
                temporal_graph_crdt_manifest: value.temporal_graph_crdt_manifest?,
                tensor_structural_format_profile: value.tensor_structural_format_profile?,
                terminal_buffer_state: value.terminal_buffer_state?,
                terminal_cognitive_event: value.terminal_cognitive_event?,
                terminal_condition_contract: value.terminal_condition_contract?,
                theory_of_mind_snapshot: value.theory_of_mind_snapshot?,
                thought_branch_state: value.thought_branch_state?,
                tie_breaker_policy: value.tie_breaker_policy?,
                token_burn_receipt: value.token_burn_receipt?,
                tool_invocation_event: value.tool_invocation_event?,
                topological_fidelity_receipt: value.topological_fidelity_receipt?,
                topological_projection_intent: value.topological_projection_intent?,
                topological_retrieval_contract: value.topological_retrieval_contract?,
                topology_hash_receipt: value.topology_hash_receipt?,
                trace_context_state: value.trace_context_state?,
                transformation_mechanism_profile: value.transformation_mechanism_profile?,
                transition_edge_profile: value.transition_edge_profile?,
                truth_maintenance_policy: value.truth_maintenance_policy?,
                upper_ontology_class_profile: value.upper_ontology_class_profile?,
                utility_justification_graph_receipt: value.utility_justification_graph_receipt?,
                vector_embedding_state: value.vector_embedding_state?,
                verifiable_credential_presentation_receipt: value
                    .verifiable_credential_presentation_receipt?,
                verifiable_entropy_receipt: value.verifiable_entropy_receipt?,
                viewport_projection_contract: value.viewport_projection_contract?,
                visual_encoding_profile: value.visual_encoding_profile?,
                volumetric_bounding_profile: value.volumetric_bounding_profile?,
                volumetric_edge_profile: value.volumetric_edge_profile?,
                volumetric_partition_state: value.volumetric_partition_state?,
                wetware_attestation_contract: value.wetware_attestation_contract?,
                workflow_manifest: value.workflow_manifest?,
                zero_knowledge_receipt: value.zero_knowledge_receipt?,
            })
        }
    }
    impl ::std::convert::From<super::CoReasonSharedKernelOntology> for CoReasonSharedKernelOntology {
        fn from(value: super::CoReasonSharedKernelOntology) -> Self {
            Self {
                activation_steering_contract: Ok(value.activation_steering_contract),
                active_inference_contract: Ok(value.active_inference_contract),
                adjudication_intent: Ok(value.adjudication_intent),
                adjudication_receipt: Ok(value.adjudication_receipt),
                adjudication_rubric_profile: Ok(value.adjudication_rubric_profile),
                adversarial_market_topology_manifest: Ok(value.adversarial_market_topology_manifest),
                agent_attestation_receipt: Ok(value.agent_attestation_receipt),
                agent_bid_intent: Ok(value.agent_bid_intent),
                algebraic_refinement_contract: Ok(value.algebraic_refinement_contract),
                ambient_state: Ok(value.ambient_state),
                analogical_mapping_task: Ok(value.analogical_mapping_task),
                anchoring_policy: Ok(value.anchoring_policy),
                any_action_space_capability: Ok(value.any_action_space_capability),
                any_exploration_branch: Ok(value.any_exploration_branch),
                any_intent: Ok(value.any_intent),
                any_node_profile: Ok(value.any_node_profile),
                any_panel_profile: Ok(value.any_panel_profile),
                any_presentation_intent: Ok(value.any_presentation_intent),
                any_state_event: Ok(value.any_state_event),
                any_toolchain_state: Ok(value.any_toolchain_state),
                any_topology_manifest: Ok(value.any_topology_manifest),
                any_transition_edge: Ok(value.any_transition_edge),
                artifact_corruption_event: Ok(value.artifact_corruption_event),
                ast_gradient_receipt: Ok(value.ast_gradient_receipt),
                asymptotic_complexity_receipt: Ok(value.asymptotic_complexity_receipt),
                atomic_proposition_state: Ok(value.atomic_proposition_state),
                attack_vector_profile: Ok(value.attack_vector_profile),
                auction_mechanism_profile: Ok(value.auction_mechanism_profile),
                auction_policy: Ok(value.auction_policy),
                auction_state: Ok(value.auction_state),
                backpressure_policy: Ok(value.backpressure_policy),
                barge_in_interrupt_event: Ok(value.barge_in_interrupt_event),
                belief_modulation_receipt: Ok(value.belief_modulation_receipt),
                belief_mutation_event: Ok(value.belief_mutation_event),
                bounded_intervention_scope_policy: Ok(value.bounded_intervention_scope_policy),
                bounded_jsonrpc_intent: Ok(value.bounded_jsonrpc_intent),
                browser_dom_state: Ok(value.browser_dom_state),
                budget_exhaustion_event: Ok(value.budget_exhaustion_event),
                bundle_content_hash_state: Ok(value.bundle_content_hash_state),
                bypass_receipt: Ok(value.bypass_receipt),
                capability_forge_topology_manifest: Ok(value.capability_forge_topology_manifest),
                capability_pointer_state: Ok(value.capability_pointer_state),
                causal_attribution_state: Ok(value.causal_attribution_state),
                causal_directed_edge_state: Ok(value.causal_directed_edge_state),
                causal_explanation_event: Ok(value.causal_explanation_event),
                causal_interval_profile: Ok(value.causal_interval_profile),
                causal_propagation_intent: Ok(value.causal_propagation_intent),
                circuit_breaker_event: Ok(value.circuit_breaker_event),
                cognitive_action_space_manifest: Ok(value.cognitive_action_space_manifest),
                cognitive_agent_node_profile: Ok(value.cognitive_agent_node_profile),
                cognitive_critique_profile: Ok(value.cognitive_critique_profile),
                cognitive_detailed_balance_contract: Ok(value.cognitive_detailed_balance_contract),
                cognitive_dual_verification_receipt: Ok(value.cognitive_dual_verification_receipt),
                cognitive_human_node_profile: Ok(value.cognitive_human_node_profile),
                cognitive_prediction_receipt: Ok(value.cognitive_prediction_receipt),
                cognitive_reasoning_trace_state: Ok(value.cognitive_reasoning_trace_state),
                cognitive_routing_contract: Ok(value.cognitive_routing_contract),
                cognitive_sampling_policy: Ok(value.cognitive_sampling_policy),
                cognitive_state_profile: Ok(value.cognitive_state_profile),
                cognitive_swarm_deployment_manifest: Ok(value.cognitive_swarm_deployment_manifest),
                cognitive_system_node_profile: Ok(value.cognitive_system_node_profile),
                cognitive_tier_profile: Ok(value.cognitive_tier_profile),
                cognitive_uncertainty_profile: Ok(value.cognitive_uncertainty_profile),
                collective_intelligence_profile: Ok(value.collective_intelligence_profile),
                composite_node_profile: Ok(value.composite_node_profile),
                compute_engine_profile: Ok(value.compute_engine_profile),
                compute_provisioning_intent: Ok(value.compute_provisioning_intent),
                compute_rate_contract: Ok(value.compute_rate_contract),
                consensus_federation_topology_manifest: Ok(
                    value.consensus_federation_topology_manifest
                ),
                consensus_policy: Ok(value.consensus_policy),
                constitutional_amendment_intent: Ok(value.constitutional_amendment_intent),
                constrained_decoding_policy: Ok(value.constrained_decoding_policy),
                context_expansion_policy: Ok(value.context_expansion_policy),
                contextual_semantic_resolution_intent: Ok(
                    value.contextual_semantic_resolution_intent
                ),
                contextualized_source_state: Ok(value.contextualized_source_state),
                continuous_manifold_mapping_contract: Ok(value.continuous_manifold_mapping_contract),
                continuous_mutation_policy: Ok(value.continuous_mutation_policy),
                continuous_observation_state: Ok(value.continuous_observation_state),
                continuous_spatial_mutation_intent: Ok(value.continuous_spatial_mutation_intent),
                council_topology_manifest: Ok(value.council_topology_manifest),
                counterfactual_regret_event: Ok(value.counterfactual_regret_event),
                crossover_mechanism_profile: Ok(value.crossover_mechanism_profile),
                crossover_policy: Ok(value.crossover_policy),
                crosswalk_resolution_receipt: Ok(value.crosswalk_resolution_receipt),
                cryptographic_provenance_policy: Ok(value.cryptographic_provenance_policy),
                crystallization_policy: Ok(value.crystallization_policy),
                custody_receipt: Ok(value.custody_receipt),
                cyclic_edge_profile: Ok(value.cyclic_edge_profile),
                dag_topology_manifest: Ok(value.dag_topology_manifest),
                defeasible_attack_event: Ok(value.defeasible_attack_event),
                defeasible_cascade_event: Ok(value.defeasible_cascade_event),
                delegated_capability_manifest: Ok(value.delegated_capability_manifest),
                deliberative_envelope: Ok(value.deliberative_envelope),
                dempster_shafer_belief_vector: Ok(value.dempster_shafer_belief_vector),
                derivation_mode_profile: Ok(value.derivation_mode_profile),
                differentiable_logic_policy: Ok(value.differentiable_logic_policy),
                digital_twin_topology_manifest: Ok(value.digital_twin_topology_manifest),
                discourse_node_state: Ok(value.discourse_node_state),
                discourse_tree_manifest: Ok(value.discourse_tree_manifest),
                distribution_profile: Ok(value.distribution_profile),
                distribution_shape_profile: Ok(value.distribution_shape_profile),
                diversity_policy: Ok(value.diversity_policy),
                document_knowledge_graph_manifest: Ok(value.document_knowledge_graph_manifest),
                document_layout_manifest: Ok(value.document_layout_manifest),
                document_layout_region_state: Ok(value.document_layout_region_state),
                drafting_intent: Ok(value.drafting_intent),
                dynamic_convergence_sla: Ok(value.dynamic_convergence_sla),
                dynamic_layout_manifest: Ok(value.dynamic_layout_manifest),
                dynamic_manifold_projection_manifest: Ok(value.dynamic_manifold_projection_manifest),
                dynamic_routing_manifest: Ok(value.dynamic_routing_manifest),
                edge_mapping_contract: Ok(value.edge_mapping_contract),
                embodied_sensory_vector_profile: Ok(value.embodied_sensory_vector_profile),
                empirical_falsification_contract: Ok(value.empirical_falsification_contract),
                empirical_statistical_profile: Ok(value.empirical_statistical_profile),
                ensemble_topology_profile: Ok(value.ensemble_topology_profile),
                ephemeral_namespace_partition_state: Ok(value.ephemeral_namespace_partition_state),
                epistemic_argument_claim_state: Ok(value.epistemic_argument_claim_state),
                epistemic_argument_graph_state: Ok(value.epistemic_argument_graph_state),
                epistemic_attention_state: Ok(value.epistemic_attention_state),
                epistemic_axiom_state: Ok(value.epistemic_axiom_state),
                epistemic_axiom_verification_receipt: Ok(value.epistemic_axiom_verification_receipt),
                epistemic_chain_graph_state: Ok(value.epistemic_chain_graph_state),
                epistemic_compression_sla: Ok(value.epistemic_compression_sla),
                epistemic_constraint_policy: Ok(value.epistemic_constraint_policy),
                epistemic_curriculum_manifest: Ok(value.epistemic_curriculum_manifest),
                epistemic_domain_graph_manifest: Ok(value.epistemic_domain_graph_manifest),
                epistemic_escalation_contract: Ok(value.epistemic_escalation_contract),
                epistemic_flow_state_receipt: Ok(value.epistemic_flow_state_receipt),
                epistemic_grounded_task_manifest: Ok(value.epistemic_grounded_task_manifest),
                epistemic_guardrails_manifest: Ok(value.epistemic_guardrails_manifest),
                epistemic_hydration_policy: Ok(value.epistemic_hydration_policy),
                epistemic_ledger_state: Ok(value.epistemic_ledger_state),
                epistemic_log_event: Ok(value.epistemic_log_event),
                epistemic_promotion_event: Ok(value.epistemic_promotion_event),
                epistemic_provenance_receipt: Ok(value.epistemic_provenance_receipt),
                epistemic_proxy_state: Ok(value.epistemic_proxy_state),
                epistemic_proxy_state_any: Ok(value.epistemic_proxy_state_any),
                epistemic_quarantine_snapshot: Ok(value.epistemic_quarantine_snapshot),
                epistemic_rejection_receipt: Ok(value.epistemic_rejection_receipt),
                epistemic_rigidity_policy: Ok(value.epistemic_rigidity_policy),
                epistemic_scanning_policy: Ok(value.epistemic_scanning_policy),
                epistemic_security_policy: Ok(value.epistemic_security_policy),
                epistemic_security_profile: Ok(value.epistemic_security_profile),
                epistemic_seed_injection_policy: Ok(value.epistemic_seed_injection_policy),
                epistemic_sop_manifest: Ok(value.epistemic_sop_manifest),
                epistemic_starvation_event: Ok(value.epistemic_starvation_event),
                epistemic_telemetry_event: Ok(value.epistemic_telemetry_event),
                epistemic_topological_proof_manifest: Ok(value.epistemic_topological_proof_manifest),
                epistemic_transmutation_task: Ok(value.epistemic_transmutation_task),
                epistemic_upsampling_task: Ok(value.epistemic_upsampling_task),
                epistemic_zero_trust_contract: Ok(value.epistemic_zero_trust_contract),
                epistemic_zero_trust_receipt: Ok(value.epistemic_zero_trust_receipt),
                escalation_contract: Ok(value.escalation_contract),
                escalation_intent: Ok(value.escalation_intent),
                escrow_policy: Ok(value.escrow_policy),
                evaluator_optimizer_topology_manifest: Ok(
                    value.evaluator_optimizer_topology_manifest
                ),
                eviction_policy: Ok(value.eviction_policy),
                evidentiary_citation_state: Ok(value.evidentiary_citation_state),
                evidentiary_grounding_sla: Ok(value.evidentiary_grounding_sla),
                evidentiary_warrant_state: Ok(value.evidentiary_warrant_state),
                evolutionary_topology_manifest: Ok(value.evolutionary_topology_manifest),
                execution_envelope_state: Ok(value.execution_envelope_state),
                execution_sla: Ok(value.execution_sla),
                execution_substrate_profile: Ok(value.execution_substrate_profile),
                exogenous_epistemic_event: Ok(value.exogenous_epistemic_event),
                facet_matrix_profile: Ok(value.facet_matrix_profile),
                fallback_intent: Ok(value.fallback_intent),
                fallback_sla: Ok(value.fallback_sla),
                falsification_contract: Ok(value.falsification_contract),
                fitness_objective_profile: Ok(value.fitness_objective_profile),
                formal_logic_premise: Ok(value.formal_logic_premise),
                formal_verification_contract: Ok(value.formal_verification_contract),
                formal_verification_receipt: Ok(value.formal_verification_receipt),
                fyi_intent: Ok(value.fyi_intent),
                generative_manifold_sla: Ok(value.generative_manifold_sla),
                generative_taxonomy_manifest: Ok(value.generative_taxonomy_manifest),
                global_governance_policy: Ok(value.global_governance_policy),
                global_semantic_invariant_profile: Ok(value.global_semantic_invariant_profile),
                global_semantic_profile: Ok(value.global_semantic_profile),
                grading_criterion_profile: Ok(value.grading_criterion_profile),
                grammar_panel_profile: Ok(value.grammar_panel_profile),
                graph_flattening_policy: Ok(value.graph_flattening_policy),
                guardrail_violation_event: Ok(value.guardrail_violation_event),
                hardware_enclave_receipt: Ok(value.hardware_enclave_receipt),
                hierarchical_dom_manifest: Ok(value.hierarchical_dom_manifest),
                hoare_logic_proof_receipt: Ok(value.hoare_logic_proof_receipt),
                homomorphic_encryption_profile: Ok(value.homomorphic_encryption_profile),
                http_transport_profile: Ok(value.http_transport_profile),
                human_directive_intent: Ok(value.human_directive_intent),
                hypothesis_generation_event: Ok(value.hypothesis_generation_event),
                hypothesis_stake_receipt: Ok(value.hypothesis_stake_receipt),
                hypothesis_superposition_state: Ok(value.hypothesis_superposition_state),
                ideation_phase_profile: Ok(value.ideation_phase_profile),
                illocutionary_force_profile: Ok(value.illocutionary_force_profile),
                input_mapping_contract: Ok(value.input_mapping_contract),
                insight_card_profile: Ok(value.insight_card_profile),
                intent_classification_receipt: Ok(value.intent_classification_receipt),
                intent_elicitation_topology_manifest: Ok(value.intent_elicitation_topology_manifest),
                intervention_intent: Ok(value.intervention_intent),
                intervention_policy: Ok(value.intervention_policy),
                intervention_receipt: Ok(value.intervention_receipt),
                interventional_causal_task: Ok(value.interventional_causal_task),
                json_primitive_state: Ok(value.json_primitive_state),
                jsonrpc_error_response_state: Ok(value.jsonrpc_error_response_state),
                jsonrpc_error_state: Ok(value.jsonrpc_error_state),
                kinematic_delta_manifest: Ok(value.kinematic_delta_manifest),
                kinematic_derivative_profile: Ok(value.kinematic_derivative_profile),
                kinetic_budget_policy: Ok(value.kinetic_budget_policy),
                kinetic_separation_policy: Ok(value.kinetic_separation_policy),
                latent_projection_intent: Ok(value.latent_projection_intent),
                latent_schema_inference_intent: Ok(value.latent_schema_inference_intent),
                latent_scratchpad_receipt: Ok(value.latent_scratchpad_receipt),
                latent_smoothing_profile: Ok(value.latent_smoothing_profile),
                lifecycle_trigger_event: Ok(value.lifecycle_trigger_event),
                lineage_watermark_receipt: Ok(value.lineage_watermark_receipt),
                link_ml_validation_sla: Ok(value.link_ml_validation_sla),
                logit_steganography_contract: Ok(value.logit_steganography_contract),
                macro_grid_profile: Ok(value.macro_grid_profile),
                manifest_violation_receipt: Ok(value.manifest_violation_receipt),
                manifold_alignment_metric_profile: Ok(value.manifold_alignment_metric_profile),
                market_contract: Ok(value.market_contract),
                market_resolution_state: Ok(value.market_resolution_state),
                markov_blanket_rendering_policy: Ok(value.markov_blanket_rendering_policy),
                mcp_capability_whitelist_policy: Ok(value.mcp_capability_whitelist_policy),
                mcp_client_intent: Ok(value.mcp_client_intent),
                mcp_prompt_reference_state: Ok(value.mcp_prompt_reference_state),
                mcp_resource_manifest: Ok(value.mcp_resource_manifest),
                mcp_server_manifest: Ok(value.mcp_server_manifest),
                mcp_tool_definition: Ok(value.mcp_tool_definition),
                mechanistic_audit_contract: Ok(value.mechanistic_audit_contract),
                memoized_node_profile: Ok(value.memoized_node_profile),
                multimodal_artifact_receipt: Ok(value.multimodal_artifact_receipt),
                multimodal_token_anchor_state: Ok(value.multimodal_token_anchor_state),
                mutation_policy: Ok(value.mutation_policy),
                n_dimensional_tensor_manifest: Ok(value.n_dimensional_tensor_manifest),
                neural_audit_attestation_receipt: Ok(value.neural_audit_attestation_receipt),
                neuro_symbolic_handoff_contract: Ok(value.neuro_symbolic_handoff_contract),
                neurosymbolic_inference_intent: Ok(value.neurosymbolic_inference_intent),
                neurosymbolic_ingestion_topology_manifest: Ok(
                    value.neurosymbolic_ingestion_topology_manifest
                ),
                neurosymbolic_verification_topology_manifest: Ok(
                    value.neurosymbolic_verification_topology_manifest
                ),
                node_cid_state: Ok(value.node_cid_state),
                observability_lod_policy: Ok(value.observability_lod_policy),
                observation_event: Ok(value.observation_event),
                ontological_alignment_policy: Ok(value.ontological_alignment_policy),
                ontological_crosswalk_intent: Ok(value.ontological_crosswalk_intent),
                ontological_normalization_intent: Ok(value.ontological_normalization_intent),
                ontological_reification_receipt: Ok(value.ontological_reification_receipt),
                ontological_surface_projection_manifest: Ok(
                    value.ontological_surface_projection_manifest
                ),
                ontology_discovery_intent: Ok(value.ontology_discovery_intent),
                optical_mapping_contract: Ok(value.optical_mapping_contract),
                optical_parsing_sla: Ok(value.optical_parsing_sla),
                optimization_direction_profile: Ok(value.optimization_direction_profile),
                oracle_execution_receipt: Ok(value.oracle_execution_receipt),
                output_mapping_contract: Ok(value.output_mapping_contract),
                override_intent: Ok(value.override_intent),
                patch_operation_profile: Ok(value.patch_operation_profile),
                peft_adapter_contract: Ok(value.peft_adapter_contract),
                permission_boundary_policy: Ok(value.permission_boundary_policy),
                persistence_commit_receipt: Ok(value.persistence_commit_receipt),
                post_coordinated_semantic_state: Ok(value.post_coordinated_semantic_state),
                post_quantum_signature_receipt: Ok(value.post_quantum_signature_receipt),
                prediction_market_policy: Ok(value.prediction_market_policy),
                prediction_market_state: Ok(value.prediction_market_state),
                presentation_manifest: Ok(value.presentation_manifest),
                procedural_metadata_manifest: Ok(value.procedural_metadata_manifest),
                process_reward_contract: Ok(value.process_reward_contract),
                profile_cid_state: Ok(value.profile_cid_state),
                qo_s_classification_profile: Ok(value.qo_s_classification_profile),
                quarantine_intent: Ok(value.quarantine_intent),
                quorum_policy: Ok(value.quorum_policy),
                rdf_export_receipt: Ok(value.rdf_export_receipt),
                rdf_serialization_intent: Ok(value.rdf_serialization_intent),
                reasoning_engineering_policy: Ok(value.reasoning_engineering_policy),
                rhetorical_structure_profile: Ok(value.rhetorical_structure_profile),
                risk_level_policy: Ok(value.risk_level_policy),
                rollback_intent: Ok(value.rollback_intent),
                routing_frontier_policy: Ok(value.routing_frontier_policy),
                sae_feature_activation_state: Ok(value.sae_feature_activation_state),
                sae_latent_policy: Ok(value.sae_latent_policy),
                salience_profile: Ok(value.salience_profile),
                scale_policy: Ok(value.scale_policy),
                schema_driven_extraction_sla: Ok(value.schema_driven_extraction_sla),
                se3_transform_profile: Ok(value.se3_transform_profile),
                secure_sub_session_state: Ok(value.secure_sub_session_state),
                self_correction_policy: Ok(value.self_correction_policy),
                semantic_discovery_intent: Ok(value.semantic_discovery_intent),
                semantic_edge_state: Ok(value.semantic_edge_state),
                semantic_firewall_policy: Ok(value.semantic_firewall_policy),
                semantic_flow_policy: Ok(value.semantic_flow_policy),
                semantic_intent: Ok(value.semantic_intent),
                semantic_mapping_heuristic_intent: Ok(value.semantic_mapping_heuristic_intent),
                semantic_node_state: Ok(value.semantic_node_state),
                semantic_relational_vector_state: Ok(value.semantic_relational_vector_state),
                semantic_slicing_policy: Ok(value.semantic_slicing_policy),
                semantic_version_state: Ok(value.semantic_version_state),
                semantic_zoom_profile: Ok(value.semantic_zoom_profile),
                shacl_validation_sla: Ok(value.shacl_validation_sla),
                shapley_attribution_receipt: Ok(value.shapley_attribution_receipt),
                side_effect_profile: Ok(value.side_effect_profile),
                simulation_convergence_sla: Ok(value.simulation_convergence_sla),
                simulation_escrow_contract: Ok(value.simulation_escrow_contract),
                smpc_topology_manifest: Ok(value.smpc_topology_manifest),
                sparql_query_intent: Ok(value.sparql_query_intent),
                sparql_query_result_receipt: Ok(value.sparql_query_result_receipt),
                spatial_billboard_contract: Ok(value.spatial_billboard_contract),
                spatial_hardware_profile: Ok(value.spatial_hardware_profile),
                spatial_kinematic_action_intent: Ok(value.spatial_kinematic_action_intent),
                spatial_reference_frame_manifest: Ok(value.spatial_reference_frame_manifest),
                spatial_render_material: Ok(value.spatial_render_material),
                spatial_tool_manifest: Ok(value.spatial_tool_manifest),
                speculative_execution_policy: Ok(value.speculative_execution_policy),
                sse_transport_profile: Ok(value.sse_transport_profile),
                state_contract: Ok(value.state_contract),
                state_differential_manifest: Ok(value.state_differential_manifest),
                state_hydration_manifest: Ok(value.state_hydration_manifest),
                state_mutation_intent: Ok(value.state_mutation_intent),
                state_vector_profile: Ok(value.state_vector_profile),
                stdio_transport_profile: Ok(value.stdio_transport_profile),
                stochastic_node_state: Ok(value.stochastic_node_state),
                stochastic_topology_manifest: Ok(value.stochastic_topology_manifest),
                strategic_thought_node_intent: Ok(value.strategic_thought_node_intent),
                streaming_disfluency_contract: Ok(value.streaming_disfluency_contract),
                structural_causal_graph_profile: Ok(value.structural_causal_graph_profile),
                substrate_hydration_manifest: Ok(value.substrate_hydration_manifest),
                swarm_topology_manifest: Ok(value.swarm_topology_manifest),
                synthetic_generation_profile: Ok(value.synthetic_generation_profile),
                system1_reflex_policy: Ok(value.system1_reflex_policy),
                system2_remediation_intent: Ok(value.system2_remediation_intent),
                system_fault_event: Ok(value.system_fault_event),
                tabular_cell_state: Ok(value.tabular_cell_state),
                tabular_encoding_profile: Ok(value.tabular_encoding_profile),
                tabular_matrix_profile: Ok(value.tabular_matrix_profile),
                target_topology_profile: Ok(value.target_topology_profile),
                task_announcement_intent: Ok(value.task_announcement_intent),
                task_award_receipt: Ok(value.task_award_receipt),
                taxonomic_node_state: Ok(value.taxonomic_node_state),
                taxonomic_restructure_intent: Ok(value.taxonomic_restructure_intent),
                taxonomic_routing_policy: Ok(value.taxonomic_routing_policy),
                telemetry_backpressure_contract: Ok(value.telemetry_backpressure_contract),
                telemetry_context_profile: Ok(value.telemetry_context_profile),
                telemetry_scalar_state: Ok(value.telemetry_scalar_state),
                teleological_isometry_receipt: Ok(value.teleological_isometry_receipt),
                temporal_bounds_profile: Ok(value.temporal_bounds_profile),
                temporal_checkpoint_state: Ok(value.temporal_checkpoint_state),
                temporal_conflict_resolution_policy: Ok(value.temporal_conflict_resolution_policy),
                temporal_edge_invalidation_intent: Ok(value.temporal_edge_invalidation_intent),
                temporal_graph_crdt_manifest: Ok(value.temporal_graph_crdt_manifest),
                tensor_structural_format_profile: Ok(value.tensor_structural_format_profile),
                terminal_buffer_state: Ok(value.terminal_buffer_state),
                terminal_cognitive_event: Ok(value.terminal_cognitive_event),
                terminal_condition_contract: Ok(value.terminal_condition_contract),
                theory_of_mind_snapshot: Ok(value.theory_of_mind_snapshot),
                thought_branch_state: Ok(value.thought_branch_state),
                tie_breaker_policy: Ok(value.tie_breaker_policy),
                token_burn_receipt: Ok(value.token_burn_receipt),
                tool_invocation_event: Ok(value.tool_invocation_event),
                topological_fidelity_receipt: Ok(value.topological_fidelity_receipt),
                topological_projection_intent: Ok(value.topological_projection_intent),
                topological_retrieval_contract: Ok(value.topological_retrieval_contract),
                topology_hash_receipt: Ok(value.topology_hash_receipt),
                trace_context_state: Ok(value.trace_context_state),
                transformation_mechanism_profile: Ok(value.transformation_mechanism_profile),
                transition_edge_profile: Ok(value.transition_edge_profile),
                truth_maintenance_policy: Ok(value.truth_maintenance_policy),
                upper_ontology_class_profile: Ok(value.upper_ontology_class_profile),
                utility_justification_graph_receipt: Ok(value.utility_justification_graph_receipt),
                vector_embedding_state: Ok(value.vector_embedding_state),
                verifiable_credential_presentation_receipt: Ok(
                    value.verifiable_credential_presentation_receipt
                ),
                verifiable_entropy_receipt: Ok(value.verifiable_entropy_receipt),
                viewport_projection_contract: Ok(value.viewport_projection_contract),
                visual_encoding_profile: Ok(value.visual_encoding_profile),
                volumetric_bounding_profile: Ok(value.volumetric_bounding_profile),
                volumetric_edge_profile: Ok(value.volumetric_edge_profile),
                volumetric_partition_state: Ok(value.volumetric_partition_state),
                wetware_attestation_contract: Ok(value.wetware_attestation_contract),
                workflow_manifest: Ok(value.workflow_manifest),
                zero_knowledge_receipt: Ok(value.zero_knowledge_receipt),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitiveActionSpaceManifest {
        action_space_cid: ::std::result::Result<super::ActionSpaceCid, ::std::string::String>,
        capabilities: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::AnyActionSpaceCapability>,
            ::std::string::String,
        >,
        capability_cid: ::std::result::Result<
            ::std::option::Option<super::BundleContentHashState>,
            ::std::string::String,
        >,
        entry_point_cid: ::std::result::Result<super::EntryPointCid, ::std::string::String>,
        execution_fee_lmsr:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        kinetic_separation: ::std::result::Result<
            ::std::option::Option<super::KineticSeparationPolicy>,
            ::std::string::String,
        >,
        metadata_cid: ::std::result::Result<
            ::std::option::Option<super::BundleContentHashState>,
            ::std::string::String,
        >,
        transition_matrix: ::std::result::Result<
            ::std::collections::HashMap<
                ::std::string::String,
                ::std::vec::Vec<super::AnyTransitionEdge>,
            >,
            ::std::string::String,
        >,
        trusted_validators:
            ::std::result::Result<::std::vec::Vec<super::NodeCidState>, ::std::string::String>,
    }
    impl ::std::default::Default for CognitiveActionSpaceManifest {
        fn default() -> Self {
            Self {
                action_space_cid: Err("no value supplied for action_space_cid".to_string()),
                capabilities: Err("no value supplied for capabilities".to_string()),
                capability_cid: Ok(Default::default()),
                entry_point_cid: Err("no value supplied for entry_point_cid".to_string()),
                execution_fee_lmsr: Ok(Default::default()),
                kinetic_separation: Ok(Default::default()),
                metadata_cid: Ok(Default::default()),
                transition_matrix: Err("no value supplied for transition_matrix".to_string()),
                trusted_validators: Ok(Default::default()),
            }
        }
    }
    impl CognitiveActionSpaceManifest {
        pub fn action_space_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ActionSpaceCid>,
            T::Error: ::std::fmt::Display,
        {
            self.action_space_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for action_space_cid: {e}"));
            self
        }
        pub fn capabilities<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::AnyActionSpaceCapability>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.capabilities = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for capabilities: {e}"));
            self
        }
        pub fn capability_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::BundleContentHashState>>,
            T::Error: ::std::fmt::Display,
        {
            self.capability_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for capability_cid: {e}"));
            self
        }
        pub fn entry_point_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EntryPointCid>,
            T::Error: ::std::fmt::Display,
        {
            self.entry_point_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for entry_point_cid: {e}"));
            self
        }
        pub fn execution_fee_lmsr<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.execution_fee_lmsr = value.try_into().map_err(|e| {
                format!("error converting supplied value for execution_fee_lmsr: {e}")
            });
            self
        }
        pub fn kinetic_separation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::KineticSeparationPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.kinetic_separation = value.try_into().map_err(|e| {
                format!("error converting supplied value for kinetic_separation: {e}")
            });
            self
        }
        pub fn metadata_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::BundleContentHashState>>,
            T::Error: ::std::fmt::Display,
        {
            self.metadata_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for metadata_cid: {e}"));
            self
        }
        pub fn transition_matrix<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    ::std::vec::Vec<super::AnyTransitionEdge>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.transition_matrix = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for transition_matrix: {e}"));
            self
        }
        pub fn trusted_validators<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.trusted_validators = value.try_into().map_err(|e| {
                format!("error converting supplied value for trusted_validators: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<CognitiveActionSpaceManifest> for super::CognitiveActionSpaceManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitiveActionSpaceManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                action_space_cid: value.action_space_cid?,
                capabilities: value.capabilities?,
                capability_cid: value.capability_cid?,
                entry_point_cid: value.entry_point_cid?,
                execution_fee_lmsr: value.execution_fee_lmsr?,
                kinetic_separation: value.kinetic_separation?,
                metadata_cid: value.metadata_cid?,
                transition_matrix: value.transition_matrix?,
                trusted_validators: value.trusted_validators?,
            })
        }
    }
    impl ::std::convert::From<super::CognitiveActionSpaceManifest> for CognitiveActionSpaceManifest {
        fn from(value: super::CognitiveActionSpaceManifest) -> Self {
            Self {
                action_space_cid: Ok(value.action_space_cid),
                capabilities: Ok(value.capabilities),
                capability_cid: Ok(value.capability_cid),
                entry_point_cid: Ok(value.entry_point_cid),
                execution_fee_lmsr: Ok(value.execution_fee_lmsr),
                kinetic_separation: Ok(value.kinetic_separation),
                metadata_cid: Ok(value.metadata_cid),
                transition_matrix: Ok(value.transition_matrix),
                trusted_validators: Ok(value.trusted_validators),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitiveAgentNodeProfile {
        action_space_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        active_attention_ray: ::std::result::Result<
            ::std::option::Option<super::EpistemicAttentionState>,
            ::std::string::String,
        >,
        active_inference_policy: ::std::result::Result<
            ::std::option::Option<super::ActiveInferenceContract>,
            ::std::string::String,
        >,
        agent_attestation: ::std::result::Result<
            ::std::option::Option<super::AgentAttestationReceipt>,
            ::std::string::String,
        >,
        analogical_policy: ::std::result::Result<
            ::std::option::Option<super::AnalogicalMappingTask>,
            ::std::string::String,
        >,
        anchoring_policy: ::std::result::Result<
            ::std::option::Option<super::AnchoringPolicy>,
            ::std::string::String,
        >,
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        audit_policy: ::std::result::Result<
            ::std::option::Option<super::MechanisticAuditContract>,
            ::std::string::String,
        >,
        baseline_cognitive_state: ::std::result::Result<
            ::std::option::Option<super::CognitiveStateProfile>,
            ::std::string::String,
        >,
        compute_frontier: ::std::result::Result<
            ::std::option::Option<super::RoutingFrontierPolicy>,
            ::std::string::String,
        >,
        correction_policy: ::std::result::Result<
            ::std::option::Option<super::SelfCorrectionPolicy>,
            ::std::string::String,
        >,
        description: ::std::result::Result<super::Description, ::std::string::String>,
        domain_extensions: ::std::result::Result<
            ::std::option::Option<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            ::std::string::String,
        >,
        emitted_intents:
            ::std::result::Result<::std::vec::Vec<super::AnyIntent>, ::std::string::String>,
        epistemic_policy: ::std::result::Result<
            ::std::option::Option<super::EpistemicScanningPolicy>,
            ::std::string::String,
        >,
        epistemic_rigidity: ::std::result::Result<
            ::std::option::Option<super::EpistemicRigidityPolicy>,
            ::std::string::String,
        >,
        escalation_policy: ::std::result::Result<
            ::std::option::Option<super::EscalationContract>,
            ::std::string::String,
        >,
        gflownet_balance_policy: ::std::result::Result<
            ::std::option::Option<super::CognitiveDetailedBalanceContract>,
            ::std::string::String,
        >,
        hardware: ::std::result::Result<
            ::std::option::Option<super::SpatialHardwareProfile>,
            ::std::string::String,
        >,
        intervention_policies: ::std::result::Result<
            ::std::vec::Vec<super::InterventionPolicy>,
            ::std::string::String,
        >,
        interventional_policy: ::std::result::Result<
            ::std::option::Option<super::InterventionalCausalTask>,
            ::std::string::String,
        >,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        logit_steganography: ::std::result::Result<
            ::std::option::Option<super::LogitSteganographyContract>,
            ::std::string::String,
        >,
        markov_blanket: ::std::result::Result<
            ::std::option::Option<super::MarkovBlanketRenderingPolicy>,
            ::std::string::String,
        >,
        peft_adapters: ::std::result::Result<
            ::std::vec::Vec<super::PeftAdapterContract>,
            ::std::string::String,
        >,
        reflex_policy: ::std::result::Result<
            ::std::option::Option<super::System1ReflexPolicy>,
            ::std::string::String,
        >,
        render_material: ::std::result::Result<
            ::std::option::Option<super::SpatialRenderMaterial>,
            ::std::string::String,
        >,
        secure_sub_session: ::std::result::Result<
            ::std::option::Option<super::SecureSubSessionState>,
            ::std::string::String,
        >,
        security: ::std::result::Result<
            ::std::option::Option<super::EpistemicSecurityProfile>,
            ::std::string::String,
        >,
        semantic_zoom: ::std::result::Result<
            ::std::option::Option<super::SemanticZoomProfile>,
            ::std::string::String,
        >,
        symbolic_handoff_policy: ::std::result::Result<
            ::std::option::Option<super::NeuroSymbolicHandoffContract>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CognitiveAgentNodeProfile {
        fn default() -> Self {
            Self {
                action_space_cid: Ok(Default::default()),
                active_attention_ray: Ok(Default::default()),
                active_inference_policy: Ok(Default::default()),
                agent_attestation: Ok(Default::default()),
                analogical_policy: Ok(Default::default()),
                anchoring_policy: Ok(Default::default()),
                architectural_intent: Ok(Default::default()),
                audit_policy: Ok(Default::default()),
                baseline_cognitive_state: Ok(Default::default()),
                compute_frontier: Ok(Default::default()),
                correction_policy: Ok(Default::default()),
                description: Err("no value supplied for description".to_string()),
                domain_extensions: Ok(Default::default()),
                emitted_intents: Ok(Default::default()),
                epistemic_policy: Ok(Default::default()),
                epistemic_rigidity: Ok(Default::default()),
                escalation_policy: Ok(Default::default()),
                gflownet_balance_policy: Ok(Default::default()),
                hardware: Ok(Default::default()),
                intervention_policies: Ok(Default::default()),
                interventional_policy: Ok(Default::default()),
                justification: Ok(Default::default()),
                logit_steganography: Ok(Default::default()),
                markov_blanket: Ok(Default::default()),
                peft_adapters: Ok(Default::default()),
                reflex_policy: Ok(Default::default()),
                render_material: Ok(Default::default()),
                secure_sub_session: Ok(Default::default()),
                security: Ok(Default::default()),
                semantic_zoom: Ok(Default::default()),
                symbolic_handoff_policy: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl CognitiveAgentNodeProfile {
        pub fn action_space_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.action_space_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for action_space_cid: {e}"));
            self
        }
        pub fn active_attention_ray<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicAttentionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.active_attention_ray = value.try_into().map_err(|e| {
                format!("error converting supplied value for active_attention_ray: {e}")
            });
            self
        }
        pub fn active_inference_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ActiveInferenceContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.active_inference_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for active_inference_policy: {e}")
            });
            self
        }
        pub fn agent_attestation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AgentAttestationReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.agent_attestation = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for agent_attestation: {e}"));
            self
        }
        pub fn analogical_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnalogicalMappingTask>>,
            T::Error: ::std::fmt::Display,
        {
            self.analogical_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for analogical_policy: {e}"));
            self
        }
        pub fn anchoring_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnchoringPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.anchoring_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for anchoring_policy: {e}"));
            self
        }
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn audit_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MechanisticAuditContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.audit_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for audit_policy: {e}"));
            self
        }
        pub fn baseline_cognitive_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveStateProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.baseline_cognitive_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for baseline_cognitive_state: {e}")
            });
            self
        }
        pub fn compute_frontier<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::RoutingFrontierPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.compute_frontier = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for compute_frontier: {e}"));
            self
        }
        pub fn correction_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SelfCorrectionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.correction_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for correction_policy: {e}"));
            self
        }
        pub fn description<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Description>,
            T::Error: ::std::fmt::Display,
        {
            self.description = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for description: {e}"));
            self
        }
        pub fn domain_extensions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.domain_extensions = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for domain_extensions: {e}"));
            self
        }
        pub fn emitted_intents<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AnyIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.emitted_intents = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for emitted_intents: {e}"));
            self
        }
        pub fn epistemic_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicScanningPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for epistemic_policy: {e}"));
            self
        }
        pub fn epistemic_rigidity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicRigidityPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_rigidity = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_rigidity: {e}")
            });
            self
        }
        pub fn escalation_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EscalationContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.escalation_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for escalation_policy: {e}"));
            self
        }
        pub fn gflownet_balance_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::CognitiveDetailedBalanceContract>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.gflownet_balance_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for gflownet_balance_policy: {e}")
            });
            self
        }
        pub fn hardware<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialHardwareProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.hardware = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for hardware: {e}"));
            self
        }
        pub fn intervention_policies<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::InterventionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.intervention_policies = value.try_into().map_err(|e| {
                format!("error converting supplied value for intervention_policies: {e}")
            });
            self
        }
        pub fn interventional_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::InterventionalCausalTask>>,
            T::Error: ::std::fmt::Display,
        {
            self.interventional_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for interventional_policy: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn logit_steganography<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LogitSteganographyContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.logit_steganography = value.try_into().map_err(|e| {
                format!("error converting supplied value for logit_steganography: {e}")
            });
            self
        }
        pub fn markov_blanket<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MarkovBlanketRenderingPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.markov_blanket = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for markov_blanket: {e}"));
            self
        }
        pub fn peft_adapters<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::PeftAdapterContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.peft_adapters = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for peft_adapters: {e}"));
            self
        }
        pub fn reflex_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::System1ReflexPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.reflex_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for reflex_policy: {e}"));
            self
        }
        pub fn render_material<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialRenderMaterial>>,
            T::Error: ::std::fmt::Display,
        {
            self.render_material = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for render_material: {e}"));
            self
        }
        pub fn secure_sub_session<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SecureSubSessionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.secure_sub_session = value.try_into().map_err(|e| {
                format!("error converting supplied value for secure_sub_session: {e}")
            });
            self
        }
        pub fn security<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicSecurityProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.security = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for security: {e}"));
            self
        }
        pub fn semantic_zoom<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticZoomProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_zoom = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_zoom: {e}"));
            self
        }
        pub fn symbolic_handoff_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NeuroSymbolicHandoffContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.symbolic_handoff_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for symbolic_handoff_policy: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CognitiveAgentNodeProfile> for super::CognitiveAgentNodeProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitiveAgentNodeProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                action_space_cid: value.action_space_cid?,
                active_attention_ray: value.active_attention_ray?,
                active_inference_policy: value.active_inference_policy?,
                agent_attestation: value.agent_attestation?,
                analogical_policy: value.analogical_policy?,
                anchoring_policy: value.anchoring_policy?,
                architectural_intent: value.architectural_intent?,
                audit_policy: value.audit_policy?,
                baseline_cognitive_state: value.baseline_cognitive_state?,
                compute_frontier: value.compute_frontier?,
                correction_policy: value.correction_policy?,
                description: value.description?,
                domain_extensions: value.domain_extensions?,
                emitted_intents: value.emitted_intents?,
                epistemic_policy: value.epistemic_policy?,
                epistemic_rigidity: value.epistemic_rigidity?,
                escalation_policy: value.escalation_policy?,
                gflownet_balance_policy: value.gflownet_balance_policy?,
                hardware: value.hardware?,
                intervention_policies: value.intervention_policies?,
                interventional_policy: value.interventional_policy?,
                justification: value.justification?,
                logit_steganography: value.logit_steganography?,
                markov_blanket: value.markov_blanket?,
                peft_adapters: value.peft_adapters?,
                reflex_policy: value.reflex_policy?,
                render_material: value.render_material?,
                secure_sub_session: value.secure_sub_session?,
                security: value.security?,
                semantic_zoom: value.semantic_zoom?,
                symbolic_handoff_policy: value.symbolic_handoff_policy?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::CognitiveAgentNodeProfile> for CognitiveAgentNodeProfile {
        fn from(value: super::CognitiveAgentNodeProfile) -> Self {
            Self {
                action_space_cid: Ok(value.action_space_cid),
                active_attention_ray: Ok(value.active_attention_ray),
                active_inference_policy: Ok(value.active_inference_policy),
                agent_attestation: Ok(value.agent_attestation),
                analogical_policy: Ok(value.analogical_policy),
                anchoring_policy: Ok(value.anchoring_policy),
                architectural_intent: Ok(value.architectural_intent),
                audit_policy: Ok(value.audit_policy),
                baseline_cognitive_state: Ok(value.baseline_cognitive_state),
                compute_frontier: Ok(value.compute_frontier),
                correction_policy: Ok(value.correction_policy),
                description: Ok(value.description),
                domain_extensions: Ok(value.domain_extensions),
                emitted_intents: Ok(value.emitted_intents),
                epistemic_policy: Ok(value.epistemic_policy),
                epistemic_rigidity: Ok(value.epistemic_rigidity),
                escalation_policy: Ok(value.escalation_policy),
                gflownet_balance_policy: Ok(value.gflownet_balance_policy),
                hardware: Ok(value.hardware),
                intervention_policies: Ok(value.intervention_policies),
                interventional_policy: Ok(value.interventional_policy),
                justification: Ok(value.justification),
                logit_steganography: Ok(value.logit_steganography),
                markov_blanket: Ok(value.markov_blanket),
                peft_adapters: Ok(value.peft_adapters),
                reflex_policy: Ok(value.reflex_policy),
                render_material: Ok(value.render_material),
                secure_sub_session: Ok(value.secure_sub_session),
                security: Ok(value.security),
                semantic_zoom: Ok(value.semantic_zoom),
                symbolic_handoff_policy: Ok(value.symbolic_handoff_policy),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitiveCritiqueProfile {
        epistemic_penalty_scalar: ::std::result::Result<f64, ::std::string::String>,
        logical_flaw_embedding: ::std::result::Result<
            ::std::option::Option<super::VectorEmbeddingState>,
            ::std::string::String,
        >,
        reasoning_trace_hash:
            ::std::result::Result<super::ReasoningTraceHash, ::std::string::String>,
    }
    impl ::std::default::Default for CognitiveCritiqueProfile {
        fn default() -> Self {
            Self {
                epistemic_penalty_scalar: Err(
                    "no value supplied for epistemic_penalty_scalar".to_string()
                ),
                logical_flaw_embedding: Ok(Default::default()),
                reasoning_trace_hash: Err("no value supplied for reasoning_trace_hash".to_string()),
            }
        }
    }
    impl CognitiveCritiqueProfile {
        pub fn epistemic_penalty_scalar<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_penalty_scalar = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_penalty_scalar: {e}")
            });
            self
        }
        pub fn logical_flaw_embedding<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VectorEmbeddingState>>,
            T::Error: ::std::fmt::Display,
        {
            self.logical_flaw_embedding = value.try_into().map_err(|e| {
                format!("error converting supplied value for logical_flaw_embedding: {e}")
            });
            self
        }
        pub fn reasoning_trace_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ReasoningTraceHash>,
            T::Error: ::std::fmt::Display,
        {
            self.reasoning_trace_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for reasoning_trace_hash: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<CognitiveCritiqueProfile> for super::CognitiveCritiqueProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitiveCritiqueProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                epistemic_penalty_scalar: value.epistemic_penalty_scalar?,
                logical_flaw_embedding: value.logical_flaw_embedding?,
                reasoning_trace_hash: value.reasoning_trace_hash?,
            })
        }
    }
    impl ::std::convert::From<super::CognitiveCritiqueProfile> for CognitiveCritiqueProfile {
        fn from(value: super::CognitiveCritiqueProfile) -> Self {
            Self {
                epistemic_penalty_scalar: Ok(value.epistemic_penalty_scalar),
                logical_flaw_embedding: Ok(value.logical_flaw_embedding),
                reasoning_trace_hash: Ok(value.reasoning_trace_hash),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitiveDetailedBalanceContract {
        flow_estimation_matrix:
            ::std::result::Result<super::FlowEstimationMatrix, ::std::string::String>,
        local_exploration_k: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        target_balance_epsilon: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for CognitiveDetailedBalanceContract {
        fn default() -> Self {
            Self {
                flow_estimation_matrix: Err(
                    "no value supplied for flow_estimation_matrix".to_string()
                ),
                local_exploration_k: Err("no value supplied for local_exploration_k".to_string()),
                target_balance_epsilon: Err(
                    "no value supplied for target_balance_epsilon".to_string()
                ),
            }
        }
    }
    impl CognitiveDetailedBalanceContract {
        pub fn flow_estimation_matrix<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FlowEstimationMatrix>,
            T::Error: ::std::fmt::Display,
        {
            self.flow_estimation_matrix = value.try_into().map_err(|e| {
                format!("error converting supplied value for flow_estimation_matrix: {e}")
            });
            self
        }
        pub fn local_exploration_k<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.local_exploration_k = value.try_into().map_err(|e| {
                format!("error converting supplied value for local_exploration_k: {e}")
            });
            self
        }
        pub fn target_balance_epsilon<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.target_balance_epsilon = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_balance_epsilon: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<CognitiveDetailedBalanceContract>
        for super::CognitiveDetailedBalanceContract
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitiveDetailedBalanceContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                flow_estimation_matrix: value.flow_estimation_matrix?,
                local_exploration_k: value.local_exploration_k?,
                target_balance_epsilon: value.target_balance_epsilon?,
            })
        }
    }
    impl ::std::convert::From<super::CognitiveDetailedBalanceContract>
        for CognitiveDetailedBalanceContract
    {
        fn from(value: super::CognitiveDetailedBalanceContract) -> Self {
            Self {
                flow_estimation_matrix: Ok(value.flow_estimation_matrix),
                local_exploration_k: Ok(value.local_exploration_k),
                target_balance_epsilon: Ok(value.target_balance_epsilon),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitiveDualVerificationReceipt {
        primary_verifier_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        secondary_verifier_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        trace_factual_alignment: ::std::result::Result<bool, ::std::string::String>,
    }
    impl ::std::default::Default for CognitiveDualVerificationReceipt {
        fn default() -> Self {
            Self {
                primary_verifier_cid: Err("no value supplied for primary_verifier_cid".to_string()),
                secondary_verifier_cid: Err(
                    "no value supplied for secondary_verifier_cid".to_string()
                ),
                trace_factual_alignment: Err(
                    "no value supplied for trace_factual_alignment".to_string()
                ),
            }
        }
    }
    impl CognitiveDualVerificationReceipt {
        pub fn primary_verifier_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.primary_verifier_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for primary_verifier_cid: {e}")
            });
            self
        }
        pub fn secondary_verifier_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.secondary_verifier_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for secondary_verifier_cid: {e}")
            });
            self
        }
        pub fn trace_factual_alignment<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.trace_factual_alignment = value.try_into().map_err(|e| {
                format!("error converting supplied value for trace_factual_alignment: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<CognitiveDualVerificationReceipt>
        for super::CognitiveDualVerificationReceipt
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitiveDualVerificationReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                primary_verifier_cid: value.primary_verifier_cid?,
                secondary_verifier_cid: value.secondary_verifier_cid?,
                trace_factual_alignment: value.trace_factual_alignment?,
            })
        }
    }
    impl ::std::convert::From<super::CognitiveDualVerificationReceipt>
        for CognitiveDualVerificationReceipt
    {
        fn from(value: super::CognitiveDualVerificationReceipt) -> Self {
            Self {
                primary_verifier_cid: Ok(value.primary_verifier_cid),
                secondary_verifier_cid: Ok(value.secondary_verifier_cid),
                trace_factual_alignment: Ok(value.trace_factual_alignment),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitiveHumanNodeProfile {
        active_attention_ray: ::std::result::Result<
            ::std::option::Option<super::EpistemicAttentionState>,
            ::std::string::String,
        >,
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        description: ::std::result::Result<super::Description, ::std::string::String>,
        domain_extensions: ::std::result::Result<
            ::std::option::Option<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            ::std::string::String,
        >,
        intervention_policies: ::std::result::Result<
            ::std::vec::Vec<super::InterventionPolicy>,
            ::std::string::String,
        >,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        markov_blanket: ::std::result::Result<
            ::std::option::Option<super::MarkovBlanketRenderingPolicy>,
            ::std::string::String,
        >,
        render_material: ::std::result::Result<
            ::std::option::Option<super::SpatialRenderMaterial>,
            ::std::string::String,
        >,
        required_attestation:
            ::std::result::Result<super::RequiredAttestation, ::std::string::String>,
        semantic_zoom: ::std::result::Result<
            ::std::option::Option<super::SemanticZoomProfile>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CognitiveHumanNodeProfile {
        fn default() -> Self {
            Self {
                active_attention_ray: Ok(Default::default()),
                architectural_intent: Ok(Default::default()),
                description: Err("no value supplied for description".to_string()),
                domain_extensions: Ok(Default::default()),
                intervention_policies: Ok(Default::default()),
                justification: Ok(Default::default()),
                markov_blanket: Ok(Default::default()),
                render_material: Ok(Default::default()),
                required_attestation: Err("no value supplied for required_attestation".to_string()),
                semantic_zoom: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl CognitiveHumanNodeProfile {
        pub fn active_attention_ray<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicAttentionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.active_attention_ray = value.try_into().map_err(|e| {
                format!("error converting supplied value for active_attention_ray: {e}")
            });
            self
        }
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn description<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Description>,
            T::Error: ::std::fmt::Display,
        {
            self.description = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for description: {e}"));
            self
        }
        pub fn domain_extensions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.domain_extensions = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for domain_extensions: {e}"));
            self
        }
        pub fn intervention_policies<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::InterventionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.intervention_policies = value.try_into().map_err(|e| {
                format!("error converting supplied value for intervention_policies: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn markov_blanket<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MarkovBlanketRenderingPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.markov_blanket = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for markov_blanket: {e}"));
            self
        }
        pub fn render_material<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialRenderMaterial>>,
            T::Error: ::std::fmt::Display,
        {
            self.render_material = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for render_material: {e}"));
            self
        }
        pub fn required_attestation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RequiredAttestation>,
            T::Error: ::std::fmt::Display,
        {
            self.required_attestation = value.try_into().map_err(|e| {
                format!("error converting supplied value for required_attestation: {e}")
            });
            self
        }
        pub fn semantic_zoom<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticZoomProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_zoom = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_zoom: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CognitiveHumanNodeProfile> for super::CognitiveHumanNodeProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitiveHumanNodeProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                active_attention_ray: value.active_attention_ray?,
                architectural_intent: value.architectural_intent?,
                description: value.description?,
                domain_extensions: value.domain_extensions?,
                intervention_policies: value.intervention_policies?,
                justification: value.justification?,
                markov_blanket: value.markov_blanket?,
                render_material: value.render_material?,
                required_attestation: value.required_attestation?,
                semantic_zoom: value.semantic_zoom?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::CognitiveHumanNodeProfile> for CognitiveHumanNodeProfile {
        fn from(value: super::CognitiveHumanNodeProfile) -> Self {
            Self {
                active_attention_ray: Ok(value.active_attention_ray),
                architectural_intent: Ok(value.architectural_intent),
                description: Ok(value.description),
                domain_extensions: Ok(value.domain_extensions),
                intervention_policies: Ok(value.intervention_policies),
                justification: Ok(value.justification),
                markov_blanket: Ok(value.markov_blanket),
                render_material: Ok(value.render_material),
                required_attestation: Ok(value.required_attestation),
                semantic_zoom: Ok(value.semantic_zoom),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitivePredictionReceipt {
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        predicted_top_k_tokens: ::std::result::Result<
            ::std::vec::Vec<super::PredictedTopKTokensItem>,
            ::std::string::String,
        >,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        source_chain_cid: ::std::result::Result<super::SourceChainCid, ::std::string::String>,
        target_source_concept:
            ::std::result::Result<super::TargetSourceConcept, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CognitivePredictionReceipt {
        fn default() -> Self {
            Self {
                event_cid: Err("no value supplied for event_cid".to_string()),
                predicted_top_k_tokens: Err(
                    "no value supplied for predicted_top_k_tokens".to_string()
                ),
                prior_event_hash: Ok(Default::default()),
                source_chain_cid: Err("no value supplied for source_chain_cid".to_string()),
                target_source_concept: Err(
                    "no value supplied for target_source_concept".to_string()
                ),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl CognitivePredictionReceipt {
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn predicted_top_k_tokens<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::PredictedTopKTokensItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.predicted_top_k_tokens = value.try_into().map_err(|e| {
                format!("error converting supplied value for predicted_top_k_tokens: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn source_chain_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceChainCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_chain_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_chain_cid: {e}"));
            self
        }
        pub fn target_source_concept<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetSourceConcept>,
            T::Error: ::std::fmt::Display,
        {
            self.target_source_concept = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_source_concept: {e}")
            });
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CognitivePredictionReceipt> for super::CognitivePredictionReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitivePredictionReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                event_cid: value.event_cid?,
                predicted_top_k_tokens: value.predicted_top_k_tokens?,
                prior_event_hash: value.prior_event_hash?,
                source_chain_cid: value.source_chain_cid?,
                target_source_concept: value.target_source_concept?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::CognitivePredictionReceipt> for CognitivePredictionReceipt {
        fn from(value: super::CognitivePredictionReceipt) -> Self {
            Self {
                event_cid: Ok(value.event_cid),
                predicted_top_k_tokens: Ok(value.predicted_top_k_tokens),
                prior_event_hash: Ok(value.prior_event_hash),
                source_chain_cid: Ok(value.source_chain_cid),
                target_source_concept: Ok(value.target_source_concept),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitiveReasoningTraceState {
        source_proof_cid: ::std::result::Result<super::SourceProofCid, ::std::string::String>,
        token_length: ::std::result::Result<u64, ::std::string::String>,
        trace_cid: ::std::result::Result<super::TraceCid, ::std::string::String>,
        trace_payload: ::std::result::Result<super::TracePayload, ::std::string::String>,
    }
    impl ::std::default::Default for CognitiveReasoningTraceState {
        fn default() -> Self {
            Self {
                source_proof_cid: Err("no value supplied for source_proof_cid".to_string()),
                token_length: Err("no value supplied for token_length".to_string()),
                trace_cid: Err("no value supplied for trace_cid".to_string()),
                trace_payload: Err("no value supplied for trace_payload".to_string()),
            }
        }
    }
    impl CognitiveReasoningTraceState {
        pub fn source_proof_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceProofCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_proof_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_proof_cid: {e}"));
            self
        }
        pub fn token_length<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.token_length = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for token_length: {e}"));
            self
        }
        pub fn trace_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TraceCid>,
            T::Error: ::std::fmt::Display,
        {
            self.trace_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for trace_cid: {e}"));
            self
        }
        pub fn trace_payload<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TracePayload>,
            T::Error: ::std::fmt::Display,
        {
            self.trace_payload = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for trace_payload: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CognitiveReasoningTraceState> for super::CognitiveReasoningTraceState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitiveReasoningTraceState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                source_proof_cid: value.source_proof_cid?,
                token_length: value.token_length?,
                trace_cid: value.trace_cid?,
                trace_payload: value.trace_payload?,
            })
        }
    }
    impl ::std::convert::From<super::CognitiveReasoningTraceState> for CognitiveReasoningTraceState {
        fn from(value: super::CognitiveReasoningTraceState) -> Self {
            Self {
                source_proof_cid: Ok(value.source_proof_cid),
                token_length: Ok(value.token_length),
                trace_cid: Ok(value.trace_cid),
                trace_payload: Ok(value.trace_payload),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitiveRoutingContract {
        dynamic_top_k: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        enforce_functional_isolation:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        expert_logit_biases: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, f64>,
            ::std::string::String,
        >,
        routing_temperature: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for CognitiveRoutingContract {
        fn default() -> Self {
            Self {
                dynamic_top_k: Err("no value supplied for dynamic_top_k".to_string()),
                enforce_functional_isolation: Ok(Default::default()),
                expert_logit_biases: Ok(Default::default()),
                routing_temperature: Err("no value supplied for routing_temperature".to_string()),
            }
        }
    }
    impl CognitiveRoutingContract {
        pub fn dynamic_top_k<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.dynamic_top_k = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for dynamic_top_k: {e}"));
            self
        }
        pub fn enforce_functional_isolation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.enforce_functional_isolation = value.try_into().map_err(|e| {
                format!("error converting supplied value for enforce_functional_isolation: {e}")
            });
            self
        }
        pub fn expert_logit_biases<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::collections::HashMap<::std::string::String, f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.expert_logit_biases = value.try_into().map_err(|e| {
                format!("error converting supplied value for expert_logit_biases: {e}")
            });
            self
        }
        pub fn routing_temperature<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.routing_temperature = value.try_into().map_err(|e| {
                format!("error converting supplied value for routing_temperature: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<CognitiveRoutingContract> for super::CognitiveRoutingContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitiveRoutingContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                dynamic_top_k: value.dynamic_top_k?,
                enforce_functional_isolation: value.enforce_functional_isolation?,
                expert_logit_biases: value.expert_logit_biases?,
                routing_temperature: value.routing_temperature?,
            })
        }
    }
    impl ::std::convert::From<super::CognitiveRoutingContract> for CognitiveRoutingContract {
        fn from(value: super::CognitiveRoutingContract) -> Self {
            Self {
                dynamic_top_k: Ok(value.dynamic_top_k),
                enforce_functional_isolation: Ok(value.enforce_functional_isolation),
                expert_logit_biases: Ok(value.expert_logit_biases),
                routing_temperature: Ok(value.routing_temperature),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitiveSamplingPolicy {
        inverse_frequency_smoothing_epsilon:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        max_complexity_hops: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for CognitiveSamplingPolicy {
        fn default() -> Self {
            Self {
                inverse_frequency_smoothing_epsilon: Ok(Default::default()),
                max_complexity_hops: Err("no value supplied for max_complexity_hops".to_string()),
            }
        }
    }
    impl CognitiveSamplingPolicy {
        pub fn inverse_frequency_smoothing_epsilon<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.inverse_frequency_smoothing_epsilon = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for inverse_frequency_smoothing_epsilon: {e}"
                )
            });
            self
        }
        pub fn max_complexity_hops<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_complexity_hops = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_complexity_hops: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<CognitiveSamplingPolicy> for super::CognitiveSamplingPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitiveSamplingPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                inverse_frequency_smoothing_epsilon: value.inverse_frequency_smoothing_epsilon?,
                max_complexity_hops: value.max_complexity_hops?,
            })
        }
    }
    impl ::std::convert::From<super::CognitiveSamplingPolicy> for CognitiveSamplingPolicy {
        fn from(value: super::CognitiveSamplingPolicy) -> Self {
            Self {
                inverse_frequency_smoothing_epsilon: Ok(value.inverse_frequency_smoothing_epsilon),
                max_complexity_hops: Ok(value.max_complexity_hops),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitiveStateProfile {
        activation_steering: ::std::result::Result<
            ::std::option::Option<super::ActivationSteeringContract>,
            ::std::string::String,
        >,
        caution_index: ::std::result::Result<f64, ::std::string::String>,
        divergence_tolerance: ::std::result::Result<f64, ::std::string::String>,
        moe_routing_directive: ::std::result::Result<
            ::std::option::Option<super::CognitiveRoutingContract>,
            ::std::string::String,
        >,
        semantic_slicing: ::std::result::Result<
            ::std::option::Option<super::SemanticSlicingPolicy>,
            ::std::string::String,
        >,
        urgency_index: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for CognitiveStateProfile {
        fn default() -> Self {
            Self {
                activation_steering: Ok(Default::default()),
                caution_index: Err("no value supplied for caution_index".to_string()),
                divergence_tolerance: Err("no value supplied for divergence_tolerance".to_string()),
                moe_routing_directive: Ok(Default::default()),
                semantic_slicing: Ok(Default::default()),
                urgency_index: Err("no value supplied for urgency_index".to_string()),
            }
        }
    }
    impl CognitiveStateProfile {
        pub fn activation_steering<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ActivationSteeringContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.activation_steering = value.try_into().map_err(|e| {
                format!("error converting supplied value for activation_steering: {e}")
            });
            self
        }
        pub fn caution_index<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.caution_index = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for caution_index: {e}"));
            self
        }
        pub fn divergence_tolerance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.divergence_tolerance = value.try_into().map_err(|e| {
                format!("error converting supplied value for divergence_tolerance: {e}")
            });
            self
        }
        pub fn moe_routing_directive<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveRoutingContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.moe_routing_directive = value.try_into().map_err(|e| {
                format!("error converting supplied value for moe_routing_directive: {e}")
            });
            self
        }
        pub fn semantic_slicing<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticSlicingPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_slicing = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_slicing: {e}"));
            self
        }
        pub fn urgency_index<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.urgency_index = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for urgency_index: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CognitiveStateProfile> for super::CognitiveStateProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitiveStateProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                activation_steering: value.activation_steering?,
                caution_index: value.caution_index?,
                divergence_tolerance: value.divergence_tolerance?,
                moe_routing_directive: value.moe_routing_directive?,
                semantic_slicing: value.semantic_slicing?,
                urgency_index: value.urgency_index?,
            })
        }
    }
    impl ::std::convert::From<super::CognitiveStateProfile> for CognitiveStateProfile {
        fn from(value: super::CognitiveStateProfile) -> Self {
            Self {
                activation_steering: Ok(value.activation_steering),
                caution_index: Ok(value.caution_index),
                divergence_tolerance: Ok(value.divergence_tolerance),
                moe_routing_directive: Ok(value.moe_routing_directive),
                semantic_slicing: Ok(value.semantic_slicing),
                urgency_index: Ok(value.urgency_index),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitiveSwarmDeploymentManifest {
        agent_node_count: ::std::result::Result<i64, ::std::string::String>,
        consensus_mechanism:
            ::std::result::Result<super::ConsensusMechanism, ::std::string::String>,
        swarm_objective_prompt: ::std::result::Result<::std::string::String, ::std::string::String>,
    }
    impl ::std::default::Default for CognitiveSwarmDeploymentManifest {
        fn default() -> Self {
            Self {
                agent_node_count: Err("no value supplied for agent_node_count".to_string()),
                consensus_mechanism: Err("no value supplied for consensus_mechanism".to_string()),
                swarm_objective_prompt: Err(
                    "no value supplied for swarm_objective_prompt".to_string()
                ),
            }
        }
    }
    impl CognitiveSwarmDeploymentManifest {
        pub fn agent_node_count<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<i64>,
            T::Error: ::std::fmt::Display,
        {
            self.agent_node_count = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for agent_node_count: {e}"));
            self
        }
        pub fn consensus_mechanism<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ConsensusMechanism>,
            T::Error: ::std::fmt::Display,
        {
            self.consensus_mechanism = value.try_into().map_err(|e| {
                format!("error converting supplied value for consensus_mechanism: {e}")
            });
            self
        }
        pub fn swarm_objective_prompt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.swarm_objective_prompt = value.try_into().map_err(|e| {
                format!("error converting supplied value for swarm_objective_prompt: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<CognitiveSwarmDeploymentManifest>
        for super::CognitiveSwarmDeploymentManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitiveSwarmDeploymentManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                agent_node_count: value.agent_node_count?,
                consensus_mechanism: value.consensus_mechanism?,
                swarm_objective_prompt: value.swarm_objective_prompt?,
            })
        }
    }
    impl ::std::convert::From<super::CognitiveSwarmDeploymentManifest>
        for CognitiveSwarmDeploymentManifest
    {
        fn from(value: super::CognitiveSwarmDeploymentManifest) -> Self {
            Self {
                agent_node_count: Ok(value.agent_node_count),
                consensus_mechanism: Ok(value.consensus_mechanism),
                swarm_objective_prompt: Ok(value.swarm_objective_prompt),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitiveSystemNodeProfile {
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        asymptotic_complexity: ::std::result::Result<
            ::std::option::Option<super::AsymptoticComplexityReceipt>,
            ::std::string::String,
        >,
        description: ::std::result::Result<super::Description, ::std::string::String>,
        domain_extensions: ::std::result::Result<
            ::std::option::Option<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            ::std::string::String,
        >,
        execution_substrate: ::std::result::Result<
            ::std::option::Option<super::ExecutionSubstrateProfile>,
            ::std::string::String,
        >,
        hoare_proof: ::std::result::Result<
            ::std::option::Option<super::HoareLogicProofReceipt>,
            ::std::string::String,
        >,
        intervention_policies: ::std::result::Result<
            ::std::vec::Vec<super::InterventionPolicy>,
            ::std::string::String,
        >,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        markov_blanket: ::std::result::Result<
            ::std::option::Option<super::MarkovBlanketRenderingPolicy>,
            ::std::string::String,
        >,
        render_material: ::std::result::Result<
            ::std::option::Option<super::SpatialRenderMaterial>,
            ::std::string::String,
        >,
        semantic_zoom: ::std::result::Result<
            ::std::option::Option<super::SemanticZoomProfile>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CognitiveSystemNodeProfile {
        fn default() -> Self {
            Self {
                architectural_intent: Ok(Default::default()),
                asymptotic_complexity: Ok(Default::default()),
                description: Err("no value supplied for description".to_string()),
                domain_extensions: Ok(Default::default()),
                execution_substrate: Ok(Default::default()),
                hoare_proof: Ok(Default::default()),
                intervention_policies: Ok(Default::default()),
                justification: Ok(Default::default()),
                markov_blanket: Ok(Default::default()),
                render_material: Ok(Default::default()),
                semantic_zoom: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl CognitiveSystemNodeProfile {
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn asymptotic_complexity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AsymptoticComplexityReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.asymptotic_complexity = value.try_into().map_err(|e| {
                format!("error converting supplied value for asymptotic_complexity: {e}")
            });
            self
        }
        pub fn description<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Description>,
            T::Error: ::std::fmt::Display,
        {
            self.description = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for description: {e}"));
            self
        }
        pub fn domain_extensions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.domain_extensions = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for domain_extensions: {e}"));
            self
        }
        pub fn execution_substrate<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ExecutionSubstrateProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.execution_substrate = value.try_into().map_err(|e| {
                format!("error converting supplied value for execution_substrate: {e}")
            });
            self
        }
        pub fn hoare_proof<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HoareLogicProofReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.hoare_proof = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for hoare_proof: {e}"));
            self
        }
        pub fn intervention_policies<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::InterventionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.intervention_policies = value.try_into().map_err(|e| {
                format!("error converting supplied value for intervention_policies: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn markov_blanket<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MarkovBlanketRenderingPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.markov_blanket = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for markov_blanket: {e}"));
            self
        }
        pub fn render_material<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialRenderMaterial>>,
            T::Error: ::std::fmt::Display,
        {
            self.render_material = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for render_material: {e}"));
            self
        }
        pub fn semantic_zoom<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticZoomProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_zoom = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_zoom: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CognitiveSystemNodeProfile> for super::CognitiveSystemNodeProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitiveSystemNodeProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                architectural_intent: value.architectural_intent?,
                asymptotic_complexity: value.asymptotic_complexity?,
                description: value.description?,
                domain_extensions: value.domain_extensions?,
                execution_substrate: value.execution_substrate?,
                hoare_proof: value.hoare_proof?,
                intervention_policies: value.intervention_policies?,
                justification: value.justification?,
                markov_blanket: value.markov_blanket?,
                render_material: value.render_material?,
                semantic_zoom: value.semantic_zoom?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::CognitiveSystemNodeProfile> for CognitiveSystemNodeProfile {
        fn from(value: super::CognitiveSystemNodeProfile) -> Self {
            Self {
                architectural_intent: Ok(value.architectural_intent),
                asymptotic_complexity: Ok(value.asymptotic_complexity),
                description: Ok(value.description),
                domain_extensions: Ok(value.domain_extensions),
                execution_substrate: Ok(value.execution_substrate),
                hoare_proof: Ok(value.hoare_proof),
                intervention_policies: Ok(value.intervention_policies),
                justification: Ok(value.justification),
                markov_blanket: Ok(value.markov_blanket),
                render_material: Ok(value.render_material),
                semantic_zoom: Ok(value.semantic_zoom),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CognitiveUncertaintyProfile {
        aleatoric_noise_ratio: ::std::result::Result<f64, ::std::string::String>,
        epistemic_knowledge_gap: ::std::result::Result<f64, ::std::string::String>,
        requires_abductive_escalation: ::std::result::Result<bool, ::std::string::String>,
        semantic_consistency_score: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for CognitiveUncertaintyProfile {
        fn default() -> Self {
            Self {
                aleatoric_noise_ratio: Err(
                    "no value supplied for aleatoric_noise_ratio".to_string()
                ),
                epistemic_knowledge_gap: Err(
                    "no value supplied for epistemic_knowledge_gap".to_string()
                ),
                requires_abductive_escalation: Err(
                    "no value supplied for requires_abductive_escalation".to_string(),
                ),
                semantic_consistency_score: Err(
                    "no value supplied for semantic_consistency_score".to_string()
                ),
            }
        }
    }
    impl CognitiveUncertaintyProfile {
        pub fn aleatoric_noise_ratio<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.aleatoric_noise_ratio = value.try_into().map_err(|e| {
                format!("error converting supplied value for aleatoric_noise_ratio: {e}")
            });
            self
        }
        pub fn epistemic_knowledge_gap<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_knowledge_gap = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_knowledge_gap: {e}")
            });
            self
        }
        pub fn requires_abductive_escalation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.requires_abductive_escalation = value.try_into().map_err(|e| {
                format!("error converting supplied value for requires_abductive_escalation: {e}")
            });
            self
        }
        pub fn semantic_consistency_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_consistency_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for semantic_consistency_score: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<CognitiveUncertaintyProfile> for super::CognitiveUncertaintyProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CognitiveUncertaintyProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                aleatoric_noise_ratio: value.aleatoric_noise_ratio?,
                epistemic_knowledge_gap: value.epistemic_knowledge_gap?,
                requires_abductive_escalation: value.requires_abductive_escalation?,
                semantic_consistency_score: value.semantic_consistency_score?,
            })
        }
    }
    impl ::std::convert::From<super::CognitiveUncertaintyProfile> for CognitiveUncertaintyProfile {
        fn from(value: super::CognitiveUncertaintyProfile) -> Self {
            Self {
                aleatoric_noise_ratio: Ok(value.aleatoric_noise_ratio),
                epistemic_knowledge_gap: Ok(value.epistemic_knowledge_gap),
                requires_abductive_escalation: Ok(value.requires_abductive_escalation),
                semantic_consistency_score: Ok(value.semantic_consistency_score),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CollectiveIntelligenceProfile {
        coordination_score: ::std::result::Result<f64, ::std::string::String>,
        information_integration: ::std::result::Result<f64, ::std::string::String>,
        synergy_index: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for CollectiveIntelligenceProfile {
        fn default() -> Self {
            Self {
                coordination_score: Err("no value supplied for coordination_score".to_string()),
                information_integration: Err(
                    "no value supplied for information_integration".to_string()
                ),
                synergy_index: Err("no value supplied for synergy_index".to_string()),
            }
        }
    }
    impl CollectiveIntelligenceProfile {
        pub fn coordination_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.coordination_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for coordination_score: {e}")
            });
            self
        }
        pub fn information_integration<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.information_integration = value.try_into().map_err(|e| {
                format!("error converting supplied value for information_integration: {e}")
            });
            self
        }
        pub fn synergy_index<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.synergy_index = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for synergy_index: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CollectiveIntelligenceProfile>
        for super::CollectiveIntelligenceProfile
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CollectiveIntelligenceProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                coordination_score: value.coordination_score?,
                information_integration: value.information_integration?,
                synergy_index: value.synergy_index?,
            })
        }
    }
    impl ::std::convert::From<super::CollectiveIntelligenceProfile> for CollectiveIntelligenceProfile {
        fn from(value: super::CollectiveIntelligenceProfile) -> Self {
            Self {
                coordination_score: Ok(value.coordination_score),
                information_integration: Ok(value.information_integration),
                synergy_index: Ok(value.synergy_index),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CompositeNodeProfile {
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        description: ::std::result::Result<super::Description, ::std::string::String>,
        domain_extensions: ::std::result::Result<
            ::std::option::Option<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            ::std::string::String,
        >,
        input_mappings: ::std::result::Result<
            ::std::vec::Vec<super::InputMappingContract>,
            ::std::string::String,
        >,
        intervention_policies: ::std::result::Result<
            ::std::vec::Vec<super::InterventionPolicy>,
            ::std::string::String,
        >,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        markov_blanket: ::std::result::Result<
            ::std::option::Option<super::MarkovBlanketRenderingPolicy>,
            ::std::string::String,
        >,
        output_mappings: ::std::result::Result<
            ::std::vec::Vec<super::OutputMappingContract>,
            ::std::string::String,
        >,
        render_material: ::std::result::Result<
            ::std::option::Option<super::SpatialRenderMaterial>,
            ::std::string::String,
        >,
        semantic_zoom: ::std::result::Result<
            ::std::option::Option<super::SemanticZoomProfile>,
            ::std::string::String,
        >,
        topology: ::std::result::Result<super::AnyTopologyManifest, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CompositeNodeProfile {
        fn default() -> Self {
            Self {
                architectural_intent: Ok(Default::default()),
                description: Err("no value supplied for description".to_string()),
                domain_extensions: Ok(Default::default()),
                input_mappings: Ok(Default::default()),
                intervention_policies: Ok(Default::default()),
                justification: Ok(Default::default()),
                markov_blanket: Ok(Default::default()),
                output_mappings: Ok(Default::default()),
                render_material: Ok(Default::default()),
                semantic_zoom: Ok(Default::default()),
                topology: Err("no value supplied for topology".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl CompositeNodeProfile {
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn description<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Description>,
            T::Error: ::std::fmt::Display,
        {
            self.description = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for description: {e}"));
            self
        }
        pub fn domain_extensions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.domain_extensions = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for domain_extensions: {e}"));
            self
        }
        pub fn input_mappings<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::InputMappingContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.input_mappings = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for input_mappings: {e}"));
            self
        }
        pub fn intervention_policies<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::InterventionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.intervention_policies = value.try_into().map_err(|e| {
                format!("error converting supplied value for intervention_policies: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn markov_blanket<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MarkovBlanketRenderingPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.markov_blanket = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for markov_blanket: {e}"));
            self
        }
        pub fn output_mappings<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::OutputMappingContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.output_mappings = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for output_mappings: {e}"));
            self
        }
        pub fn render_material<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialRenderMaterial>>,
            T::Error: ::std::fmt::Display,
        {
            self.render_material = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for render_material: {e}"));
            self
        }
        pub fn semantic_zoom<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticZoomProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_zoom = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_zoom: {e}"));
            self
        }
        pub fn topology<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AnyTopologyManifest>,
            T::Error: ::std::fmt::Display,
        {
            self.topology = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CompositeNodeProfile> for super::CompositeNodeProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CompositeNodeProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                architectural_intent: value.architectural_intent?,
                description: value.description?,
                domain_extensions: value.domain_extensions?,
                input_mappings: value.input_mappings?,
                intervention_policies: value.intervention_policies?,
                justification: value.justification?,
                markov_blanket: value.markov_blanket?,
                output_mappings: value.output_mappings?,
                render_material: value.render_material?,
                semantic_zoom: value.semantic_zoom?,
                topology: value.topology?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::CompositeNodeProfile> for CompositeNodeProfile {
        fn from(value: super::CompositeNodeProfile) -> Self {
            Self {
                architectural_intent: Ok(value.architectural_intent),
                description: Ok(value.description),
                domain_extensions: Ok(value.domain_extensions),
                input_mappings: Ok(value.input_mappings),
                intervention_policies: Ok(value.intervention_policies),
                justification: Ok(value.justification),
                markov_blanket: Ok(value.markov_blanket),
                output_mappings: Ok(value.output_mappings),
                render_material: Ok(value.render_material),
                semantic_zoom: Ok(value.semantic_zoom),
                topology: Ok(value.topology),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ComputeEngineProfile {
        capabilities:
            ::std::result::Result<::std::vec::Vec<super::CapabilitiesItem>, ::std::string::String>,
        context_window_size: ::std::result::Result<u64, ::std::string::String>,
        foundation_matrix_name:
            ::std::result::Result<super::FoundationMatrixName, ::std::string::String>,
        provider: ::std::result::Result<super::Provider, ::std::string::String>,
        rate_card: ::std::result::Result<super::ComputeRateContract, ::std::string::String>,
        supported_functional_experts: ::std::result::Result<
            ::std::vec::Vec<super::SupportedFunctionalExpertsItem>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for ComputeEngineProfile {
        fn default() -> Self {
            Self {
                capabilities: Err("no value supplied for capabilities".to_string()),
                context_window_size: Err("no value supplied for context_window_size".to_string()),
                foundation_matrix_name: Err(
                    "no value supplied for foundation_matrix_name".to_string()
                ),
                provider: Err("no value supplied for provider".to_string()),
                rate_card: Err("no value supplied for rate_card".to_string()),
                supported_functional_experts: Ok(Default::default()),
            }
        }
    }
    impl ComputeEngineProfile {
        pub fn capabilities<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::CapabilitiesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.capabilities = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for capabilities: {e}"));
            self
        }
        pub fn context_window_size<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.context_window_size = value.try_into().map_err(|e| {
                format!("error converting supplied value for context_window_size: {e}")
            });
            self
        }
        pub fn foundation_matrix_name<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FoundationMatrixName>,
            T::Error: ::std::fmt::Display,
        {
            self.foundation_matrix_name = value.try_into().map_err(|e| {
                format!("error converting supplied value for foundation_matrix_name: {e}")
            });
            self
        }
        pub fn provider<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Provider>,
            T::Error: ::std::fmt::Display,
        {
            self.provider = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for provider: {e}"));
            self
        }
        pub fn rate_card<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ComputeRateContract>,
            T::Error: ::std::fmt::Display,
        {
            self.rate_card = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for rate_card: {e}"));
            self
        }
        pub fn supported_functional_experts<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::SupportedFunctionalExpertsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.supported_functional_experts = value.try_into().map_err(|e| {
                format!("error converting supplied value for supported_functional_experts: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<ComputeEngineProfile> for super::ComputeEngineProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ComputeEngineProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                capabilities: value.capabilities?,
                context_window_size: value.context_window_size?,
                foundation_matrix_name: value.foundation_matrix_name?,
                provider: value.provider?,
                rate_card: value.rate_card?,
                supported_functional_experts: value.supported_functional_experts?,
            })
        }
    }
    impl ::std::convert::From<super::ComputeEngineProfile> for ComputeEngineProfile {
        fn from(value: super::ComputeEngineProfile) -> Self {
            Self {
                capabilities: Ok(value.capabilities),
                context_window_size: Ok(value.context_window_size),
                foundation_matrix_name: Ok(value.foundation_matrix_name),
                provider: Ok(value.provider),
                rate_card: Ok(value.rate_card),
                supported_functional_experts: Ok(value.supported_functional_experts),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ComputeProvisioningIntent {
        autostop_idle_minutes:
            ::std::result::Result<::std::option::Option<i64>, ::std::string::String>,
        hardware_profile: ::std::result::Result<
            ::std::option::Option<super::SpatialHardwareProfile>,
            ::std::string::String,
        >,
        max_budget: ::std::result::Result<u64, ::std::string::String>,
        provisioning_engine: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        qos_class: ::std::result::Result<
            ::std::option::Option<super::QoSClassificationProfile>,
            ::std::string::String,
        >,
        required_capabilities: ::std::result::Result<
            ::std::vec::Vec<super::RequiredCapabilitiesItem>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        use_spot: ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
    }
    impl ::std::default::Default for ComputeProvisioningIntent {
        fn default() -> Self {
            Self {
                autostop_idle_minutes: Ok(Default::default()),
                hardware_profile: Ok(Default::default()),
                max_budget: Err("no value supplied for max_budget".to_string()),
                provisioning_engine: Ok(Default::default()),
                qos_class: Ok(Default::default()),
                required_capabilities: Ok(Default::default()),
                topology_class: Ok(Default::default()),
                use_spot: Ok(Default::default()),
            }
        }
    }
    impl ComputeProvisioningIntent {
        pub fn autostop_idle_minutes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<i64>>,
            T::Error: ::std::fmt::Display,
        {
            self.autostop_idle_minutes = value.try_into().map_err(|e| {
                format!("error converting supplied value for autostop_idle_minutes: {e}")
            });
            self
        }
        pub fn hardware_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialHardwareProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.hardware_profile = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for hardware_profile: {e}"));
            self
        }
        pub fn max_budget<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_budget = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_budget: {e}"));
            self
        }
        pub fn provisioning_engine<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.provisioning_engine = value.try_into().map_err(|e| {
                format!("error converting supplied value for provisioning_engine: {e}")
            });
            self
        }
        pub fn qos_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::QoSClassificationProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.qos_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for qos_class: {e}"));
            self
        }
        pub fn required_capabilities<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::RequiredCapabilitiesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.required_capabilities = value.try_into().map_err(|e| {
                format!("error converting supplied value for required_capabilities: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn use_spot<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.use_spot = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for use_spot: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ComputeProvisioningIntent> for super::ComputeProvisioningIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ComputeProvisioningIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                autostop_idle_minutes: value.autostop_idle_minutes?,
                hardware_profile: value.hardware_profile?,
                max_budget: value.max_budget?,
                provisioning_engine: value.provisioning_engine?,
                qos_class: value.qos_class?,
                required_capabilities: value.required_capabilities?,
                topology_class: value.topology_class?,
                use_spot: value.use_spot?,
            })
        }
    }
    impl ::std::convert::From<super::ComputeProvisioningIntent> for ComputeProvisioningIntent {
        fn from(value: super::ComputeProvisioningIntent) -> Self {
            Self {
                autostop_idle_minutes: Ok(value.autostop_idle_minutes),
                hardware_profile: Ok(value.hardware_profile),
                max_budget: Ok(value.max_budget),
                provisioning_engine: Ok(value.provisioning_engine),
                qos_class: Ok(value.qos_class),
                required_capabilities: Ok(value.required_capabilities),
                topology_class: Ok(value.topology_class),
                use_spot: Ok(value.use_spot),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ComputeRateContract {
        cost_per_million_input_tokens: ::std::result::Result<u64, ::std::string::String>,
        cost_per_million_output_tokens: ::std::result::Result<u64, ::std::string::String>,
        magnitude_unit: ::std::result::Result<super::MagnitudeUnit, ::std::string::String>,
    }
    impl ::std::default::Default for ComputeRateContract {
        fn default() -> Self {
            Self {
                cost_per_million_input_tokens: Err(
                    "no value supplied for cost_per_million_input_tokens".to_string(),
                ),
                cost_per_million_output_tokens: Err(
                    "no value supplied for cost_per_million_output_tokens".to_string(),
                ),
                magnitude_unit: Err("no value supplied for magnitude_unit".to_string()),
            }
        }
    }
    impl ComputeRateContract {
        pub fn cost_per_million_input_tokens<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.cost_per_million_input_tokens = value.try_into().map_err(|e| {
                format!("error converting supplied value for cost_per_million_input_tokens: {e}")
            });
            self
        }
        pub fn cost_per_million_output_tokens<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.cost_per_million_output_tokens = value.try_into().map_err(|e| {
                format!("error converting supplied value for cost_per_million_output_tokens: {e}")
            });
            self
        }
        pub fn magnitude_unit<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MagnitudeUnit>,
            T::Error: ::std::fmt::Display,
        {
            self.magnitude_unit = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for magnitude_unit: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ComputeRateContract> for super::ComputeRateContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ComputeRateContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                cost_per_million_input_tokens: value.cost_per_million_input_tokens?,
                cost_per_million_output_tokens: value.cost_per_million_output_tokens?,
                magnitude_unit: value.magnitude_unit?,
            })
        }
    }
    impl ::std::convert::From<super::ComputeRateContract> for ComputeRateContract {
        fn from(value: super::ComputeRateContract) -> Self {
            Self {
                cost_per_million_input_tokens: Ok(value.cost_per_million_input_tokens),
                cost_per_million_output_tokens: Ok(value.cost_per_million_output_tokens),
                magnitude_unit: Ok(value.magnitude_unit),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ConsensusFederationTopologyManifest {
        adjudicator_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        participant_cids:
            ::std::result::Result<::std::vec::Vec<super::NodeCidState>, ::std::string::String>,
        quorum_rules: ::std::result::Result<super::QuorumPolicy, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for ConsensusFederationTopologyManifest {
        fn default() -> Self {
            Self {
                adjudicator_cid: Err("no value supplied for adjudicator_cid".to_string()),
                participant_cids: Err("no value supplied for participant_cids".to_string()),
                quorum_rules: Err("no value supplied for quorum_rules".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl ConsensusFederationTopologyManifest {
        pub fn adjudicator_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.adjudicator_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for adjudicator_cid: {e}"));
            self
        }
        pub fn participant_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.participant_cids = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for participant_cids: {e}"));
            self
        }
        pub fn quorum_rules<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::QuorumPolicy>,
            T::Error: ::std::fmt::Display,
        {
            self.quorum_rules = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for quorum_rules: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ConsensusFederationTopologyManifest>
        for super::ConsensusFederationTopologyManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ConsensusFederationTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                adjudicator_cid: value.adjudicator_cid?,
                participant_cids: value.participant_cids?,
                quorum_rules: value.quorum_rules?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::ConsensusFederationTopologyManifest>
        for ConsensusFederationTopologyManifest
    {
        fn from(value: super::ConsensusFederationTopologyManifest) -> Self {
            Self {
                adjudicator_cid: Ok(value.adjudicator_cid),
                participant_cids: Ok(value.participant_cids),
                quorum_rules: Ok(value.quorum_rules),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ConsensusPolicy {
        max_debate_rounds: ::std::result::Result<::std::option::Option<u64>, ::std::string::String>,
        prediction_market_rules: ::std::result::Result<
            ::std::option::Option<super::PredictionMarketPolicy>,
            ::std::string::String,
        >,
        quorum_rules: ::std::result::Result<
            ::std::option::Option<super::QuorumPolicy>,
            ::std::string::String,
        >,
        strategy: ::std::result::Result<super::Strategy, ::std::string::String>,
        tie_breaker_node_cid: ::std::result::Result<
            ::std::option::Option<super::NodeCidState>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for ConsensusPolicy {
        fn default() -> Self {
            Self {
                max_debate_rounds: Ok(Default::default()),
                prediction_market_rules: Ok(Default::default()),
                quorum_rules: Ok(Default::default()),
                strategy: Err("no value supplied for strategy".to_string()),
                tie_breaker_node_cid: Ok(Default::default()),
            }
        }
    }
    impl ConsensusPolicy {
        pub fn max_debate_rounds<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_debate_rounds = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_debate_rounds: {e}"));
            self
        }
        pub fn prediction_market_rules<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::PredictionMarketPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.prediction_market_rules = value.try_into().map_err(|e| {
                format!("error converting supplied value for prediction_market_rules: {e}")
            });
            self
        }
        pub fn quorum_rules<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::QuorumPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.quorum_rules = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for quorum_rules: {e}"));
            self
        }
        pub fn strategy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Strategy>,
            T::Error: ::std::fmt::Display,
        {
            self.strategy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for strategy: {e}"));
            self
        }
        pub fn tie_breaker_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.tie_breaker_node_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for tie_breaker_node_cid: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<ConsensusPolicy> for super::ConsensusPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ConsensusPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_debate_rounds: value.max_debate_rounds?,
                prediction_market_rules: value.prediction_market_rules?,
                quorum_rules: value.quorum_rules?,
                strategy: value.strategy?,
                tie_breaker_node_cid: value.tie_breaker_node_cid?,
            })
        }
    }
    impl ::std::convert::From<super::ConsensusPolicy> for ConsensusPolicy {
        fn from(value: super::ConsensusPolicy) -> Self {
            Self {
                max_debate_rounds: Ok(value.max_debate_rounds),
                prediction_market_rules: Ok(value.prediction_market_rules),
                quorum_rules: Ok(value.quorum_rules),
                strategy: Ok(value.strategy),
                tie_breaker_node_cid: Ok(value.tie_breaker_node_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ConstitutionalAmendmentIntent {
        drift_event_cid: ::std::result::Result<super::DriftEventCid, ::std::string::String>,
        justification: ::std::result::Result<super::Justification, ::std::string::String>,
        proposed_patch: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for ConstitutionalAmendmentIntent {
        fn default() -> Self {
            Self {
                drift_event_cid: Err("no value supplied for drift_event_cid".to_string()),
                justification: Err("no value supplied for justification".to_string()),
                proposed_patch: Err("no value supplied for proposed_patch".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl ConstitutionalAmendmentIntent {
        pub fn drift_event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DriftEventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.drift_event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for drift_event_cid: {e}"));
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Justification>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn proposed_patch<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.proposed_patch = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proposed_patch: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ConstitutionalAmendmentIntent>
        for super::ConstitutionalAmendmentIntent
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ConstitutionalAmendmentIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                drift_event_cid: value.drift_event_cid?,
                justification: value.justification?,
                proposed_patch: value.proposed_patch?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::ConstitutionalAmendmentIntent> for ConstitutionalAmendmentIntent {
        fn from(value: super::ConstitutionalAmendmentIntent) -> Self {
            Self {
                drift_event_cid: Ok(value.drift_event_cid),
                justification: Ok(value.justification),
                proposed_patch: Ok(value.proposed_patch),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ConstrainedDecodingPolicy {
        compiler_backend: ::std::result::Result<super::CompilerBackend, ::std::string::String>,
        enforcement_strategy: ::std::result::Result<
            ::std::option::Option<super::EnforcementStrategy>,
            ::std::string::String,
        >,
        formal_grammar_string: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        terminate_on_eos_leak:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
    }
    impl ::std::default::Default for ConstrainedDecodingPolicy {
        fn default() -> Self {
            Self {
                compiler_backend: Err("no value supplied for compiler_backend".to_string()),
                enforcement_strategy: Ok(Default::default()),
                formal_grammar_string: Ok(Default::default()),
                terminate_on_eos_leak: Ok(Default::default()),
            }
        }
    }
    impl ConstrainedDecodingPolicy {
        pub fn compiler_backend<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CompilerBackend>,
            T::Error: ::std::fmt::Display,
        {
            self.compiler_backend = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for compiler_backend: {e}"));
            self
        }
        pub fn enforcement_strategy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EnforcementStrategy>>,
            T::Error: ::std::fmt::Display,
        {
            self.enforcement_strategy = value.try_into().map_err(|e| {
                format!("error converting supplied value for enforcement_strategy: {e}")
            });
            self
        }
        pub fn formal_grammar_string<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.formal_grammar_string = value.try_into().map_err(|e| {
                format!("error converting supplied value for formal_grammar_string: {e}")
            });
            self
        }
        pub fn terminate_on_eos_leak<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.terminate_on_eos_leak = value.try_into().map_err(|e| {
                format!("error converting supplied value for terminate_on_eos_leak: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<ConstrainedDecodingPolicy> for super::ConstrainedDecodingPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ConstrainedDecodingPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                compiler_backend: value.compiler_backend?,
                enforcement_strategy: value.enforcement_strategy?,
                formal_grammar_string: value.formal_grammar_string?,
                terminate_on_eos_leak: value.terminate_on_eos_leak?,
            })
        }
    }
    impl ::std::convert::From<super::ConstrainedDecodingPolicy> for ConstrainedDecodingPolicy {
        fn from(value: super::ConstrainedDecodingPolicy) -> Self {
            Self {
                compiler_backend: Ok(value.compiler_backend),
                enforcement_strategy: Ok(value.enforcement_strategy),
                formal_grammar_string: Ok(value.formal_grammar_string),
                terminate_on_eos_leak: Ok(value.terminate_on_eos_leak),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ContextExpansionPolicy {
        expansion_paradigm: ::std::result::Result<super::ExpansionParadigm, ::std::string::String>,
        max_token_budget: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        parent_merge_threshold:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        surrounding_sentences_k: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for ContextExpansionPolicy {
        fn default() -> Self {
            Self {
                expansion_paradigm: Err("no value supplied for expansion_paradigm".to_string()),
                max_token_budget: Err("no value supplied for max_token_budget".to_string()),
                parent_merge_threshold: Ok(Default::default()),
                surrounding_sentences_k: Ok(Default::default()),
            }
        }
    }
    impl ContextExpansionPolicy {
        pub fn expansion_paradigm<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ExpansionParadigm>,
            T::Error: ::std::fmt::Display,
        {
            self.expansion_paradigm = value.try_into().map_err(|e| {
                format!("error converting supplied value for expansion_paradigm: {e}")
            });
            self
        }
        pub fn max_token_budget<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_token_budget = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_token_budget: {e}"));
            self
        }
        pub fn parent_merge_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.parent_merge_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for parent_merge_threshold: {e}")
            });
            self
        }
        pub fn surrounding_sentences_k<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.surrounding_sentences_k = value.try_into().map_err(|e| {
                format!("error converting supplied value for surrounding_sentences_k: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<ContextExpansionPolicy> for super::ContextExpansionPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ContextExpansionPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                expansion_paradigm: value.expansion_paradigm?,
                max_token_budget: value.max_token_budget?,
                parent_merge_threshold: value.parent_merge_threshold?,
                surrounding_sentences_k: value.surrounding_sentences_k?,
            })
        }
    }
    impl ::std::convert::From<super::ContextExpansionPolicy> for ContextExpansionPolicy {
        fn from(value: super::ContextExpansionPolicy) -> Self {
            Self {
                expansion_paradigm: Ok(value.expansion_paradigm),
                max_token_budget: Ok(value.max_token_budget),
                parent_merge_threshold: Ok(value.parent_merge_threshold),
                surrounding_sentences_k: Ok(value.surrounding_sentences_k),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ContextualSemanticResolutionIntent {
        alignment_metric:
            ::std::result::Result<super::ManifoldAlignmentMetricProfile, ::std::string::String>,
        encoding_profile:
            ::std::result::Result<super::TabularEncodingProfile, ::std::string::String>,
        minimum_isometry_threshold: ::std::result::Result<f64, ::std::string::String>,
        source_record_cid: ::std::result::Result<super::SourceRecordCid, ::std::string::String>,
        target_ontology_graph_cid:
            ::std::result::Result<super::TargetOntologyGraphCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for ContextualSemanticResolutionIntent {
        fn default() -> Self {
            Self {
                alignment_metric: Err("no value supplied for alignment_metric".to_string()),
                encoding_profile: Err("no value supplied for encoding_profile".to_string()),
                minimum_isometry_threshold: Err(
                    "no value supplied for minimum_isometry_threshold".to_string()
                ),
                source_record_cid: Err("no value supplied for source_record_cid".to_string()),
                target_ontology_graph_cid: Err(
                    "no value supplied for target_ontology_graph_cid".to_string()
                ),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl ContextualSemanticResolutionIntent {
        pub fn alignment_metric<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ManifoldAlignmentMetricProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.alignment_metric = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for alignment_metric: {e}"));
            self
        }
        pub fn encoding_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TabularEncodingProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.encoding_profile = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for encoding_profile: {e}"));
            self
        }
        pub fn minimum_isometry_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.minimum_isometry_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for minimum_isometry_threshold: {e}")
            });
            self
        }
        pub fn source_record_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceRecordCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_record_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_record_cid: {e}"));
            self
        }
        pub fn target_ontology_graph_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetOntologyGraphCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_ontology_graph_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_ontology_graph_cid: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ContextualSemanticResolutionIntent>
        for super::ContextualSemanticResolutionIntent
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ContextualSemanticResolutionIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                alignment_metric: value.alignment_metric?,
                encoding_profile: value.encoding_profile?,
                minimum_isometry_threshold: value.minimum_isometry_threshold?,
                source_record_cid: value.source_record_cid?,
                target_ontology_graph_cid: value.target_ontology_graph_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::ContextualSemanticResolutionIntent>
        for ContextualSemanticResolutionIntent
    {
        fn from(value: super::ContextualSemanticResolutionIntent) -> Self {
            Self {
                alignment_metric: Ok(value.alignment_metric),
                encoding_profile: Ok(value.encoding_profile),
                minimum_isometry_threshold: Ok(value.minimum_isometry_threshold),
                source_record_cid: Ok(value.source_record_cid),
                target_ontology_graph_cid: Ok(value.target_ontology_graph_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ContextualizedSourceState {
        contextual_envelope: ::std::result::Result<
            ::std::vec::Vec<super::ContextualEnvelopeItem>,
            ::std::string::String,
        >,
        source_system_provenance_flag: ::std::result::Result<bool, ::std::string::String>,
        target_string: ::std::result::Result<super::TargetString, ::std::string::String>,
    }
    impl ::std::default::Default for ContextualizedSourceState {
        fn default() -> Self {
            Self {
                contextual_envelope: Err("no value supplied for contextual_envelope".to_string()),
                source_system_provenance_flag: Err(
                    "no value supplied for source_system_provenance_flag".to_string(),
                ),
                target_string: Err("no value supplied for target_string".to_string()),
            }
        }
    }
    impl ContextualizedSourceState {
        pub fn contextual_envelope<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ContextualEnvelopeItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.contextual_envelope = value.try_into().map_err(|e| {
                format!("error converting supplied value for contextual_envelope: {e}")
            });
            self
        }
        pub fn source_system_provenance_flag<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.source_system_provenance_flag = value.try_into().map_err(|e| {
                format!("error converting supplied value for source_system_provenance_flag: {e}")
            });
            self
        }
        pub fn target_string<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetString>,
            T::Error: ::std::fmt::Display,
        {
            self.target_string = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_string: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ContextualizedSourceState> for super::ContextualizedSourceState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ContextualizedSourceState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                contextual_envelope: value.contextual_envelope?,
                source_system_provenance_flag: value.source_system_provenance_flag?,
                target_string: value.target_string?,
            })
        }
    }
    impl ::std::convert::From<super::ContextualizedSourceState> for ContextualizedSourceState {
        fn from(value: super::ContextualizedSourceState) -> Self {
            Self {
                contextual_envelope: Ok(value.contextual_envelope),
                source_system_provenance_flag: Ok(value.source_system_provenance_flag),
                target_string: Ok(value.target_string),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ContinuousManifoldMappingContract {
        isometry_preservation_score: ::std::result::Result<f64, ::std::string::String>,
        source_semantic_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        target_spatial_transform:
            ::std::result::Result<super::Se3TransformProfile, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for ContinuousManifoldMappingContract {
        fn default() -> Self {
            Self {
                isometry_preservation_score: Err(
                    "no value supplied for isometry_preservation_score".to_string(),
                ),
                source_semantic_node_cid: Err(
                    "no value supplied for source_semantic_node_cid".to_string()
                ),
                target_spatial_transform: Err(
                    "no value supplied for target_spatial_transform".to_string()
                ),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl ContinuousManifoldMappingContract {
        pub fn isometry_preservation_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.isometry_preservation_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for isometry_preservation_score: {e}")
            });
            self
        }
        pub fn source_semantic_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.source_semantic_node_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for source_semantic_node_cid: {e}")
            });
            self
        }
        pub fn target_spatial_transform<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Se3TransformProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.target_spatial_transform = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_spatial_transform: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ContinuousManifoldMappingContract>
        for super::ContinuousManifoldMappingContract
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ContinuousManifoldMappingContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                isometry_preservation_score: value.isometry_preservation_score?,
                source_semantic_node_cid: value.source_semantic_node_cid?,
                target_spatial_transform: value.target_spatial_transform?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::ContinuousManifoldMappingContract>
        for ContinuousManifoldMappingContract
    {
        fn from(value: super::ContinuousManifoldMappingContract) -> Self {
            Self {
                isometry_preservation_score: Ok(value.isometry_preservation_score),
                source_semantic_node_cid: Ok(value.source_semantic_node_cid),
                target_spatial_transform: Ok(value.target_spatial_transform),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ContinuousMutationPolicy {
        max_uncommitted_edges: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        micro_batch_interval_ms:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        mutation_paradigm: ::std::result::Result<super::MutationParadigm, ::std::string::String>,
    }
    impl ::std::default::Default for ContinuousMutationPolicy {
        fn default() -> Self {
            Self {
                max_uncommitted_edges: Err(
                    "no value supplied for max_uncommitted_edges".to_string()
                ),
                micro_batch_interval_ms: Err(
                    "no value supplied for micro_batch_interval_ms".to_string()
                ),
                mutation_paradigm: Err("no value supplied for mutation_paradigm".to_string()),
            }
        }
    }
    impl ContinuousMutationPolicy {
        pub fn max_uncommitted_edges<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_uncommitted_edges = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_uncommitted_edges: {e}")
            });
            self
        }
        pub fn micro_batch_interval_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.micro_batch_interval_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for micro_batch_interval_ms: {e}")
            });
            self
        }
        pub fn mutation_paradigm<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MutationParadigm>,
            T::Error: ::std::fmt::Display,
        {
            self.mutation_paradigm = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for mutation_paradigm: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ContinuousMutationPolicy> for super::ContinuousMutationPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ContinuousMutationPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_uncommitted_edges: value.max_uncommitted_edges?,
                micro_batch_interval_ms: value.micro_batch_interval_ms?,
                mutation_paradigm: value.mutation_paradigm?,
            })
        }
    }
    impl ::std::convert::From<super::ContinuousMutationPolicy> for ContinuousMutationPolicy {
        fn from(value: super::ContinuousMutationPolicy) -> Self {
            Self {
                max_uncommitted_edges: Ok(value.max_uncommitted_edges),
                micro_batch_interval_ms: Ok(value.micro_batch_interval_ms),
                mutation_paradigm: Ok(value.mutation_paradigm),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ContinuousObservationState {
        latest_confidence_score: ::std::result::Result<f64, ::std::string::String>,
        stream_cid: ::std::result::Result<super::StreamCid, ::std::string::String>,
        temporal_decay_matrix: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, f64>,
            ::std::string::String,
        >,
        token_buffer:
            ::std::result::Result<::std::vec::Vec<super::TokenBufferItem>, ::std::string::String>,
    }
    impl ::std::default::Default for ContinuousObservationState {
        fn default() -> Self {
            Self {
                latest_confidence_score: Err(
                    "no value supplied for latest_confidence_score".to_string()
                ),
                stream_cid: Err("no value supplied for stream_cid".to_string()),
                temporal_decay_matrix: Err(
                    "no value supplied for temporal_decay_matrix".to_string()
                ),
                token_buffer: Err("no value supplied for token_buffer".to_string()),
            }
        }
    }
    impl ContinuousObservationState {
        pub fn latest_confidence_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.latest_confidence_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for latest_confidence_score: {e}")
            });
            self
        }
        pub fn stream_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StreamCid>,
            T::Error: ::std::fmt::Display,
        {
            self.stream_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for stream_cid: {e}"));
            self
        }
        pub fn temporal_decay_matrix<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::collections::HashMap<::std::string::String, f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_decay_matrix = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_decay_matrix: {e}")
            });
            self
        }
        pub fn token_buffer<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::TokenBufferItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.token_buffer = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for token_buffer: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ContinuousObservationState> for super::ContinuousObservationState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ContinuousObservationState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                latest_confidence_score: value.latest_confidence_score?,
                stream_cid: value.stream_cid?,
                temporal_decay_matrix: value.temporal_decay_matrix?,
                token_buffer: value.token_buffer?,
            })
        }
    }
    impl ::std::convert::From<super::ContinuousObservationState> for ContinuousObservationState {
        fn from(value: super::ContinuousObservationState) -> Self {
            Self {
                latest_confidence_score: Ok(value.latest_confidence_score),
                stream_cid: Ok(value.stream_cid),
                temporal_decay_matrix: Ok(value.temporal_decay_matrix),
                token_buffer: Ok(value.token_buffer),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ContinuousSpatialMutationIntent {
        lamport_clock: ::std::result::Result<u64, ::std::string::String>,
        proposed_transform:
            ::std::result::Result<super::Se3TransformProfile, ::std::string::String>,
        target_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for ContinuousSpatialMutationIntent {
        fn default() -> Self {
            Self {
                lamport_clock: Err("no value supplied for lamport_clock".to_string()),
                proposed_transform: Err("no value supplied for proposed_transform".to_string()),
                target_node_cid: Err("no value supplied for target_node_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl ContinuousSpatialMutationIntent {
        pub fn lamport_clock<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.lamport_clock = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lamport_clock: {e}"));
            self
        }
        pub fn proposed_transform<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Se3TransformProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.proposed_transform = value.try_into().map_err(|e| {
                format!("error converting supplied value for proposed_transform: {e}")
            });
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ContinuousSpatialMutationIntent>
        for super::ContinuousSpatialMutationIntent
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ContinuousSpatialMutationIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                lamport_clock: value.lamport_clock?,
                proposed_transform: value.proposed_transform?,
                target_node_cid: value.target_node_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::ContinuousSpatialMutationIntent>
        for ContinuousSpatialMutationIntent
    {
        fn from(value: super::ContinuousSpatialMutationIntent) -> Self {
            Self {
                lamport_clock: Ok(value.lamport_clock),
                proposed_transform: Ok(value.proposed_transform),
                target_node_cid: Ok(value.target_node_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CouncilTopologyManifest {
        adjudicator_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        consensus_policy: ::std::result::Result<
            ::std::option::Option<super::ConsensusPolicy>,
            ::std::string::String,
        >,
        council_escrow: ::std::result::Result<
            ::std::option::Option<super::EscrowPolicy>,
            ::std::string::String,
        >,
        diversity_policy: ::std::result::Result<
            ::std::option::Option<super::DiversityPolicy>,
            ::std::string::String,
        >,
        epistemic_enforcement: ::std::result::Result<
            ::std::option::Option<super::TruthMaintenancePolicy>,
            ::std::string::String,
        >,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        lifecycle_phase: ::std::result::Result<
            ::std::option::Option<super::LifecyclePhase>,
            ::std::string::String,
        >,
        nodes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            ::std::string::String,
        >,
        observability: ::std::result::Result<
            ::std::option::Option<super::ObservabilityLodPolicy>,
            ::std::string::String,
        >,
        ontological_alignment: ::std::result::Result<
            ::std::option::Option<super::OntologicalAlignmentPolicy>,
            ::std::string::String,
        >,
        semantic_flow: ::std::result::Result<
            ::std::option::Option<super::SemanticFlowPolicy>,
            ::std::string::String,
        >,
        shared_state_contract: ::std::result::Result<
            ::std::option::Option<super::StateContract>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CouncilTopologyManifest {
        fn default() -> Self {
            Self {
                adjudicator_cid: Err("no value supplied for adjudicator_cid".to_string()),
                architectural_intent: Ok(Default::default()),
                consensus_policy: Ok(Default::default()),
                council_escrow: Ok(Default::default()),
                diversity_policy: Ok(Default::default()),
                epistemic_enforcement: Ok(Default::default()),
                justification: Ok(Default::default()),
                lifecycle_phase: Ok(Default::default()),
                nodes: Err("no value supplied for nodes".to_string()),
                observability: Ok(Default::default()),
                ontological_alignment: Ok(Default::default()),
                semantic_flow: Ok(Default::default()),
                shared_state_contract: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl CouncilTopologyManifest {
        pub fn adjudicator_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.adjudicator_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for adjudicator_cid: {e}"));
            self
        }
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn consensus_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ConsensusPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.consensus_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for consensus_policy: {e}"));
            self
        }
        pub fn council_escrow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EscrowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.council_escrow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for council_escrow: {e}"));
            self
        }
        pub fn diversity_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DiversityPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.diversity_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for diversity_policy: {e}"));
            self
        }
        pub fn epistemic_enforcement<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TruthMaintenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_enforcement = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_enforcement: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn lifecycle_phase<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LifecyclePhase>>,
            T::Error: ::std::fmt::Display,
        {
            self.lifecycle_phase = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lifecycle_phase: {e}"));
            self
        }
        pub fn nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for nodes: {e}"));
            self
        }
        pub fn observability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ObservabilityLodPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.observability = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for observability: {e}"));
            self
        }
        pub fn ontological_alignment<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::OntologicalAlignmentPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.ontological_alignment = value.try_into().map_err(|e| {
                format!("error converting supplied value for ontological_alignment: {e}")
            });
            self
        }
        pub fn semantic_flow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFlowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_flow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_flow: {e}"));
            self
        }
        pub fn shared_state_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.shared_state_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for shared_state_contract: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CouncilTopologyManifest> for super::CouncilTopologyManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CouncilTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                adjudicator_cid: value.adjudicator_cid?,
                architectural_intent: value.architectural_intent?,
                consensus_policy: value.consensus_policy?,
                council_escrow: value.council_escrow?,
                diversity_policy: value.diversity_policy?,
                epistemic_enforcement: value.epistemic_enforcement?,
                justification: value.justification?,
                lifecycle_phase: value.lifecycle_phase?,
                nodes: value.nodes?,
                observability: value.observability?,
                ontological_alignment: value.ontological_alignment?,
                semantic_flow: value.semantic_flow?,
                shared_state_contract: value.shared_state_contract?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::CouncilTopologyManifest> for CouncilTopologyManifest {
        fn from(value: super::CouncilTopologyManifest) -> Self {
            Self {
                adjudicator_cid: Ok(value.adjudicator_cid),
                architectural_intent: Ok(value.architectural_intent),
                consensus_policy: Ok(value.consensus_policy),
                council_escrow: Ok(value.council_escrow),
                diversity_policy: Ok(value.diversity_policy),
                epistemic_enforcement: Ok(value.epistemic_enforcement),
                justification: Ok(value.justification),
                lifecycle_phase: Ok(value.lifecycle_phase),
                nodes: Ok(value.nodes),
                observability: Ok(value.observability),
                ontological_alignment: Ok(value.ontological_alignment),
                semantic_flow: Ok(value.semantic_flow),
                shared_state_contract: Ok(value.shared_state_contract),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CounterfactualRegretEvent {
        counterfactual_intervention:
            ::std::result::Result<super::CounterfactualIntervention, ::std::string::String>,
        epistemic_regret: ::std::result::Result<f64, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        expected_utility_actual: ::std::result::Result<f64, ::std::string::String>,
        expected_utility_simulated: ::std::result::Result<f64, ::std::string::String>,
        historical_event_cid:
            ::std::result::Result<super::HistoricalEventCid, ::std::string::String>,
        policy_mutation_gradients: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, f64>,
            ::std::string::String,
        >,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CounterfactualRegretEvent {
        fn default() -> Self {
            Self {
                counterfactual_intervention: Err(
                    "no value supplied for counterfactual_intervention".to_string(),
                ),
                epistemic_regret: Err("no value supplied for epistemic_regret".to_string()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                expected_utility_actual: Err(
                    "no value supplied for expected_utility_actual".to_string()
                ),
                expected_utility_simulated: Err(
                    "no value supplied for expected_utility_simulated".to_string()
                ),
                historical_event_cid: Err("no value supplied for historical_event_cid".to_string()),
                policy_mutation_gradients: Ok(Default::default()),
                prior_event_hash: Ok(Default::default()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl CounterfactualRegretEvent {
        pub fn counterfactual_intervention<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CounterfactualIntervention>,
            T::Error: ::std::fmt::Display,
        {
            self.counterfactual_intervention = value.try_into().map_err(|e| {
                format!("error converting supplied value for counterfactual_intervention: {e}")
            });
            self
        }
        pub fn epistemic_regret<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_regret = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for epistemic_regret: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn expected_utility_actual<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.expected_utility_actual = value.try_into().map_err(|e| {
                format!("error converting supplied value for expected_utility_actual: {e}")
            });
            self
        }
        pub fn expected_utility_simulated<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.expected_utility_simulated = value.try_into().map_err(|e| {
                format!("error converting supplied value for expected_utility_simulated: {e}")
            });
            self
        }
        pub fn historical_event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::HistoricalEventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.historical_event_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for historical_event_cid: {e}")
            });
            self
        }
        pub fn policy_mutation_gradients<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::collections::HashMap<::std::string::String, f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.policy_mutation_gradients = value.try_into().map_err(|e| {
                format!("error converting supplied value for policy_mutation_gradients: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CounterfactualRegretEvent> for super::CounterfactualRegretEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CounterfactualRegretEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                counterfactual_intervention: value.counterfactual_intervention?,
                epistemic_regret: value.epistemic_regret?,
                event_cid: value.event_cid?,
                expected_utility_actual: value.expected_utility_actual?,
                expected_utility_simulated: value.expected_utility_simulated?,
                historical_event_cid: value.historical_event_cid?,
                policy_mutation_gradients: value.policy_mutation_gradients?,
                prior_event_hash: value.prior_event_hash?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::CounterfactualRegretEvent> for CounterfactualRegretEvent {
        fn from(value: super::CounterfactualRegretEvent) -> Self {
            Self {
                counterfactual_intervention: Ok(value.counterfactual_intervention),
                epistemic_regret: Ok(value.epistemic_regret),
                event_cid: Ok(value.event_cid),
                expected_utility_actual: Ok(value.expected_utility_actual),
                expected_utility_simulated: Ok(value.expected_utility_simulated),
                historical_event_cid: Ok(value.historical_event_cid),
                policy_mutation_gradients: Ok(value.policy_mutation_gradients),
                prior_event_hash: Ok(value.prior_event_hash),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CrossoverPolicy {
        blending_factor: ::std::result::Result<f64, ::std::string::String>,
        strategy_profile:
            ::std::result::Result<super::CrossoverMechanismProfile, ::std::string::String>,
        verifiable_entropy: ::std::result::Result<
            ::std::option::Option<super::VerifiableEntropyReceipt>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CrossoverPolicy {
        fn default() -> Self {
            Self {
                blending_factor: Err("no value supplied for blending_factor".to_string()),
                strategy_profile: Err("no value supplied for strategy_profile".to_string()),
                verifiable_entropy: Ok(Default::default()),
            }
        }
    }
    impl CrossoverPolicy {
        pub fn blending_factor<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.blending_factor = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for blending_factor: {e}"));
            self
        }
        pub fn strategy_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CrossoverMechanismProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.strategy_profile = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for strategy_profile: {e}"));
            self
        }
        pub fn verifiable_entropy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VerifiableEntropyReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.verifiable_entropy = value.try_into().map_err(|e| {
                format!("error converting supplied value for verifiable_entropy: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<CrossoverPolicy> for super::CrossoverPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CrossoverPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                blending_factor: value.blending_factor?,
                strategy_profile: value.strategy_profile?,
                verifiable_entropy: value.verifiable_entropy?,
            })
        }
    }
    impl ::std::convert::From<super::CrossoverPolicy> for CrossoverPolicy {
        fn from(value: super::CrossoverPolicy) -> Self {
            Self {
                blending_factor: Ok(value.blending_factor),
                strategy_profile: Ok(value.strategy_profile),
                verifiable_entropy: Ok(value.verifiable_entropy),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CrosswalkResolutionReceipt {
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        grounding_confidence:
            ::std::result::Result<super::DempsterShaferBeliefVector, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        receipt_cid: ::std::result::Result<super::ReceiptCid, ::std::string::String>,
        resolved_curies: ::std::result::Result<
            ::std::collections::HashMap<
                ::std::string::String,
                super::CrosswalkResolutionReceiptResolvedCuriesValue,
            >,
            ::std::string::String,
        >,
        target_graph_cid: ::std::result::Result<super::TargetGraphCid, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CrosswalkResolutionReceipt {
        fn default() -> Self {
            Self {
                event_cid: Err("no value supplied for event_cid".to_string()),
                grounding_confidence: Err("no value supplied for grounding_confidence".to_string()),
                prior_event_hash: Ok(Default::default()),
                receipt_cid: Err("no value supplied for receipt_cid".to_string()),
                resolved_curies: Err("no value supplied for resolved_curies".to_string()),
                target_graph_cid: Err("no value supplied for target_graph_cid".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl CrosswalkResolutionReceipt {
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn grounding_confidence<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DempsterShaferBeliefVector>,
            T::Error: ::std::fmt::Display,
        {
            self.grounding_confidence = value.try_into().map_err(|e| {
                format!("error converting supplied value for grounding_confidence: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn receipt_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ReceiptCid>,
            T::Error: ::std::fmt::Display,
        {
            self.receipt_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for receipt_cid: {e}"));
            self
        }
        pub fn resolved_curies<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::CrosswalkResolutionReceiptResolvedCuriesValue,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.resolved_curies = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for resolved_curies: {e}"));
            self
        }
        pub fn target_graph_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetGraphCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_graph_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_graph_cid: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CrosswalkResolutionReceipt> for super::CrosswalkResolutionReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CrosswalkResolutionReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                event_cid: value.event_cid?,
                grounding_confidence: value.grounding_confidence?,
                prior_event_hash: value.prior_event_hash?,
                receipt_cid: value.receipt_cid?,
                resolved_curies: value.resolved_curies?,
                target_graph_cid: value.target_graph_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::CrosswalkResolutionReceipt> for CrosswalkResolutionReceipt {
        fn from(value: super::CrosswalkResolutionReceipt) -> Self {
            Self {
                event_cid: Ok(value.event_cid),
                grounding_confidence: Ok(value.grounding_confidence),
                prior_event_hash: Ok(value.prior_event_hash),
                receipt_cid: Ok(value.receipt_cid),
                resolved_curies: Ok(value.resolved_curies),
                target_graph_cid: Ok(value.target_graph_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CryptographicProvenancePolicy {
        provenance_trace_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CryptographicProvenancePolicy {
        fn default() -> Self {
            Self {
                provenance_trace_cid: Ok(Default::default()),
            }
        }
    }
    impl CryptographicProvenancePolicy {
        pub fn provenance_trace_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.provenance_trace_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for provenance_trace_cid: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<CryptographicProvenancePolicy>
        for super::CryptographicProvenancePolicy
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CryptographicProvenancePolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                provenance_trace_cid: value.provenance_trace_cid?,
            })
        }
    }
    impl ::std::convert::From<super::CryptographicProvenancePolicy> for CryptographicProvenancePolicy {
        fn from(value: super::CryptographicProvenancePolicy) -> Self {
            Self {
                provenance_trace_cid: Ok(value.provenance_trace_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CrystallizationPolicy {
        aleatoric_entropy_threshold: ::std::result::Result<f64, ::std::string::String>,
        min_observations_required: ::std::result::Result<i64, ::std::string::String>,
        target_cognitive_tier:
            ::std::result::Result<super::TargetCognitiveTier, ::std::string::String>,
    }
    impl ::std::default::Default for CrystallizationPolicy {
        fn default() -> Self {
            Self {
                aleatoric_entropy_threshold: Err(
                    "no value supplied for aleatoric_entropy_threshold".to_string(),
                ),
                min_observations_required: Err(
                    "no value supplied for min_observations_required".to_string()
                ),
                target_cognitive_tier: Err(
                    "no value supplied for target_cognitive_tier".to_string()
                ),
            }
        }
    }
    impl CrystallizationPolicy {
        pub fn aleatoric_entropy_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.aleatoric_entropy_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for aleatoric_entropy_threshold: {e}")
            });
            self
        }
        pub fn min_observations_required<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<i64>,
            T::Error: ::std::fmt::Display,
        {
            self.min_observations_required = value.try_into().map_err(|e| {
                format!("error converting supplied value for min_observations_required: {e}")
            });
            self
        }
        pub fn target_cognitive_tier<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetCognitiveTier>,
            T::Error: ::std::fmt::Display,
        {
            self.target_cognitive_tier = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_cognitive_tier: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<CrystallizationPolicy> for super::CrystallizationPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CrystallizationPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                aleatoric_entropy_threshold: value.aleatoric_entropy_threshold?,
                min_observations_required: value.min_observations_required?,
                target_cognitive_tier: value.target_cognitive_tier?,
            })
        }
    }
    impl ::std::convert::From<super::CrystallizationPolicy> for CrystallizationPolicy {
        fn from(value: super::CrystallizationPolicy) -> Self {
            Self {
                aleatoric_entropy_threshold: Ok(value.aleatoric_entropy_threshold),
                min_observations_required: Ok(value.min_observations_required),
                target_cognitive_tier: Ok(value.target_cognitive_tier),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CustodyReceipt {
        applied_policy_cid: ::std::result::Result<super::AppliedPolicyCid, ::std::string::String>,
        custody_cid: ::std::result::Result<super::CustodyCid, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        post_redaction_hash: ::std::result::Result<super::PostRedactionHash, ::std::string::String>,
        pre_redaction_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        redaction_timestamp_unix_nano: ::std::result::Result<i64, ::std::string::String>,
        source_node_cid: ::std::result::Result<super::SourceNodeCid, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CustodyReceipt {
        fn default() -> Self {
            Self {
                applied_policy_cid: Err("no value supplied for applied_policy_cid".to_string()),
                custody_cid: Err("no value supplied for custody_cid".to_string()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                post_redaction_hash: Err("no value supplied for post_redaction_hash".to_string()),
                pre_redaction_hash: Ok(Default::default()),
                prior_event_hash: Ok(Default::default()),
                redaction_timestamp_unix_nano: Err(
                    "no value supplied for redaction_timestamp_unix_nano".to_string(),
                ),
                source_node_cid: Err("no value supplied for source_node_cid".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl CustodyReceipt {
        pub fn applied_policy_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AppliedPolicyCid>,
            T::Error: ::std::fmt::Display,
        {
            self.applied_policy_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for applied_policy_cid: {e}")
            });
            self
        }
        pub fn custody_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CustodyCid>,
            T::Error: ::std::fmt::Display,
        {
            self.custody_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for custody_cid: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn post_redaction_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PostRedactionHash>,
            T::Error: ::std::fmt::Display,
        {
            self.post_redaction_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for post_redaction_hash: {e}")
            });
            self
        }
        pub fn pre_redaction_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.pre_redaction_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for pre_redaction_hash: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn redaction_timestamp_unix_nano<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<i64>,
            T::Error: ::std::fmt::Display,
        {
            self.redaction_timestamp_unix_nano = value.try_into().map_err(|e| {
                format!("error converting supplied value for redaction_timestamp_unix_nano: {e}")
            });
            self
        }
        pub fn source_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceNodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_node_cid: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CustodyReceipt> for super::CustodyReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CustodyReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                applied_policy_cid: value.applied_policy_cid?,
                custody_cid: value.custody_cid?,
                event_cid: value.event_cid?,
                post_redaction_hash: value.post_redaction_hash?,
                pre_redaction_hash: value.pre_redaction_hash?,
                prior_event_hash: value.prior_event_hash?,
                redaction_timestamp_unix_nano: value.redaction_timestamp_unix_nano?,
                source_node_cid: value.source_node_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::CustodyReceipt> for CustodyReceipt {
        fn from(value: super::CustodyReceipt) -> Self {
            Self {
                applied_policy_cid: Ok(value.applied_policy_cid),
                custody_cid: Ok(value.custody_cid),
                event_cid: Ok(value.event_cid),
                post_redaction_hash: Ok(value.post_redaction_hash),
                pre_redaction_hash: Ok(value.pre_redaction_hash),
                prior_event_hash: Ok(value.prior_event_hash),
                redaction_timestamp_unix_nano: Ok(value.redaction_timestamp_unix_nano),
                source_node_cid: Ok(value.source_node_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct CyclicEdgeProfile {
        compute_weight_magnitude: ::std::result::Result<u64, ::std::string::String>,
        discount_factor: ::std::result::Result<f64, ::std::string::String>,
        eval_strategy: ::std::result::Result<
            ::std::option::Option<super::EvalStrategy>,
            ::std::string::String,
        >,
        payload_mappings: ::std::result::Result<
            ::std::vec::Vec<super::EdgeMappingContract>,
            ::std::string::String,
        >,
        probability_weight: ::std::result::Result<f64, ::std::string::String>,
        target_intent: ::std::result::Result<
            ::std::option::Option<super::SemanticDiscoveryIntent>,
            ::std::string::String,
        >,
        target_node_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        terminal_condition:
            ::std::result::Result<super::TerminalConditionContract, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for CyclicEdgeProfile {
        fn default() -> Self {
            Self {
                compute_weight_magnitude: Err(
                    "no value supplied for compute_weight_magnitude".to_string()
                ),
                discount_factor: Err("no value supplied for discount_factor".to_string()),
                eval_strategy: Ok(Default::default()),
                payload_mappings: Ok(Default::default()),
                probability_weight: Err("no value supplied for probability_weight".to_string()),
                target_intent: Ok(Default::default()),
                target_node_cid: Ok(Default::default()),
                terminal_condition: Err("no value supplied for terminal_condition".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl CyclicEdgeProfile {
        pub fn compute_weight_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.compute_weight_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for compute_weight_magnitude: {e}")
            });
            self
        }
        pub fn discount_factor<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.discount_factor = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for discount_factor: {e}"));
            self
        }
        pub fn eval_strategy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EvalStrategy>>,
            T::Error: ::std::fmt::Display,
        {
            self.eval_strategy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for eval_strategy: {e}"));
            self
        }
        pub fn payload_mappings<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EdgeMappingContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.payload_mappings = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for payload_mappings: {e}"));
            self
        }
        pub fn probability_weight<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.probability_weight = value.try_into().map_err(|e| {
                format!("error converting supplied value for probability_weight: {e}")
            });
            self
        }
        pub fn target_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticDiscoveryIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.target_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_intent: {e}"));
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
        pub fn terminal_condition<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TerminalConditionContract>,
            T::Error: ::std::fmt::Display,
        {
            self.terminal_condition = value.try_into().map_err(|e| {
                format!("error converting supplied value for terminal_condition: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<CyclicEdgeProfile> for super::CyclicEdgeProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: CyclicEdgeProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                compute_weight_magnitude: value.compute_weight_magnitude?,
                discount_factor: value.discount_factor?,
                eval_strategy: value.eval_strategy?,
                payload_mappings: value.payload_mappings?,
                probability_weight: value.probability_weight?,
                target_intent: value.target_intent?,
                target_node_cid: value.target_node_cid?,
                terminal_condition: value.terminal_condition?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::CyclicEdgeProfile> for CyclicEdgeProfile {
        fn from(value: super::CyclicEdgeProfile) -> Self {
            Self {
                compute_weight_magnitude: Ok(value.compute_weight_magnitude),
                discount_factor: Ok(value.discount_factor),
                eval_strategy: Ok(value.eval_strategy),
                payload_mappings: Ok(value.payload_mappings),
                probability_weight: Ok(value.probability_weight),
                target_intent: Ok(value.target_intent),
                target_node_cid: Ok(value.target_node_cid),
                terminal_condition: Ok(value.terminal_condition),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DagTopologyManifest {
        allow_cycles: ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        backpressure: ::std::result::Result<
            ::std::option::Option<super::BackpressurePolicy>,
            ::std::string::String,
        >,
        edges: ::std::result::Result<
            ::std::vec::Vec<[::serde_json::Value; 2usize]>,
            ::std::string::String,
        >,
        epistemic_enforcement: ::std::result::Result<
            ::std::option::Option<super::TruthMaintenancePolicy>,
            ::std::string::String,
        >,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        lifecycle_phase: ::std::result::Result<
            ::std::option::Option<super::LifecyclePhase>,
            ::std::string::String,
        >,
        max_depth: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        max_fan_out: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        nodes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            ::std::string::String,
        >,
        observability: ::std::result::Result<
            ::std::option::Option<super::ObservabilityLodPolicy>,
            ::std::string::String,
        >,
        semantic_flow: ::std::result::Result<
            ::std::option::Option<super::SemanticFlowPolicy>,
            ::std::string::String,
        >,
        shared_state_contract: ::std::result::Result<
            ::std::option::Option<super::StateContract>,
            ::std::string::String,
        >,
        speculative_boundaries: ::std::result::Result<
            ::std::vec::Vec<super::SpeculativeExecutionPolicy>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for DagTopologyManifest {
        fn default() -> Self {
            Self {
                allow_cycles: Ok(Default::default()),
                architectural_intent: Ok(Default::default()),
                backpressure: Ok(Default::default()),
                edges: Ok(Default::default()),
                epistemic_enforcement: Ok(Default::default()),
                justification: Ok(Default::default()),
                lifecycle_phase: Ok(Default::default()),
                max_depth: Err("no value supplied for max_depth".to_string()),
                max_fan_out: Err("no value supplied for max_fan_out".to_string()),
                nodes: Err("no value supplied for nodes".to_string()),
                observability: Ok(Default::default()),
                semantic_flow: Ok(Default::default()),
                shared_state_contract: Ok(Default::default()),
                speculative_boundaries: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl DagTopologyManifest {
        pub fn allow_cycles<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.allow_cycles = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for allow_cycles: {e}"));
            self
        }
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn backpressure<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::BackpressurePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.backpressure = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for backpressure: {e}"));
            self
        }
        pub fn edges<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<[::serde_json::Value; 2usize]>>,
            T::Error: ::std::fmt::Display,
        {
            self.edges = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for edges: {e}"));
            self
        }
        pub fn epistemic_enforcement<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TruthMaintenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_enforcement = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_enforcement: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn lifecycle_phase<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LifecyclePhase>>,
            T::Error: ::std::fmt::Display,
        {
            self.lifecycle_phase = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lifecycle_phase: {e}"));
            self
        }
        pub fn max_depth<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_depth = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_depth: {e}"));
            self
        }
        pub fn max_fan_out<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_fan_out = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_fan_out: {e}"));
            self
        }
        pub fn nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for nodes: {e}"));
            self
        }
        pub fn observability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ObservabilityLodPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.observability = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for observability: {e}"));
            self
        }
        pub fn semantic_flow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFlowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_flow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_flow: {e}"));
            self
        }
        pub fn shared_state_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.shared_state_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for shared_state_contract: {e}")
            });
            self
        }
        pub fn speculative_boundaries<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::SpeculativeExecutionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.speculative_boundaries = value.try_into().map_err(|e| {
                format!("error converting supplied value for speculative_boundaries: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<DagTopologyManifest> for super::DagTopologyManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DagTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                allow_cycles: value.allow_cycles?,
                architectural_intent: value.architectural_intent?,
                backpressure: value.backpressure?,
                edges: value.edges?,
                epistemic_enforcement: value.epistemic_enforcement?,
                justification: value.justification?,
                lifecycle_phase: value.lifecycle_phase?,
                max_depth: value.max_depth?,
                max_fan_out: value.max_fan_out?,
                nodes: value.nodes?,
                observability: value.observability?,
                semantic_flow: value.semantic_flow?,
                shared_state_contract: value.shared_state_contract?,
                speculative_boundaries: value.speculative_boundaries?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::DagTopologyManifest> for DagTopologyManifest {
        fn from(value: super::DagTopologyManifest) -> Self {
            Self {
                allow_cycles: Ok(value.allow_cycles),
                architectural_intent: Ok(value.architectural_intent),
                backpressure: Ok(value.backpressure),
                edges: Ok(value.edges),
                epistemic_enforcement: Ok(value.epistemic_enforcement),
                justification: Ok(value.justification),
                lifecycle_phase: Ok(value.lifecycle_phase),
                max_depth: Ok(value.max_depth),
                max_fan_out: Ok(value.max_fan_out),
                nodes: Ok(value.nodes),
                observability: Ok(value.observability),
                semantic_flow: Ok(value.semantic_flow),
                shared_state_contract: Ok(value.shared_state_contract),
                speculative_boundaries: Ok(value.speculative_boundaries),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DefeasibleAttackEvent {
        attack_cid: ::std::result::Result<super::AttackCid, ::std::string::String>,
        attack_vector: ::std::result::Result<super::AttackVectorProfile, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        source_claim_cid: ::std::result::Result<super::SourceClaimCid, ::std::string::String>,
        target_claim_cid: ::std::result::Result<super::TargetClaimCid, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for DefeasibleAttackEvent {
        fn default() -> Self {
            Self {
                attack_cid: Err("no value supplied for attack_cid".to_string()),
                attack_vector: Err("no value supplied for attack_vector".to_string()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                prior_event_hash: Ok(Default::default()),
                source_claim_cid: Err("no value supplied for source_claim_cid".to_string()),
                target_claim_cid: Err("no value supplied for target_claim_cid".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl DefeasibleAttackEvent {
        pub fn attack_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AttackCid>,
            T::Error: ::std::fmt::Display,
        {
            self.attack_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for attack_cid: {e}"));
            self
        }
        pub fn attack_vector<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AttackVectorProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.attack_vector = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for attack_vector: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn source_claim_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceClaimCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_claim_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_claim_cid: {e}"));
            self
        }
        pub fn target_claim_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetClaimCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_claim_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_claim_cid: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<DefeasibleAttackEvent> for super::DefeasibleAttackEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DefeasibleAttackEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                attack_cid: value.attack_cid?,
                attack_vector: value.attack_vector?,
                event_cid: value.event_cid?,
                prior_event_hash: value.prior_event_hash?,
                source_claim_cid: value.source_claim_cid?,
                target_claim_cid: value.target_claim_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::DefeasibleAttackEvent> for DefeasibleAttackEvent {
        fn from(value: super::DefeasibleAttackEvent) -> Self {
            Self {
                attack_cid: Ok(value.attack_cid),
                attack_vector: Ok(value.attack_vector),
                event_cid: Ok(value.event_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                source_claim_cid: Ok(value.source_claim_cid),
                target_claim_cid: Ok(value.target_claim_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DefeasibleCascadeEvent {
        cascade_cid: ::std::result::Result<super::CascadeCid, ::std::string::String>,
        cross_boundary_quarantine_issued:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        propagated_decay_factor: ::std::result::Result<f64, ::std::string::String>,
        quarantined_event_cids: ::std::result::Result<
            ::std::vec::Vec<super::QuarantinedEventCidsItem>,
            ::std::string::String,
        >,
        root_falsified_event_cid:
            ::std::result::Result<super::RootFalsifiedEventCid, ::std::string::String>,
        temporal_blast_radius: ::std::result::Result<
            ::std::option::Option<[::serde_json::Value; 2usize]>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for DefeasibleCascadeEvent {
        fn default() -> Self {
            Self {
                cascade_cid: Err("no value supplied for cascade_cid".to_string()),
                cross_boundary_quarantine_issued: Ok(Default::default()),
                propagated_decay_factor: Err(
                    "no value supplied for propagated_decay_factor".to_string()
                ),
                quarantined_event_cids: Err(
                    "no value supplied for quarantined_event_cids".to_string()
                ),
                root_falsified_event_cid: Err(
                    "no value supplied for root_falsified_event_cid".to_string()
                ),
                temporal_blast_radius: Ok(Default::default()),
            }
        }
    }
    impl DefeasibleCascadeEvent {
        pub fn cascade_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CascadeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.cascade_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for cascade_cid: {e}"));
            self
        }
        pub fn cross_boundary_quarantine_issued<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.cross_boundary_quarantine_issued = value.try_into().map_err(|e| {
                format!("error converting supplied value for cross_boundary_quarantine_issued: {e}")
            });
            self
        }
        pub fn propagated_decay_factor<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.propagated_decay_factor = value.try_into().map_err(|e| {
                format!("error converting supplied value for propagated_decay_factor: {e}")
            });
            self
        }
        pub fn quarantined_event_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::QuarantinedEventCidsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.quarantined_event_cids = value.try_into().map_err(|e| {
                format!("error converting supplied value for quarantined_event_cids: {e}")
            });
            self
        }
        pub fn root_falsified_event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RootFalsifiedEventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.root_falsified_event_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for root_falsified_event_cid: {e}")
            });
            self
        }
        pub fn temporal_blast_radius<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<[::serde_json::Value; 2usize]>>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_blast_radius = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_blast_radius: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<DefeasibleCascadeEvent> for super::DefeasibleCascadeEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DefeasibleCascadeEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                cascade_cid: value.cascade_cid?,
                cross_boundary_quarantine_issued: value.cross_boundary_quarantine_issued?,
                propagated_decay_factor: value.propagated_decay_factor?,
                quarantined_event_cids: value.quarantined_event_cids?,
                root_falsified_event_cid: value.root_falsified_event_cid?,
                temporal_blast_radius: value.temporal_blast_radius?,
            })
        }
    }
    impl ::std::convert::From<super::DefeasibleCascadeEvent> for DefeasibleCascadeEvent {
        fn from(value: super::DefeasibleCascadeEvent) -> Self {
            Self {
                cascade_cid: Ok(value.cascade_cid),
                cross_boundary_quarantine_issued: Ok(value.cross_boundary_quarantine_issued),
                propagated_decay_factor: Ok(value.propagated_decay_factor),
                quarantined_event_cids: Ok(value.quarantined_event_cids),
                root_falsified_event_cid: Ok(value.root_falsified_event_cid),
                temporal_blast_radius: Ok(value.temporal_blast_radius),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DelegatedCapabilityManifest {
        allowed_tool_cids: ::std::result::Result<
            ::std::vec::Vec<super::CapabilityPointerState>,
            ::std::string::String,
        >,
        capability_cid: ::std::result::Result<super::CapabilityCid, ::std::string::String>,
        cryptographic_signature:
            ::std::result::Result<super::CryptographicSignature, ::std::string::String>,
        delegate_agent_did: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        expiration_timestamp: ::std::result::Result<f64, ::std::string::String>,
        principal_did: ::std::result::Result<super::NodeCidState, ::std::string::String>,
    }
    impl ::std::default::Default for DelegatedCapabilityManifest {
        fn default() -> Self {
            Self {
                allowed_tool_cids: Err("no value supplied for allowed_tool_cids".to_string()),
                capability_cid: Err("no value supplied for capability_cid".to_string()),
                cryptographic_signature: Err(
                    "no value supplied for cryptographic_signature".to_string()
                ),
                delegate_agent_did: Err("no value supplied for delegate_agent_did".to_string()),
                expiration_timestamp: Err("no value supplied for expiration_timestamp".to_string()),
                principal_did: Err("no value supplied for principal_did".to_string()),
            }
        }
    }
    impl DelegatedCapabilityManifest {
        pub fn allowed_tool_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::CapabilityPointerState>>,
            T::Error: ::std::fmt::Display,
        {
            self.allowed_tool_cids = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for allowed_tool_cids: {e}"));
            self
        }
        pub fn capability_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CapabilityCid>,
            T::Error: ::std::fmt::Display,
        {
            self.capability_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for capability_cid: {e}"));
            self
        }
        pub fn cryptographic_signature<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CryptographicSignature>,
            T::Error: ::std::fmt::Display,
        {
            self.cryptographic_signature = value.try_into().map_err(|e| {
                format!("error converting supplied value for cryptographic_signature: {e}")
            });
            self
        }
        pub fn delegate_agent_did<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.delegate_agent_did = value.try_into().map_err(|e| {
                format!("error converting supplied value for delegate_agent_did: {e}")
            });
            self
        }
        pub fn expiration_timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.expiration_timestamp = value.try_into().map_err(|e| {
                format!("error converting supplied value for expiration_timestamp: {e}")
            });
            self
        }
        pub fn principal_did<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.principal_did = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for principal_did: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<DelegatedCapabilityManifest> for super::DelegatedCapabilityManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DelegatedCapabilityManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                allowed_tool_cids: value.allowed_tool_cids?,
                capability_cid: value.capability_cid?,
                cryptographic_signature: value.cryptographic_signature?,
                delegate_agent_did: value.delegate_agent_did?,
                expiration_timestamp: value.expiration_timestamp?,
                principal_did: value.principal_did?,
            })
        }
    }
    impl ::std::convert::From<super::DelegatedCapabilityManifest> for DelegatedCapabilityManifest {
        fn from(value: super::DelegatedCapabilityManifest) -> Self {
            Self {
                allowed_tool_cids: Ok(value.allowed_tool_cids),
                capability_cid: Ok(value.capability_cid),
                cryptographic_signature: Ok(value.cryptographic_signature),
                delegate_agent_did: Ok(value.delegate_agent_did),
                expiration_timestamp: Ok(value.expiration_timestamp),
                principal_did: Ok(value.principal_did),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DeliberativeEnvelope {
        deliberation_trace: ::std::result::Result<super::DeliberationTrace, ::std::string::String>,
        payload: ::std::result::Result<::serde_json::Value, ::std::string::String>,
    }
    impl ::std::default::Default for DeliberativeEnvelope {
        fn default() -> Self {
            Self {
                deliberation_trace: Err("no value supplied for deliberation_trace".to_string()),
                payload: Err("no value supplied for payload".to_string()),
            }
        }
    }
    impl DeliberativeEnvelope {
        pub fn deliberation_trace<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DeliberationTrace>,
            T::Error: ::std::fmt::Display,
        {
            self.deliberation_trace = value.try_into().map_err(|e| {
                format!("error converting supplied value for deliberation_trace: {e}")
            });
            self
        }
        pub fn payload<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::serde_json::Value>,
            T::Error: ::std::fmt::Display,
        {
            self.payload = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for payload: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<DeliberativeEnvelope> for super::DeliberativeEnvelope {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DeliberativeEnvelope,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                deliberation_trace: value.deliberation_trace?,
                payload: value.payload?,
            })
        }
    }
    impl ::std::convert::From<super::DeliberativeEnvelope> for DeliberativeEnvelope {
        fn from(value: super::DeliberativeEnvelope) -> Self {
            Self {
                deliberation_trace: Ok(value.deliberation_trace),
                payload: Ok(value.payload),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DempsterShaferBeliefVector {
        epistemic_conflict_mass: ::std::result::Result<f64, ::std::string::String>,
        lexical_confidence: ::std::result::Result<f64, ::std::string::String>,
        semantic_distance: ::std::result::Result<f64, ::std::string::String>,
        structural_graph_confidence: ::std::result::Result<f64, ::std::string::String>,
        supporting_citations: ::std::result::Result<
            ::std::vec::Vec<super::EvidentiaryCitationState>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for DempsterShaferBeliefVector {
        fn default() -> Self {
            Self {
                epistemic_conflict_mass: Err(
                    "no value supplied for epistemic_conflict_mass".to_string()
                ),
                lexical_confidence: Err("no value supplied for lexical_confidence".to_string()),
                semantic_distance: Err("no value supplied for semantic_distance".to_string()),
                structural_graph_confidence: Err(
                    "no value supplied for structural_graph_confidence".to_string(),
                ),
                supporting_citations: Ok(Default::default()),
            }
        }
    }
    impl DempsterShaferBeliefVector {
        pub fn epistemic_conflict_mass<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_conflict_mass = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_conflict_mass: {e}")
            });
            self
        }
        pub fn lexical_confidence<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.lexical_confidence = value.try_into().map_err(|e| {
                format!("error converting supplied value for lexical_confidence: {e}")
            });
            self
        }
        pub fn semantic_distance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_distance = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_distance: {e}"));
            self
        }
        pub fn structural_graph_confidence<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.structural_graph_confidence = value.try_into().map_err(|e| {
                format!("error converting supplied value for structural_graph_confidence: {e}")
            });
            self
        }
        pub fn supporting_citations<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EvidentiaryCitationState>>,
            T::Error: ::std::fmt::Display,
        {
            self.supporting_citations = value.try_into().map_err(|e| {
                format!("error converting supplied value for supporting_citations: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<DempsterShaferBeliefVector> for super::DempsterShaferBeliefVector {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DempsterShaferBeliefVector,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                epistemic_conflict_mass: value.epistemic_conflict_mass?,
                lexical_confidence: value.lexical_confidence?,
                semantic_distance: value.semantic_distance?,
                structural_graph_confidence: value.structural_graph_confidence?,
                supporting_citations: value.supporting_citations?,
            })
        }
    }
    impl ::std::convert::From<super::DempsterShaferBeliefVector> for DempsterShaferBeliefVector {
        fn from(value: super::DempsterShaferBeliefVector) -> Self {
            Self {
                epistemic_conflict_mass: Ok(value.epistemic_conflict_mass),
                lexical_confidence: Ok(value.lexical_confidence),
                semantic_distance: Ok(value.semantic_distance),
                structural_graph_confidence: Ok(value.structural_graph_confidence),
                supporting_citations: Ok(value.supporting_citations),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DifferentiableLogicPolicy {
        constraint_cid: ::std::result::Result<super::ConstraintCid, ::std::string::String>,
        formal_syntax_smt: ::std::result::Result<super::FormalSyntaxSmt, ::std::string::String>,
        relaxation_epsilon: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for DifferentiableLogicPolicy {
        fn default() -> Self {
            Self {
                constraint_cid: Err("no value supplied for constraint_cid".to_string()),
                formal_syntax_smt: Err("no value supplied for formal_syntax_smt".to_string()),
                relaxation_epsilon: Err("no value supplied for relaxation_epsilon".to_string()),
            }
        }
    }
    impl DifferentiableLogicPolicy {
        pub fn constraint_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ConstraintCid>,
            T::Error: ::std::fmt::Display,
        {
            self.constraint_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for constraint_cid: {e}"));
            self
        }
        pub fn formal_syntax_smt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FormalSyntaxSmt>,
            T::Error: ::std::fmt::Display,
        {
            self.formal_syntax_smt = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for formal_syntax_smt: {e}"));
            self
        }
        pub fn relaxation_epsilon<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.relaxation_epsilon = value.try_into().map_err(|e| {
                format!("error converting supplied value for relaxation_epsilon: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<DifferentiableLogicPolicy> for super::DifferentiableLogicPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DifferentiableLogicPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                constraint_cid: value.constraint_cid?,
                formal_syntax_smt: value.formal_syntax_smt?,
                relaxation_epsilon: value.relaxation_epsilon?,
            })
        }
    }
    impl ::std::convert::From<super::DifferentiableLogicPolicy> for DifferentiableLogicPolicy {
        fn from(value: super::DifferentiableLogicPolicy) -> Self {
            Self {
                constraint_cid: Ok(value.constraint_cid),
                formal_syntax_smt: Ok(value.formal_syntax_smt),
                relaxation_epsilon: Ok(value.relaxation_epsilon),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DigitalTwinTopologyManifest {
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        convergence_sla:
            ::std::result::Result<super::SimulationConvergenceSla, ::std::string::String>,
        enforce_no_side_effects:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        epistemic_enforcement: ::std::result::Result<
            ::std::option::Option<super::TruthMaintenancePolicy>,
            ::std::string::String,
        >,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        lifecycle_phase: ::std::result::Result<
            ::std::option::Option<super::LifecyclePhase>,
            ::std::string::String,
        >,
        nodes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            ::std::string::String,
        >,
        observability: ::std::result::Result<
            ::std::option::Option<super::ObservabilityLodPolicy>,
            ::std::string::String,
        >,
        semantic_flow: ::std::result::Result<
            ::std::option::Option<super::SemanticFlowPolicy>,
            ::std::string::String,
        >,
        shared_state_contract: ::std::result::Result<
            ::std::option::Option<super::StateContract>,
            ::std::string::String,
        >,
        target_topology_cid: ::std::result::Result<super::TargetTopologyCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for DigitalTwinTopologyManifest {
        fn default() -> Self {
            Self {
                architectural_intent: Ok(Default::default()),
                convergence_sla: Err("no value supplied for convergence_sla".to_string()),
                enforce_no_side_effects: Ok(Default::default()),
                epistemic_enforcement: Ok(Default::default()),
                justification: Ok(Default::default()),
                lifecycle_phase: Ok(Default::default()),
                nodes: Err("no value supplied for nodes".to_string()),
                observability: Ok(Default::default()),
                semantic_flow: Ok(Default::default()),
                shared_state_contract: Ok(Default::default()),
                target_topology_cid: Err("no value supplied for target_topology_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl DigitalTwinTopologyManifest {
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn convergence_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SimulationConvergenceSla>,
            T::Error: ::std::fmt::Display,
        {
            self.convergence_sla = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for convergence_sla: {e}"));
            self
        }
        pub fn enforce_no_side_effects<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.enforce_no_side_effects = value.try_into().map_err(|e| {
                format!("error converting supplied value for enforce_no_side_effects: {e}")
            });
            self
        }
        pub fn epistemic_enforcement<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TruthMaintenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_enforcement = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_enforcement: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn lifecycle_phase<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LifecyclePhase>>,
            T::Error: ::std::fmt::Display,
        {
            self.lifecycle_phase = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lifecycle_phase: {e}"));
            self
        }
        pub fn nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for nodes: {e}"));
            self
        }
        pub fn observability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ObservabilityLodPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.observability = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for observability: {e}"));
            self
        }
        pub fn semantic_flow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFlowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_flow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_flow: {e}"));
            self
        }
        pub fn shared_state_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.shared_state_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for shared_state_contract: {e}")
            });
            self
        }
        pub fn target_topology_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetTopologyCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_topology_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_topology_cid: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<DigitalTwinTopologyManifest> for super::DigitalTwinTopologyManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DigitalTwinTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                architectural_intent: value.architectural_intent?,
                convergence_sla: value.convergence_sla?,
                enforce_no_side_effects: value.enforce_no_side_effects?,
                epistemic_enforcement: value.epistemic_enforcement?,
                justification: value.justification?,
                lifecycle_phase: value.lifecycle_phase?,
                nodes: value.nodes?,
                observability: value.observability?,
                semantic_flow: value.semantic_flow?,
                shared_state_contract: value.shared_state_contract?,
                target_topology_cid: value.target_topology_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::DigitalTwinTopologyManifest> for DigitalTwinTopologyManifest {
        fn from(value: super::DigitalTwinTopologyManifest) -> Self {
            Self {
                architectural_intent: Ok(value.architectural_intent),
                convergence_sla: Ok(value.convergence_sla),
                enforce_no_side_effects: Ok(value.enforce_no_side_effects),
                epistemic_enforcement: Ok(value.epistemic_enforcement),
                justification: Ok(value.justification),
                lifecycle_phase: Ok(value.lifecycle_phase),
                nodes: Ok(value.nodes),
                observability: Ok(value.observability),
                semantic_flow: Ok(value.semantic_flow),
                shared_state_contract: Ok(value.shared_state_contract),
                target_topology_cid: Ok(value.target_topology_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DiscourseNodeState {
        contained_propositions:
            ::std::result::Result<::std::vec::Vec<super::NodeCidState>, ::std::string::String>,
        discourse_type: ::std::result::Result<super::DiscourseType, ::std::string::String>,
        node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        parent_node_cid: ::std::result::Result<
            ::std::option::Option<super::NodeCidState>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for DiscourseNodeState {
        fn default() -> Self {
            Self {
                contained_propositions: Ok(Default::default()),
                discourse_type: Err("no value supplied for discourse_type".to_string()),
                node_cid: Err("no value supplied for node_cid".to_string()),
                parent_node_cid: Ok(Default::default()),
            }
        }
    }
    impl DiscourseNodeState {
        pub fn contained_propositions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.contained_propositions = value.try_into().map_err(|e| {
                format!("error converting supplied value for contained_propositions: {e}")
            });
            self
        }
        pub fn discourse_type<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DiscourseType>,
            T::Error: ::std::fmt::Display,
        {
            self.discourse_type = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for discourse_type: {e}"));
            self
        }
        pub fn node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for node_cid: {e}"));
            self
        }
        pub fn parent_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.parent_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for parent_node_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<DiscourseNodeState> for super::DiscourseNodeState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DiscourseNodeState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                contained_propositions: value.contained_propositions?,
                discourse_type: value.discourse_type?,
                node_cid: value.node_cid?,
                parent_node_cid: value.parent_node_cid?,
            })
        }
    }
    impl ::std::convert::From<super::DiscourseNodeState> for DiscourseNodeState {
        fn from(value: super::DiscourseNodeState) -> Self {
            Self {
                contained_propositions: Ok(value.contained_propositions),
                discourse_type: Ok(value.discourse_type),
                node_cid: Ok(value.node_cid),
                parent_node_cid: Ok(value.parent_node_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DiscourseTreeManifest {
        discourse_nodes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::DiscourseNodeState>,
            ::std::string::String,
        >,
        manifest_cid: ::std::result::Result<super::ManifestCid, ::std::string::String>,
        root_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for DiscourseTreeManifest {
        fn default() -> Self {
            Self {
                discourse_nodes: Err("no value supplied for discourse_nodes".to_string()),
                manifest_cid: Err("no value supplied for manifest_cid".to_string()),
                root_node_cid: Err("no value supplied for root_node_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl DiscourseTreeManifest {
        pub fn discourse_nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::DiscourseNodeState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.discourse_nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for discourse_nodes: {e}"));
            self
        }
        pub fn manifest_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ManifestCid>,
            T::Error: ::std::fmt::Display,
        {
            self.manifest_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for manifest_cid: {e}"));
            self
        }
        pub fn root_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.root_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for root_node_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<DiscourseTreeManifest> for super::DiscourseTreeManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DiscourseTreeManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                discourse_nodes: value.discourse_nodes?,
                manifest_cid: value.manifest_cid?,
                root_node_cid: value.root_node_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::DiscourseTreeManifest> for DiscourseTreeManifest {
        fn from(value: super::DiscourseTreeManifest) -> Self {
            Self {
                discourse_nodes: Ok(value.discourse_nodes),
                manifest_cid: Ok(value.manifest_cid),
                root_node_cid: Ok(value.root_node_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DistributionProfile {
        confidence_interval_95: ::std::result::Result<
            ::std::option::Option<::std::vec::Vec<::serde_json::Value>>,
            ::std::string::String,
        >,
        distribution_type:
            ::std::result::Result<super::DistributionShapeProfile, ::std::string::String>,
        mean: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        variance: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
    }
    impl ::std::default::Default for DistributionProfile {
        fn default() -> Self {
            Self {
                confidence_interval_95: Ok(Default::default()),
                distribution_type: Err("no value supplied for distribution_type".to_string()),
                mean: Ok(Default::default()),
                variance: Ok(Default::default()),
            }
        }
    }
    impl DistributionProfile {
        pub fn confidence_interval_95<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::vec::Vec<::serde_json::Value>>>,
            T::Error: ::std::fmt::Display,
        {
            self.confidence_interval_95 = value.try_into().map_err(|e| {
                format!("error converting supplied value for confidence_interval_95: {e}")
            });
            self
        }
        pub fn distribution_type<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DistributionShapeProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.distribution_type = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for distribution_type: {e}"));
            self
        }
        pub fn mean<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.mean = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for mean: {e}"));
            self
        }
        pub fn variance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.variance = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for variance: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<DistributionProfile> for super::DistributionProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DistributionProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                confidence_interval_95: value.confidence_interval_95?,
                distribution_type: value.distribution_type?,
                mean: value.mean?,
                variance: value.variance?,
            })
        }
    }
    impl ::std::convert::From<super::DistributionProfile> for DistributionProfile {
        fn from(value: super::DistributionProfile) -> Self {
            Self {
                confidence_interval_95: Ok(value.confidence_interval_95),
                distribution_type: Ok(value.distribution_type),
                mean: Ok(value.mean),
                variance: Ok(value.variance),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DiversityPolicy {
        min_adversaries: ::std::result::Result<u64, ::std::string::String>,
        model_variance_required: ::std::result::Result<bool, ::std::string::String>,
        temperature_variance:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
    }
    impl ::std::default::Default for DiversityPolicy {
        fn default() -> Self {
            Self {
                min_adversaries: Err("no value supplied for min_adversaries".to_string()),
                model_variance_required: Err(
                    "no value supplied for model_variance_required".to_string()
                ),
                temperature_variance: Ok(Default::default()),
            }
        }
    }
    impl DiversityPolicy {
        pub fn min_adversaries<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.min_adversaries = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for min_adversaries: {e}"));
            self
        }
        pub fn model_variance_required<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.model_variance_required = value.try_into().map_err(|e| {
                format!("error converting supplied value for model_variance_required: {e}")
            });
            self
        }
        pub fn temperature_variance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.temperature_variance = value.try_into().map_err(|e| {
                format!("error converting supplied value for temperature_variance: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<DiversityPolicy> for super::DiversityPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DiversityPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                min_adversaries: value.min_adversaries?,
                model_variance_required: value.model_variance_required?,
                temperature_variance: value.temperature_variance?,
            })
        }
    }
    impl ::std::convert::From<super::DiversityPolicy> for DiversityPolicy {
        fn from(value: super::DiversityPolicy) -> Self {
            Self {
                min_adversaries: Ok(value.min_adversaries),
                model_variance_required: Ok(value.model_variance_required),
                temperature_variance: Ok(value.temperature_variance),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DocumentKnowledgeGraphManifest {
        causal_edges: ::std::result::Result<
            ::std::vec::Vec<super::CausalDirectedEdgeState>,
            ::std::string::String,
        >,
        graph_cid: ::std::result::Result<super::GraphCid, ::std::string::String>,
        isomorphism_hash: ::std::result::Result<super::IsomorphismHash, ::std::string::String>,
        nodes:
            ::std::result::Result<::std::vec::Vec<super::SemanticNodeState>, ::std::string::String>,
        source_artifact_cid: ::std::result::Result<super::SourceArtifactCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for DocumentKnowledgeGraphManifest {
        fn default() -> Self {
            Self {
                causal_edges: Err("no value supplied for causal_edges".to_string()),
                graph_cid: Err("no value supplied for graph_cid".to_string()),
                isomorphism_hash: Err("no value supplied for isomorphism_hash".to_string()),
                nodes: Err("no value supplied for nodes".to_string()),
                source_artifact_cid: Err("no value supplied for source_artifact_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl DocumentKnowledgeGraphManifest {
        pub fn causal_edges<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::CausalDirectedEdgeState>>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_edges = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for causal_edges: {e}"));
            self
        }
        pub fn graph_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::GraphCid>,
            T::Error: ::std::fmt::Display,
        {
            self.graph_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for graph_cid: {e}"));
            self
        }
        pub fn isomorphism_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::IsomorphismHash>,
            T::Error: ::std::fmt::Display,
        {
            self.isomorphism_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for isomorphism_hash: {e}"));
            self
        }
        pub fn nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::SemanticNodeState>>,
            T::Error: ::std::fmt::Display,
        {
            self.nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for nodes: {e}"));
            self
        }
        pub fn source_artifact_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceArtifactCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_artifact_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for source_artifact_cid: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<DocumentKnowledgeGraphManifest>
        for super::DocumentKnowledgeGraphManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DocumentKnowledgeGraphManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                causal_edges: value.causal_edges?,
                graph_cid: value.graph_cid?,
                isomorphism_hash: value.isomorphism_hash?,
                nodes: value.nodes?,
                source_artifact_cid: value.source_artifact_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::DocumentKnowledgeGraphManifest>
        for DocumentKnowledgeGraphManifest
    {
        fn from(value: super::DocumentKnowledgeGraphManifest) -> Self {
            Self {
                causal_edges: Ok(value.causal_edges),
                graph_cid: Ok(value.graph_cid),
                isomorphism_hash: Ok(value.isomorphism_hash),
                nodes: Ok(value.nodes),
                source_artifact_cid: Ok(value.source_artifact_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DocumentLayoutManifest {
        blocks: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::DocumentLayoutRegionState>,
            ::std::string::String,
        >,
        chronological_flow_edges: ::std::result::Result<
            ::std::vec::Vec<[::serde_json::Value; 2usize]>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for DocumentLayoutManifest {
        fn default() -> Self {
            Self {
                blocks: Err("no value supplied for blocks".to_string()),
                chronological_flow_edges: Ok(Default::default()),
            }
        }
    }
    impl DocumentLayoutManifest {
        pub fn blocks<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::DocumentLayoutRegionState,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.blocks = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for blocks: {e}"));
            self
        }
        pub fn chronological_flow_edges<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<[::serde_json::Value; 2usize]>>,
            T::Error: ::std::fmt::Display,
        {
            self.chronological_flow_edges = value.try_into().map_err(|e| {
                format!("error converting supplied value for chronological_flow_edges: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<DocumentLayoutManifest> for super::DocumentLayoutManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DocumentLayoutManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                blocks: value.blocks?,
                chronological_flow_edges: value.chronological_flow_edges?,
            })
        }
    }
    impl ::std::convert::From<super::DocumentLayoutManifest> for DocumentLayoutManifest {
        fn from(value: super::DocumentLayoutManifest) -> Self {
            Self {
                blocks: Ok(value.blocks),
                chronological_flow_edges: Ok(value.chronological_flow_edges),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DocumentLayoutRegionState {
        anchor: ::std::result::Result<super::MultimodalTokenAnchorState, ::std::string::String>,
        block_cid: ::std::result::Result<super::BlockCid, ::std::string::String>,
        block_class: ::std::result::Result<super::BlockClass, ::std::string::String>,
        tabular_matrix: ::std::result::Result<
            ::std::option::Option<super::TabularMatrixProfile>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for DocumentLayoutRegionState {
        fn default() -> Self {
            Self {
                anchor: Err("no value supplied for anchor".to_string()),
                block_cid: Err("no value supplied for block_cid".to_string()),
                block_class: Err("no value supplied for block_class".to_string()),
                tabular_matrix: Ok(Default::default()),
            }
        }
    }
    impl DocumentLayoutRegionState {
        pub fn anchor<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MultimodalTokenAnchorState>,
            T::Error: ::std::fmt::Display,
        {
            self.anchor = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for anchor: {e}"));
            self
        }
        pub fn block_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::BlockCid>,
            T::Error: ::std::fmt::Display,
        {
            self.block_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for block_cid: {e}"));
            self
        }
        pub fn block_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::BlockClass>,
            T::Error: ::std::fmt::Display,
        {
            self.block_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for block_class: {e}"));
            self
        }
        pub fn tabular_matrix<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TabularMatrixProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.tabular_matrix = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for tabular_matrix: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<DocumentLayoutRegionState> for super::DocumentLayoutRegionState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DocumentLayoutRegionState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                anchor: value.anchor?,
                block_cid: value.block_cid?,
                block_class: value.block_class?,
                tabular_matrix: value.tabular_matrix?,
            })
        }
    }
    impl ::std::convert::From<super::DocumentLayoutRegionState> for DocumentLayoutRegionState {
        fn from(value: super::DocumentLayoutRegionState) -> Self {
            Self {
                anchor: Ok(value.anchor),
                block_cid: Ok(value.block_cid),
                block_class: Ok(value.block_class),
                tabular_matrix: Ok(value.tabular_matrix),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DraftingIntent {
        context_prompt: ::std::result::Result<super::ContextPrompt, ::std::string::String>,
        resolution_schema: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        timeout_action: ::std::result::Result<super::TimeoutAction, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for DraftingIntent {
        fn default() -> Self {
            Self {
                context_prompt: Err("no value supplied for context_prompt".to_string()),
                resolution_schema: Err("no value supplied for resolution_schema".to_string()),
                timeout_action: Err("no value supplied for timeout_action".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl DraftingIntent {
        pub fn context_prompt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ContextPrompt>,
            T::Error: ::std::fmt::Display,
        {
            self.context_prompt = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for context_prompt: {e}"));
            self
        }
        pub fn resolution_schema<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.resolution_schema = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for resolution_schema: {e}"));
            self
        }
        pub fn timeout_action<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TimeoutAction>,
            T::Error: ::std::fmt::Display,
        {
            self.timeout_action = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timeout_action: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<DraftingIntent> for super::DraftingIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DraftingIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                context_prompt: value.context_prompt?,
                resolution_schema: value.resolution_schema?,
                timeout_action: value.timeout_action?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::DraftingIntent> for DraftingIntent {
        fn from(value: super::DraftingIntent) -> Self {
            Self {
                context_prompt: Ok(value.context_prompt),
                resolution_schema: Ok(value.resolution_schema),
                timeout_action: Ok(value.timeout_action),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DynamicConvergenceSla {
        convergence_delta_epsilon: ::std::result::Result<f64, ::std::string::String>,
        lookback_window_steps: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        minimum_reasoning_steps:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for DynamicConvergenceSla {
        fn default() -> Self {
            Self {
                convergence_delta_epsilon: Err(
                    "no value supplied for convergence_delta_epsilon".to_string()
                ),
                lookback_window_steps: Err(
                    "no value supplied for lookback_window_steps".to_string()
                ),
                minimum_reasoning_steps: Err(
                    "no value supplied for minimum_reasoning_steps".to_string()
                ),
            }
        }
    }
    impl DynamicConvergenceSla {
        pub fn convergence_delta_epsilon<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.convergence_delta_epsilon = value.try_into().map_err(|e| {
                format!("error converting supplied value for convergence_delta_epsilon: {e}")
            });
            self
        }
        pub fn lookback_window_steps<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.lookback_window_steps = value.try_into().map_err(|e| {
                format!("error converting supplied value for lookback_window_steps: {e}")
            });
            self
        }
        pub fn minimum_reasoning_steps<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.minimum_reasoning_steps = value.try_into().map_err(|e| {
                format!("error converting supplied value for minimum_reasoning_steps: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<DynamicConvergenceSla> for super::DynamicConvergenceSla {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DynamicConvergenceSla,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                convergence_delta_epsilon: value.convergence_delta_epsilon?,
                lookback_window_steps: value.lookback_window_steps?,
                minimum_reasoning_steps: value.minimum_reasoning_steps?,
            })
        }
    }
    impl ::std::convert::From<super::DynamicConvergenceSla> for DynamicConvergenceSla {
        fn from(value: super::DynamicConvergenceSla) -> Self {
            Self {
                convergence_delta_epsilon: Ok(value.convergence_delta_epsilon),
                lookback_window_steps: Ok(value.lookback_window_steps),
                minimum_reasoning_steps: Ok(value.minimum_reasoning_steps),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DynamicLayoutManifest {
        layout_tstring: ::std::result::Result<super::LayoutTstring, ::std::string::String>,
        max_ast_node_budget: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for DynamicLayoutManifest {
        fn default() -> Self {
            Self {
                layout_tstring: Err("no value supplied for layout_tstring".to_string()),
                max_ast_node_budget: Ok(Default::default()),
            }
        }
    }
    impl DynamicLayoutManifest {
        pub fn layout_tstring<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::LayoutTstring>,
            T::Error: ::std::fmt::Display,
        {
            self.layout_tstring = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for layout_tstring: {e}"));
            self
        }
        pub fn max_ast_node_budget<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_ast_node_budget = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_ast_node_budget: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<DynamicLayoutManifest> for super::DynamicLayoutManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DynamicLayoutManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                layout_tstring: value.layout_tstring?,
                max_ast_node_budget: value.max_ast_node_budget?,
            })
        }
    }
    impl ::std::convert::From<super::DynamicLayoutManifest> for DynamicLayoutManifest {
        fn from(value: super::DynamicLayoutManifest) -> Self {
            Self {
                layout_tstring: Ok(value.layout_tstring),
                max_ast_node_budget: Ok(value.max_ast_node_budget),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DynamicManifoldProjectionManifest {
        active_forge_cid: ::std::result::Result<super::ActiveForgeCid, ::std::string::String>,
        ast_gradient_visual_mapping:
            ::std::result::Result<super::GrammarPanelProfile, ::std::string::String>,
        manifest_cid: ::std::result::Result<super::ManifestCid, ::std::string::String>,
        thermodynamic_burn_mapping:
            ::std::result::Result<super::AnyPanelProfile, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        viewport_zoom_profile:
            ::std::result::Result<super::SemanticZoomProfile, ::std::string::String>,
    }
    impl ::std::default::Default for DynamicManifoldProjectionManifest {
        fn default() -> Self {
            Self {
                active_forge_cid: Err("no value supplied for active_forge_cid".to_string()),
                ast_gradient_visual_mapping: Err(
                    "no value supplied for ast_gradient_visual_mapping".to_string(),
                ),
                manifest_cid: Err("no value supplied for manifest_cid".to_string()),
                thermodynamic_burn_mapping: Err(
                    "no value supplied for thermodynamic_burn_mapping".to_string()
                ),
                topology_class: Ok(Default::default()),
                viewport_zoom_profile: Err(
                    "no value supplied for viewport_zoom_profile".to_string()
                ),
            }
        }
    }
    impl DynamicManifoldProjectionManifest {
        pub fn active_forge_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ActiveForgeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.active_forge_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for active_forge_cid: {e}"));
            self
        }
        pub fn ast_gradient_visual_mapping<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::GrammarPanelProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.ast_gradient_visual_mapping = value.try_into().map_err(|e| {
                format!("error converting supplied value for ast_gradient_visual_mapping: {e}")
            });
            self
        }
        pub fn manifest_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ManifestCid>,
            T::Error: ::std::fmt::Display,
        {
            self.manifest_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for manifest_cid: {e}"));
            self
        }
        pub fn thermodynamic_burn_mapping<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AnyPanelProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.thermodynamic_burn_mapping = value.try_into().map_err(|e| {
                format!("error converting supplied value for thermodynamic_burn_mapping: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn viewport_zoom_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SemanticZoomProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.viewport_zoom_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for viewport_zoom_profile: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<DynamicManifoldProjectionManifest>
        for super::DynamicManifoldProjectionManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DynamicManifoldProjectionManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                active_forge_cid: value.active_forge_cid?,
                ast_gradient_visual_mapping: value.ast_gradient_visual_mapping?,
                manifest_cid: value.manifest_cid?,
                thermodynamic_burn_mapping: value.thermodynamic_burn_mapping?,
                topology_class: value.topology_class?,
                viewport_zoom_profile: value.viewport_zoom_profile?,
            })
        }
    }
    impl ::std::convert::From<super::DynamicManifoldProjectionManifest>
        for DynamicManifoldProjectionManifest
    {
        fn from(value: super::DynamicManifoldProjectionManifest) -> Self {
            Self {
                active_forge_cid: Ok(value.active_forge_cid),
                ast_gradient_visual_mapping: Ok(value.ast_gradient_visual_mapping),
                manifest_cid: Ok(value.manifest_cid),
                thermodynamic_burn_mapping: Ok(value.thermodynamic_burn_mapping),
                topology_class: Ok(value.topology_class),
                viewport_zoom_profile: Ok(value.viewport_zoom_profile),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct DynamicRoutingManifest {
        active_subgraphs: ::std::result::Result<
            ::std::collections::HashMap<
                ::std::string::String,
                ::std::vec::Vec<super::NodeCidState>,
            >,
            ::std::string::String,
        >,
        artifact_profile:
            ::std::result::Result<super::GlobalSemanticProfile, ::std::string::String>,
        branch_budgets_magnitude: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, i64>,
            ::std::string::String,
        >,
        bypassed_steps:
            ::std::result::Result<::std::vec::Vec<super::BypassReceipt>, ::std::string::String>,
        manifest_cid: ::std::result::Result<super::ManifestCid, ::std::string::String>,
    }
    impl ::std::default::Default for DynamicRoutingManifest {
        fn default() -> Self {
            Self {
                active_subgraphs: Err("no value supplied for active_subgraphs".to_string()),
                artifact_profile: Err("no value supplied for artifact_profile".to_string()),
                branch_budgets_magnitude: Err(
                    "no value supplied for branch_budgets_magnitude".to_string()
                ),
                bypassed_steps: Ok(Default::default()),
                manifest_cid: Err("no value supplied for manifest_cid".to_string()),
            }
        }
    }
    impl DynamicRoutingManifest {
        pub fn active_subgraphs<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    ::std::vec::Vec<super::NodeCidState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.active_subgraphs = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for active_subgraphs: {e}"));
            self
        }
        pub fn artifact_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::GlobalSemanticProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.artifact_profile = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for artifact_profile: {e}"));
            self
        }
        pub fn branch_budgets_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::collections::HashMap<::std::string::String, i64>>,
            T::Error: ::std::fmt::Display,
        {
            self.branch_budgets_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for branch_budgets_magnitude: {e}")
            });
            self
        }
        pub fn bypassed_steps<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::BypassReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.bypassed_steps = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for bypassed_steps: {e}"));
            self
        }
        pub fn manifest_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ManifestCid>,
            T::Error: ::std::fmt::Display,
        {
            self.manifest_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for manifest_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<DynamicRoutingManifest> for super::DynamicRoutingManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: DynamicRoutingManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                active_subgraphs: value.active_subgraphs?,
                artifact_profile: value.artifact_profile?,
                branch_budgets_magnitude: value.branch_budgets_magnitude?,
                bypassed_steps: value.bypassed_steps?,
                manifest_cid: value.manifest_cid?,
            })
        }
    }
    impl ::std::convert::From<super::DynamicRoutingManifest> for DynamicRoutingManifest {
        fn from(value: super::DynamicRoutingManifest) -> Self {
            Self {
                active_subgraphs: Ok(value.active_subgraphs),
                artifact_profile: Ok(value.artifact_profile),
                branch_budgets_magnitude: Ok(value.branch_budgets_magnitude),
                bypassed_steps: Ok(value.bypassed_steps),
                manifest_cid: Ok(value.manifest_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EdgeMappingContract {
        source_pointer: ::std::result::Result<super::SourcePointer, ::std::string::String>,
        target_pointer: ::std::result::Result<super::TargetPointer, ::std::string::String>,
    }
    impl ::std::default::Default for EdgeMappingContract {
        fn default() -> Self {
            Self {
                source_pointer: Err("no value supplied for source_pointer".to_string()),
                target_pointer: Err("no value supplied for target_pointer".to_string()),
            }
        }
    }
    impl EdgeMappingContract {
        pub fn source_pointer<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourcePointer>,
            T::Error: ::std::fmt::Display,
        {
            self.source_pointer = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_pointer: {e}"));
            self
        }
        pub fn target_pointer<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetPointer>,
            T::Error: ::std::fmt::Display,
        {
            self.target_pointer = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_pointer: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EdgeMappingContract> for super::EdgeMappingContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EdgeMappingContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                source_pointer: value.source_pointer?,
                target_pointer: value.target_pointer?,
            })
        }
    }
    impl ::std::convert::From<super::EdgeMappingContract> for EdgeMappingContract {
        fn from(value: super::EdgeMappingContract) -> Self {
            Self {
                source_pointer: Ok(value.source_pointer),
                target_pointer: Ok(value.target_pointer),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EmbodiedSensoryVectorProfile {
        bayesian_surprise_score: ::std::result::Result<f64, ::std::string::String>,
        salience_threshold_breached:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        sensory_modality: ::std::result::Result<super::SensoryModality, ::std::string::String>,
        temporal_duration_ms: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for EmbodiedSensoryVectorProfile {
        fn default() -> Self {
            Self {
                bayesian_surprise_score: Err(
                    "no value supplied for bayesian_surprise_score".to_string()
                ),
                salience_threshold_breached: Ok(Default::default()),
                sensory_modality: Err("no value supplied for sensory_modality".to_string()),
                temporal_duration_ms: Err("no value supplied for temporal_duration_ms".to_string()),
            }
        }
    }
    impl EmbodiedSensoryVectorProfile {
        pub fn bayesian_surprise_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.bayesian_surprise_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for bayesian_surprise_score: {e}")
            });
            self
        }
        pub fn salience_threshold_breached<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.salience_threshold_breached = value.try_into().map_err(|e| {
                format!("error converting supplied value for salience_threshold_breached: {e}")
            });
            self
        }
        pub fn sensory_modality<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SensoryModality>,
            T::Error: ::std::fmt::Display,
        {
            self.sensory_modality = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for sensory_modality: {e}"));
            self
        }
        pub fn temporal_duration_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_duration_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_duration_ms: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EmbodiedSensoryVectorProfile> for super::EmbodiedSensoryVectorProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EmbodiedSensoryVectorProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                bayesian_surprise_score: value.bayesian_surprise_score?,
                salience_threshold_breached: value.salience_threshold_breached?,
                sensory_modality: value.sensory_modality?,
                temporal_duration_ms: value.temporal_duration_ms?,
            })
        }
    }
    impl ::std::convert::From<super::EmbodiedSensoryVectorProfile> for EmbodiedSensoryVectorProfile {
        fn from(value: super::EmbodiedSensoryVectorProfile) -> Self {
            Self {
                bayesian_surprise_score: Ok(value.bayesian_surprise_score),
                salience_threshold_breached: Ok(value.salience_threshold_breached),
                sensory_modality: Ok(value.sensory_modality),
                temporal_duration_ms: Ok(value.temporal_duration_ms),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EmpiricalFalsificationContract {
        condition_cid: ::std::result::Result<super::ConditionCid, ::std::string::String>,
        description: ::std::result::Result<super::Description, ::std::string::String>,
        falsifying_observation_signature:
            ::std::result::Result<super::FalsifyingObservationSignature, ::std::string::String>,
        required_tool_name: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EmpiricalFalsificationContract {
        fn default() -> Self {
            Self {
                condition_cid: Err("no value supplied for condition_cid".to_string()),
                description: Err("no value supplied for description".to_string()),
                falsifying_observation_signature: Err(
                    "no value supplied for falsifying_observation_signature".to_string(),
                ),
                required_tool_name: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl EmpiricalFalsificationContract {
        pub fn condition_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ConditionCid>,
            T::Error: ::std::fmt::Display,
        {
            self.condition_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for condition_cid: {e}"));
            self
        }
        pub fn description<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Description>,
            T::Error: ::std::fmt::Display,
        {
            self.description = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for description: {e}"));
            self
        }
        pub fn falsifying_observation_signature<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FalsifyingObservationSignature>,
            T::Error: ::std::fmt::Display,
        {
            self.falsifying_observation_signature = value.try_into().map_err(|e| {
                format!("error converting supplied value for falsifying_observation_signature: {e}")
            });
            self
        }
        pub fn required_tool_name<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.required_tool_name = value.try_into().map_err(|e| {
                format!("error converting supplied value for required_tool_name: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EmpiricalFalsificationContract>
        for super::EmpiricalFalsificationContract
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EmpiricalFalsificationContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                condition_cid: value.condition_cid?,
                description: value.description?,
                falsifying_observation_signature: value.falsifying_observation_signature?,
                required_tool_name: value.required_tool_name?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::EmpiricalFalsificationContract>
        for EmpiricalFalsificationContract
    {
        fn from(value: super::EmpiricalFalsificationContract) -> Self {
            Self {
                condition_cid: Ok(value.condition_cid),
                description: Ok(value.description),
                falsifying_observation_signature: Ok(value.falsifying_observation_signature),
                required_tool_name: Ok(value.required_tool_name),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EmpiricalStatisticalProfile {
        algebraic_operator: ::std::result::Result<super::AlgebraicOperator, ::std::string::String>,
        lower_bound: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        qualifier_type: ::std::result::Result<super::QualifierType, ::std::string::String>,
        upper_bound: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        value: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for EmpiricalStatisticalProfile {
        fn default() -> Self {
            Self {
                algebraic_operator: Err("no value supplied for algebraic_operator".to_string()),
                lower_bound: Ok(Default::default()),
                qualifier_type: Err("no value supplied for qualifier_type".to_string()),
                upper_bound: Ok(Default::default()),
                value: Err("no value supplied for value".to_string()),
            }
        }
    }
    impl EmpiricalStatisticalProfile {
        pub fn algebraic_operator<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AlgebraicOperator>,
            T::Error: ::std::fmt::Display,
        {
            self.algebraic_operator = value.try_into().map_err(|e| {
                format!("error converting supplied value for algebraic_operator: {e}")
            });
            self
        }
        pub fn lower_bound<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.lower_bound = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lower_bound: {e}"));
            self
        }
        pub fn qualifier_type<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::QualifierType>,
            T::Error: ::std::fmt::Display,
        {
            self.qualifier_type = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for qualifier_type: {e}"));
            self
        }
        pub fn upper_bound<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.upper_bound = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for upper_bound: {e}"));
            self
        }
        pub fn value<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.value = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for value: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EmpiricalStatisticalProfile> for super::EmpiricalStatisticalProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EmpiricalStatisticalProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                algebraic_operator: value.algebraic_operator?,
                lower_bound: value.lower_bound?,
                qualifier_type: value.qualifier_type?,
                upper_bound: value.upper_bound?,
                value: value.value?,
            })
        }
    }
    impl ::std::convert::From<super::EmpiricalStatisticalProfile> for EmpiricalStatisticalProfile {
        fn from(value: super::EmpiricalStatisticalProfile) -> Self {
            Self {
                algebraic_operator: Ok(value.algebraic_operator),
                lower_bound: Ok(value.lower_bound),
                qualifier_type: Ok(value.qualifier_type),
                upper_bound: Ok(value.upper_bound),
                value: Ok(value.value),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EnsembleTopologyProfile {
        concurrent_branch_cids:
            ::std::result::Result<::std::vec::Vec<super::NodeCidState>, ::std::string::String>,
        fusion_function: ::std::result::Result<super::FusionFunction, ::std::string::String>,
    }
    impl ::std::default::Default for EnsembleTopologyProfile {
        fn default() -> Self {
            Self {
                concurrent_branch_cids: Err(
                    "no value supplied for concurrent_branch_cids".to_string()
                ),
                fusion_function: Err("no value supplied for fusion_function".to_string()),
            }
        }
    }
    impl EnsembleTopologyProfile {
        pub fn concurrent_branch_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.concurrent_branch_cids = value.try_into().map_err(|e| {
                format!("error converting supplied value for concurrent_branch_cids: {e}")
            });
            self
        }
        pub fn fusion_function<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FusionFunction>,
            T::Error: ::std::fmt::Display,
        {
            self.fusion_function = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for fusion_function: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EnsembleTopologyProfile> for super::EnsembleTopologyProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EnsembleTopologyProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                concurrent_branch_cids: value.concurrent_branch_cids?,
                fusion_function: value.fusion_function?,
            })
        }
    }
    impl ::std::convert::From<super::EnsembleTopologyProfile> for EnsembleTopologyProfile {
        fn from(value: super::EnsembleTopologyProfile) -> Self {
            Self {
                concurrent_branch_cids: Ok(value.concurrent_branch_cids),
                fusion_function: Ok(value.fusion_function),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EphemeralNamespacePartitionState {
        allow_network_egress:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        allow_subprocess_spawning:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        authorized_bytecode_hashes: ::std::result::Result<
            ::std::vec::Vec<super::AuthorizedBytecodeHashesItem>,
            ::std::string::String,
        >,
        execution_runtime: ::std::result::Result<super::ExecutionRuntime, ::std::string::String>,
        max_ttl_seconds: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        max_vram_mb: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        partition_cid: ::std::result::Result<super::PartitionCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EphemeralNamespacePartitionState {
        fn default() -> Self {
            Self {
                allow_network_egress: Ok(Default::default()),
                allow_subprocess_spawning: Ok(Default::default()),
                authorized_bytecode_hashes: Err(
                    "no value supplied for authorized_bytecode_hashes".to_string()
                ),
                execution_runtime: Err("no value supplied for execution_runtime".to_string()),
                max_ttl_seconds: Err("no value supplied for max_ttl_seconds".to_string()),
                max_vram_mb: Err("no value supplied for max_vram_mb".to_string()),
                partition_cid: Err("no value supplied for partition_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl EphemeralNamespacePartitionState {
        pub fn allow_network_egress<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.allow_network_egress = value.try_into().map_err(|e| {
                format!("error converting supplied value for allow_network_egress: {e}")
            });
            self
        }
        pub fn allow_subprocess_spawning<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.allow_subprocess_spawning = value.try_into().map_err(|e| {
                format!("error converting supplied value for allow_subprocess_spawning: {e}")
            });
            self
        }
        pub fn authorized_bytecode_hashes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AuthorizedBytecodeHashesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.authorized_bytecode_hashes = value.try_into().map_err(|e| {
                format!("error converting supplied value for authorized_bytecode_hashes: {e}")
            });
            self
        }
        pub fn execution_runtime<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ExecutionRuntime>,
            T::Error: ::std::fmt::Display,
        {
            self.execution_runtime = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for execution_runtime: {e}"));
            self
        }
        pub fn max_ttl_seconds<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_ttl_seconds = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_ttl_seconds: {e}"));
            self
        }
        pub fn max_vram_mb<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_vram_mb = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_vram_mb: {e}"));
            self
        }
        pub fn partition_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PartitionCid>,
            T::Error: ::std::fmt::Display,
        {
            self.partition_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for partition_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EphemeralNamespacePartitionState>
        for super::EphemeralNamespacePartitionState
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EphemeralNamespacePartitionState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                allow_network_egress: value.allow_network_egress?,
                allow_subprocess_spawning: value.allow_subprocess_spawning?,
                authorized_bytecode_hashes: value.authorized_bytecode_hashes?,
                execution_runtime: value.execution_runtime?,
                max_ttl_seconds: value.max_ttl_seconds?,
                max_vram_mb: value.max_vram_mb?,
                partition_cid: value.partition_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::EphemeralNamespacePartitionState>
        for EphemeralNamespacePartitionState
    {
        fn from(value: super::EphemeralNamespacePartitionState) -> Self {
            Self {
                allow_network_egress: Ok(value.allow_network_egress),
                allow_subprocess_spawning: Ok(value.allow_subprocess_spawning),
                authorized_bytecode_hashes: Ok(value.authorized_bytecode_hashes),
                execution_runtime: Ok(value.execution_runtime),
                max_ttl_seconds: Ok(value.max_ttl_seconds),
                max_vram_mb: Ok(value.max_vram_mb),
                partition_cid: Ok(value.partition_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicArgumentClaimState {
        claim_cid: ::std::result::Result<super::ClaimCid, ::std::string::String>,
        proponent_cid: ::std::result::Result<super::ProponentCid, ::std::string::String>,
        text_chunk: ::std::result::Result<super::TextChunk, ::std::string::String>,
        warrants: ::std::result::Result<
            ::std::vec::Vec<super::EvidentiaryWarrantState>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicArgumentClaimState {
        fn default() -> Self {
            Self {
                claim_cid: Err("no value supplied for claim_cid".to_string()),
                proponent_cid: Err("no value supplied for proponent_cid".to_string()),
                text_chunk: Err("no value supplied for text_chunk".to_string()),
                warrants: Ok(Default::default()),
            }
        }
    }
    impl EpistemicArgumentClaimState {
        pub fn claim_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ClaimCid>,
            T::Error: ::std::fmt::Display,
        {
            self.claim_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for claim_cid: {e}"));
            self
        }
        pub fn proponent_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProponentCid>,
            T::Error: ::std::fmt::Display,
        {
            self.proponent_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proponent_cid: {e}"));
            self
        }
        pub fn text_chunk<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TextChunk>,
            T::Error: ::std::fmt::Display,
        {
            self.text_chunk = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for text_chunk: {e}"));
            self
        }
        pub fn warrants<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EvidentiaryWarrantState>>,
            T::Error: ::std::fmt::Display,
        {
            self.warrants = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for warrants: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicArgumentClaimState> for super::EpistemicArgumentClaimState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicArgumentClaimState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                claim_cid: value.claim_cid?,
                proponent_cid: value.proponent_cid?,
                text_chunk: value.text_chunk?,
                warrants: value.warrants?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicArgumentClaimState> for EpistemicArgumentClaimState {
        fn from(value: super::EpistemicArgumentClaimState) -> Self {
            Self {
                claim_cid: Ok(value.claim_cid),
                proponent_cid: Ok(value.proponent_cid),
                text_chunk: Ok(value.text_chunk),
                warrants: Ok(value.warrants),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicArgumentGraphState {
        attacks: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::DefeasibleAttackEvent>,
            ::std::string::String,
        >,
        claims: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::EpistemicArgumentClaimState>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicArgumentGraphState {
        fn default() -> Self {
            Self {
                attacks: Ok(Default::default()),
                claims: Err("no value supplied for claims".to_string()),
            }
        }
    }
    impl EpistemicArgumentGraphState {
        pub fn attacks<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::DefeasibleAttackEvent>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.attacks = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for attacks: {e}"));
            self
        }
        pub fn claims<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::EpistemicArgumentClaimState,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.claims = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for claims: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicArgumentGraphState> for super::EpistemicArgumentGraphState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicArgumentGraphState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                attacks: value.attacks?,
                claims: value.claims?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicArgumentGraphState> for EpistemicArgumentGraphState {
        fn from(value: super::EpistemicArgumentGraphState) -> Self {
            Self {
                attacks: Ok(value.attacks),
                claims: Ok(value.claims),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicAttentionState {
        direction_unit_vector:
            ::std::result::Result<[::serde_json::Value; 3usize], ::std::string::String>,
        hardware_gaze_signature: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        intersected_node_cids:
            ::std::result::Result<::std::vec::Vec<super::NodeCidState>, ::std::string::String>,
        origin: ::std::result::Result<super::Se3TransformProfile, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicAttentionState {
        fn default() -> Self {
            Self {
                direction_unit_vector: Err(
                    "no value supplied for direction_unit_vector".to_string()
                ),
                hardware_gaze_signature: Ok(Default::default()),
                intersected_node_cids: Ok(Default::default()),
                origin: Err("no value supplied for origin".to_string()),
            }
        }
    }
    impl EpistemicAttentionState {
        pub fn direction_unit_vector<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<[::serde_json::Value; 3usize]>,
            T::Error: ::std::fmt::Display,
        {
            self.direction_unit_vector = value.try_into().map_err(|e| {
                format!("error converting supplied value for direction_unit_vector: {e}")
            });
            self
        }
        pub fn hardware_gaze_signature<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.hardware_gaze_signature = value.try_into().map_err(|e| {
                format!("error converting supplied value for hardware_gaze_signature: {e}")
            });
            self
        }
        pub fn intersected_node_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.intersected_node_cids = value.try_into().map_err(|e| {
                format!("error converting supplied value for intersected_node_cids: {e}")
            });
            self
        }
        pub fn origin<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Se3TransformProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.origin = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for origin: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicAttentionState> for super::EpistemicAttentionState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicAttentionState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                direction_unit_vector: value.direction_unit_vector?,
                hardware_gaze_signature: value.hardware_gaze_signature?,
                intersected_node_cids: value.intersected_node_cids?,
                origin: value.origin?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicAttentionState> for EpistemicAttentionState {
        fn from(value: super::EpistemicAttentionState) -> Self {
            Self {
                direction_unit_vector: Ok(value.direction_unit_vector),
                hardware_gaze_signature: Ok(value.hardware_gaze_signature),
                intersected_node_cids: Ok(value.intersected_node_cids),
                origin: Ok(value.origin),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicAxiomState {
        directed_edge_class: ::std::result::Result<super::DirectedEdgeClass, ::std::string::String>,
        source_concept_cid: ::std::result::Result<super::SourceConceptCid, ::std::string::String>,
        target_concept_cid: ::std::result::Result<super::TargetConceptCid, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicAxiomState {
        fn default() -> Self {
            Self {
                directed_edge_class: Err("no value supplied for directed_edge_class".to_string()),
                source_concept_cid: Err("no value supplied for source_concept_cid".to_string()),
                target_concept_cid: Err("no value supplied for target_concept_cid".to_string()),
            }
        }
    }
    impl EpistemicAxiomState {
        pub fn directed_edge_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DirectedEdgeClass>,
            T::Error: ::std::fmt::Display,
        {
            self.directed_edge_class = value.try_into().map_err(|e| {
                format!("error converting supplied value for directed_edge_class: {e}")
            });
            self
        }
        pub fn source_concept_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceConceptCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_concept_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for source_concept_cid: {e}")
            });
            self
        }
        pub fn target_concept_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetConceptCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_concept_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_concept_cid: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicAxiomState> for super::EpistemicAxiomState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicAxiomState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                directed_edge_class: value.directed_edge_class?,
                source_concept_cid: value.source_concept_cid?,
                target_concept_cid: value.target_concept_cid?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicAxiomState> for EpistemicAxiomState {
        fn from(value: super::EpistemicAxiomState) -> Self {
            Self {
                directed_edge_class: Ok(value.directed_edge_class),
                source_concept_cid: Ok(value.source_concept_cid),
                target_concept_cid: Ok(value.target_concept_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicAxiomVerificationReceipt {
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        fact_score_passed: ::std::result::Result<bool, ::std::string::String>,
        formal_backing_receipt_cid: ::std::result::Result<
            ::std::option::Option<super::NodeCidState>,
            ::std::string::String,
        >,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        sequence_similarity_score: ::std::result::Result<f64, ::std::string::String>,
        source_prediction_cid:
            ::std::result::Result<super::SourcePredictionCid, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        zero_trust_receipt_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicAxiomVerificationReceipt {
        fn default() -> Self {
            Self {
                event_cid: Err("no value supplied for event_cid".to_string()),
                fact_score_passed: Err("no value supplied for fact_score_passed".to_string()),
                formal_backing_receipt_cid: Ok(Default::default()),
                prior_event_hash: Ok(Default::default()),
                sequence_similarity_score: Err(
                    "no value supplied for sequence_similarity_score".to_string()
                ),
                source_prediction_cid: Err(
                    "no value supplied for source_prediction_cid".to_string()
                ),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
                zero_trust_receipt_cid: Ok(Default::default()),
            }
        }
    }
    impl EpistemicAxiomVerificationReceipt {
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn fact_score_passed<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.fact_score_passed = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for fact_score_passed: {e}"));
            self
        }
        pub fn formal_backing_receipt_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.formal_backing_receipt_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for formal_backing_receipt_cid: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn sequence_similarity_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.sequence_similarity_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for sequence_similarity_score: {e}")
            });
            self
        }
        pub fn source_prediction_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourcePredictionCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_prediction_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for source_prediction_cid: {e}")
            });
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn zero_trust_receipt_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.zero_trust_receipt_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for zero_trust_receipt_cid: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicAxiomVerificationReceipt>
        for super::EpistemicAxiomVerificationReceipt
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicAxiomVerificationReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                event_cid: value.event_cid?,
                fact_score_passed: value.fact_score_passed?,
                formal_backing_receipt_cid: value.formal_backing_receipt_cid?,
                prior_event_hash: value.prior_event_hash?,
                sequence_similarity_score: value.sequence_similarity_score?,
                source_prediction_cid: value.source_prediction_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
                zero_trust_receipt_cid: value.zero_trust_receipt_cid?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicAxiomVerificationReceipt>
        for EpistemicAxiomVerificationReceipt
    {
        fn from(value: super::EpistemicAxiomVerificationReceipt) -> Self {
            Self {
                event_cid: Ok(value.event_cid),
                fact_score_passed: Ok(value.fact_score_passed),
                formal_backing_receipt_cid: Ok(value.formal_backing_receipt_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                sequence_similarity_score: Ok(value.sequence_similarity_score),
                source_prediction_cid: Ok(value.source_prediction_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
                zero_trust_receipt_cid: Ok(value.zero_trust_receipt_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicChainGraphState {
        chain_cid: ::std::result::Result<super::ChainCid, ::std::string::String>,
        semantic_leaves: ::std::result::Result<
            ::std::vec::Vec<super::EpistemicAxiomState>,
            ::std::string::String,
        >,
        syntactic_roots: ::std::result::Result<
            ::std::vec::Vec<super::SyntacticRootsItem>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicChainGraphState {
        fn default() -> Self {
            Self {
                chain_cid: Err("no value supplied for chain_cid".to_string()),
                semantic_leaves: Err("no value supplied for semantic_leaves".to_string()),
                syntactic_roots: Err("no value supplied for syntactic_roots".to_string()),
            }
        }
    }
    impl EpistemicChainGraphState {
        pub fn chain_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ChainCid>,
            T::Error: ::std::fmt::Display,
        {
            self.chain_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for chain_cid: {e}"));
            self
        }
        pub fn semantic_leaves<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EpistemicAxiomState>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_leaves = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_leaves: {e}"));
            self
        }
        pub fn syntactic_roots<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::SyntacticRootsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.syntactic_roots = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for syntactic_roots: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicChainGraphState> for super::EpistemicChainGraphState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicChainGraphState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                chain_cid: value.chain_cid?,
                semantic_leaves: value.semantic_leaves?,
                syntactic_roots: value.syntactic_roots?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicChainGraphState> for EpistemicChainGraphState {
        fn from(value: super::EpistemicChainGraphState) -> Self {
            Self {
                chain_cid: Ok(value.chain_cid),
                semantic_leaves: Ok(value.semantic_leaves),
                syntactic_roots: Ok(value.syntactic_roots),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicCompressionSla {
        max_allowed_entropy_loss: ::std::result::Result<f64, ::std::string::String>,
        minimum_fidelity_threshold: ::std::result::Result<f64, ::std::string::String>,
        required_grounding_density:
            ::std::result::Result<super::RequiredGroundingDensity, ::std::string::String>,
        strict_probability_retention:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicCompressionSla {
        fn default() -> Self {
            Self {
                max_allowed_entropy_loss: Err(
                    "no value supplied for max_allowed_entropy_loss".to_string()
                ),
                minimum_fidelity_threshold: Err(
                    "no value supplied for minimum_fidelity_threshold".to_string()
                ),
                required_grounding_density: Err(
                    "no value supplied for required_grounding_density".to_string()
                ),
                strict_probability_retention: Ok(Default::default()),
            }
        }
    }
    impl EpistemicCompressionSla {
        pub fn max_allowed_entropy_loss<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_allowed_entropy_loss = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_allowed_entropy_loss: {e}")
            });
            self
        }
        pub fn minimum_fidelity_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.minimum_fidelity_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for minimum_fidelity_threshold: {e}")
            });
            self
        }
        pub fn required_grounding_density<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RequiredGroundingDensity>,
            T::Error: ::std::fmt::Display,
        {
            self.required_grounding_density = value.try_into().map_err(|e| {
                format!("error converting supplied value for required_grounding_density: {e}")
            });
            self
        }
        pub fn strict_probability_retention<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.strict_probability_retention = value.try_into().map_err(|e| {
                format!("error converting supplied value for strict_probability_retention: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicCompressionSla> for super::EpistemicCompressionSla {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicCompressionSla,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_allowed_entropy_loss: value.max_allowed_entropy_loss?,
                minimum_fidelity_threshold: value.minimum_fidelity_threshold?,
                required_grounding_density: value.required_grounding_density?,
                strict_probability_retention: value.strict_probability_retention?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicCompressionSla> for EpistemicCompressionSla {
        fn from(value: super::EpistemicCompressionSla) -> Self {
            Self {
                max_allowed_entropy_loss: Ok(value.max_allowed_entropy_loss),
                minimum_fidelity_threshold: Ok(value.minimum_fidelity_threshold),
                required_grounding_density: Ok(value.required_grounding_density),
                strict_probability_retention: Ok(value.strict_probability_retention),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicConstraintPolicy {
        assertion_ast: ::std::result::Result<super::AssertionAst, ::std::string::String>,
        remediation_prompt: ::std::result::Result<super::RemediationPrompt, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicConstraintPolicy {
        fn default() -> Self {
            Self {
                assertion_ast: Err("no value supplied for assertion_ast".to_string()),
                remediation_prompt: Err("no value supplied for remediation_prompt".to_string()),
            }
        }
    }
    impl EpistemicConstraintPolicy {
        pub fn assertion_ast<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AssertionAst>,
            T::Error: ::std::fmt::Display,
        {
            self.assertion_ast = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for assertion_ast: {e}"));
            self
        }
        pub fn remediation_prompt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RemediationPrompt>,
            T::Error: ::std::fmt::Display,
        {
            self.remediation_prompt = value.try_into().map_err(|e| {
                format!("error converting supplied value for remediation_prompt: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicConstraintPolicy> for super::EpistemicConstraintPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicConstraintPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                assertion_ast: value.assertion_ast?,
                remediation_prompt: value.remediation_prompt?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicConstraintPolicy> for EpistemicConstraintPolicy {
        fn from(value: super::EpistemicConstraintPolicy) -> Self {
            Self {
                assertion_ast: Ok(value.assertion_ast),
                remediation_prompt: Ok(value.remediation_prompt),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicCurriculumManifest {
        curriculum_cid: ::std::result::Result<super::CurriculumCid, ::std::string::String>,
        tasks: ::std::result::Result<
            ::std::vec::Vec<super::EpistemicGroundedTaskManifest>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicCurriculumManifest {
        fn default() -> Self {
            Self {
                curriculum_cid: Err("no value supplied for curriculum_cid".to_string()),
                tasks: Err("no value supplied for tasks".to_string()),
            }
        }
    }
    impl EpistemicCurriculumManifest {
        pub fn curriculum_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CurriculumCid>,
            T::Error: ::std::fmt::Display,
        {
            self.curriculum_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for curriculum_cid: {e}"));
            self
        }
        pub fn tasks<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EpistemicGroundedTaskManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.tasks = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for tasks: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicCurriculumManifest> for super::EpistemicCurriculumManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicCurriculumManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                curriculum_cid: value.curriculum_cid?,
                tasks: value.tasks?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicCurriculumManifest> for EpistemicCurriculumManifest {
        fn from(value: super::EpistemicCurriculumManifest) -> Self {
            Self {
                curriculum_cid: Ok(value.curriculum_cid),
                tasks: Ok(value.tasks),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicDomainGraphManifest {
        graph_cid: ::std::result::Result<super::GraphCid, ::std::string::String>,
        verified_axioms: ::std::result::Result<
            ::std::vec::Vec<super::EpistemicAxiomState>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicDomainGraphManifest {
        fn default() -> Self {
            Self {
                graph_cid: Err("no value supplied for graph_cid".to_string()),
                verified_axioms: Err("no value supplied for verified_axioms".to_string()),
            }
        }
    }
    impl EpistemicDomainGraphManifest {
        pub fn graph_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::GraphCid>,
            T::Error: ::std::fmt::Display,
        {
            self.graph_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for graph_cid: {e}"));
            self
        }
        pub fn verified_axioms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EpistemicAxiomState>>,
            T::Error: ::std::fmt::Display,
        {
            self.verified_axioms = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for verified_axioms: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicDomainGraphManifest> for super::EpistemicDomainGraphManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicDomainGraphManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                graph_cid: value.graph_cid?,
                verified_axioms: value.verified_axioms?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicDomainGraphManifest> for EpistemicDomainGraphManifest {
        fn from(value: super::EpistemicDomainGraphManifest) -> Self {
            Self {
                graph_cid: Ok(value.graph_cid),
                verified_axioms: Ok(value.verified_axioms),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicEscalationContract {
        baseline_entropy_threshold: ::std::result::Result<f64, ::std::string::String>,
        max_escalation_tiers: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        test_time_multiplier: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicEscalationContract {
        fn default() -> Self {
            Self {
                baseline_entropy_threshold: Err(
                    "no value supplied for baseline_entropy_threshold".to_string()
                ),
                max_escalation_tiers: Err("no value supplied for max_escalation_tiers".to_string()),
                test_time_multiplier: Err("no value supplied for test_time_multiplier".to_string()),
            }
        }
    }
    impl EpistemicEscalationContract {
        pub fn baseline_entropy_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.baseline_entropy_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for baseline_entropy_threshold: {e}")
            });
            self
        }
        pub fn max_escalation_tiers<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_escalation_tiers = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_escalation_tiers: {e}")
            });
            self
        }
        pub fn test_time_multiplier<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.test_time_multiplier = value.try_into().map_err(|e| {
                format!("error converting supplied value for test_time_multiplier: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicEscalationContract> for super::EpistemicEscalationContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicEscalationContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                baseline_entropy_threshold: value.baseline_entropy_threshold?,
                max_escalation_tiers: value.max_escalation_tiers?,
                test_time_multiplier: value.test_time_multiplier?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicEscalationContract> for EpistemicEscalationContract {
        fn from(value: super::EpistemicEscalationContract) -> Self {
            Self {
                baseline_entropy_threshold: Ok(value.baseline_entropy_threshold),
                max_escalation_tiers: Ok(value.max_escalation_tiers),
                test_time_multiplier: Ok(value.test_time_multiplier),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicFlowStateReceipt {
        estimated_flow_value: ::std::result::Result<f64, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        source_trajectory_cid:
            ::std::result::Result<super::SourceTrajectoryCid, ::std::string::String>,
        terminal_reward_factorized: ::std::result::Result<bool, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicFlowStateReceipt {
        fn default() -> Self {
            Self {
                estimated_flow_value: Err("no value supplied for estimated_flow_value".to_string()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                prior_event_hash: Ok(Default::default()),
                source_trajectory_cid: Err(
                    "no value supplied for source_trajectory_cid".to_string()
                ),
                terminal_reward_factorized: Err(
                    "no value supplied for terminal_reward_factorized".to_string()
                ),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl EpistemicFlowStateReceipt {
        pub fn estimated_flow_value<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.estimated_flow_value = value.try_into().map_err(|e| {
                format!("error converting supplied value for estimated_flow_value: {e}")
            });
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn source_trajectory_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceTrajectoryCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_trajectory_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for source_trajectory_cid: {e}")
            });
            self
        }
        pub fn terminal_reward_factorized<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.terminal_reward_factorized = value.try_into().map_err(|e| {
                format!("error converting supplied value for terminal_reward_factorized: {e}")
            });
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicFlowStateReceipt> for super::EpistemicFlowStateReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicFlowStateReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                estimated_flow_value: value.estimated_flow_value?,
                event_cid: value.event_cid?,
                prior_event_hash: value.prior_event_hash?,
                source_trajectory_cid: value.source_trajectory_cid?,
                terminal_reward_factorized: value.terminal_reward_factorized?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicFlowStateReceipt> for EpistemicFlowStateReceipt {
        fn from(value: super::EpistemicFlowStateReceipt) -> Self {
            Self {
                estimated_flow_value: Ok(value.estimated_flow_value),
                event_cid: Ok(value.event_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                source_trajectory_cid: Ok(value.source_trajectory_cid),
                terminal_reward_factorized: Ok(value.terminal_reward_factorized),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicGroundedTaskManifest {
        task_cid: ::std::result::Result<super::TaskCid, ::std::string::String>,
        thinking_trace:
            ::std::result::Result<super::CognitiveReasoningTraceState, ::std::string::String>,
        topological_proof:
            ::std::result::Result<super::EpistemicTopologicalProofManifest, ::std::string::String>,
        verification_lock:
            ::std::result::Result<super::CognitiveDualVerificationReceipt, ::std::string::String>,
        vignette_payload: ::std::result::Result<super::VignettePayload, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicGroundedTaskManifest {
        fn default() -> Self {
            Self {
                task_cid: Err("no value supplied for task_cid".to_string()),
                thinking_trace: Err("no value supplied for thinking_trace".to_string()),
                topological_proof: Err("no value supplied for topological_proof".to_string()),
                verification_lock: Err("no value supplied for verification_lock".to_string()),
                vignette_payload: Err("no value supplied for vignette_payload".to_string()),
            }
        }
    }
    impl EpistemicGroundedTaskManifest {
        pub fn task_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TaskCid>,
            T::Error: ::std::fmt::Display,
        {
            self.task_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for task_cid: {e}"));
            self
        }
        pub fn thinking_trace<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CognitiveReasoningTraceState>,
            T::Error: ::std::fmt::Display,
        {
            self.thinking_trace = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for thinking_trace: {e}"));
            self
        }
        pub fn topological_proof<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EpistemicTopologicalProofManifest>,
            T::Error: ::std::fmt::Display,
        {
            self.topological_proof = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topological_proof: {e}"));
            self
        }
        pub fn verification_lock<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CognitiveDualVerificationReceipt>,
            T::Error: ::std::fmt::Display,
        {
            self.verification_lock = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for verification_lock: {e}"));
            self
        }
        pub fn vignette_payload<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VignettePayload>,
            T::Error: ::std::fmt::Display,
        {
            self.vignette_payload = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for vignette_payload: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicGroundedTaskManifest>
        for super::EpistemicGroundedTaskManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicGroundedTaskManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                task_cid: value.task_cid?,
                thinking_trace: value.thinking_trace?,
                topological_proof: value.topological_proof?,
                verification_lock: value.verification_lock?,
                vignette_payload: value.vignette_payload?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicGroundedTaskManifest> for EpistemicGroundedTaskManifest {
        fn from(value: super::EpistemicGroundedTaskManifest) -> Self {
            Self {
                task_cid: Ok(value.task_cid),
                thinking_trace: Ok(value.thinking_trace),
                topological_proof: Ok(value.topological_proof),
                verification_lock: Ok(value.verification_lock),
                vignette_payload: Ok(value.vignette_payload),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicGuardrailsManifest {
        colang_payload: ::std::result::Result<super::ColangPayload, ::std::string::String>,
        colang_version: ::std::result::Result<
            ::std::option::Option<super::ColangVersion>,
            ::std::string::String,
        >,
        severity:
            ::std::result::Result<::std::option::Option<super::Severity>, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicGuardrailsManifest {
        fn default() -> Self {
            Self {
                colang_payload: Err("no value supplied for colang_payload".to_string()),
                colang_version: Ok(Default::default()),
                severity: Ok(Default::default()),
            }
        }
    }
    impl EpistemicGuardrailsManifest {
        pub fn colang_payload<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ColangPayload>,
            T::Error: ::std::fmt::Display,
        {
            self.colang_payload = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for colang_payload: {e}"));
            self
        }
        pub fn colang_version<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ColangVersion>>,
            T::Error: ::std::fmt::Display,
        {
            self.colang_version = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for colang_version: {e}"));
            self
        }
        pub fn severity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::Severity>>,
            T::Error: ::std::fmt::Display,
        {
            self.severity = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for severity: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicGuardrailsManifest> for super::EpistemicGuardrailsManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicGuardrailsManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                colang_payload: value.colang_payload?,
                colang_version: value.colang_version?,
                severity: value.severity?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicGuardrailsManifest> for EpistemicGuardrailsManifest {
        fn from(value: super::EpistemicGuardrailsManifest) -> Self {
            Self {
                colang_payload: Ok(value.colang_payload),
                colang_version: Ok(value.colang_version),
                severity: Ok(value.severity),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicHydrationPolicy {
        lazy_fetch_timeout_ms: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        max_unfold_depth: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        truncation_strategy:
            ::std::result::Result<super::TruncationStrategy, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicHydrationPolicy {
        fn default() -> Self {
            Self {
                lazy_fetch_timeout_ms: Err(
                    "no value supplied for lazy_fetch_timeout_ms".to_string()
                ),
                max_unfold_depth: Err("no value supplied for max_unfold_depth".to_string()),
                truncation_strategy: Err("no value supplied for truncation_strategy".to_string()),
            }
        }
    }
    impl EpistemicHydrationPolicy {
        pub fn lazy_fetch_timeout_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.lazy_fetch_timeout_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for lazy_fetch_timeout_ms: {e}")
            });
            self
        }
        pub fn max_unfold_depth<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_unfold_depth = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_unfold_depth: {e}"));
            self
        }
        pub fn truncation_strategy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TruncationStrategy>,
            T::Error: ::std::fmt::Display,
        {
            self.truncation_strategy = value.try_into().map_err(|e| {
                format!("error converting supplied value for truncation_strategy: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicHydrationPolicy> for super::EpistemicHydrationPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicHydrationPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                lazy_fetch_timeout_ms: value.lazy_fetch_timeout_ms?,
                max_unfold_depth: value.max_unfold_depth?,
                truncation_strategy: value.truncation_strategy?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicHydrationPolicy> for EpistemicHydrationPolicy {
        fn from(value: super::EpistemicHydrationPolicy) -> Self {
            Self {
                lazy_fetch_timeout_ms: Ok(value.lazy_fetch_timeout_ms),
                max_unfold_depth: Ok(value.max_unfold_depth),
                truncation_strategy: Ok(value.truncation_strategy),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicLedgerState {
        active_cascades: ::std::result::Result<
            ::std::vec::Vec<super::DefeasibleCascadeEvent>,
            ::std::string::String,
        >,
        active_rollbacks:
            ::std::result::Result<::std::vec::Vec<super::RollbackIntent>, ::std::string::String>,
        checkpoints: ::std::result::Result<
            ::std::vec::Vec<super::TemporalCheckpointState>,
            ::std::string::String,
        >,
        crystallization_policy: ::std::result::Result<
            ::std::option::Option<super::CrystallizationPolicy>,
            ::std::string::String,
        >,
        defeasible_claims: ::std::result::Result<
            ::std::collections::HashMap<
                super::EpistemicLedgerStateDefeasibleClaimsKey,
                super::SemanticNodeState,
            >,
            ::std::string::String,
        >,
        eviction_policy: ::std::result::Result<
            ::std::option::Option<super::EvictionPolicy>,
            ::std::string::String,
        >,
        history:
            ::std::result::Result<::std::vec::Vec<super::AnyStateEvent>, ::std::string::String>,
        retracted_nodes: ::std::result::Result<
            ::std::vec::Vec<super::RetractedNodesItem>,
            ::std::string::String,
        >,
        truth_maintenance_policy: ::std::result::Result<
            ::std::option::Option<super::TruthMaintenancePolicy>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicLedgerState {
        fn default() -> Self {
            Self {
                active_cascades: Ok(Default::default()),
                active_rollbacks: Ok(Default::default()),
                checkpoints: Ok(Default::default()),
                crystallization_policy: Ok(Default::default()),
                defeasible_claims: Ok(Default::default()),
                eviction_policy: Ok(Default::default()),
                history: Err("no value supplied for history".to_string()),
                retracted_nodes: Ok(Default::default()),
                truth_maintenance_policy: Ok(Default::default()),
            }
        }
    }
    impl EpistemicLedgerState {
        pub fn active_cascades<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::DefeasibleCascadeEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.active_cascades = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for active_cascades: {e}"));
            self
        }
        pub fn active_rollbacks<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::RollbackIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.active_rollbacks = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for active_rollbacks: {e}"));
            self
        }
        pub fn checkpoints<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::TemporalCheckpointState>>,
            T::Error: ::std::fmt::Display,
        {
            self.checkpoints = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for checkpoints: {e}"));
            self
        }
        pub fn crystallization_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CrystallizationPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.crystallization_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for crystallization_policy: {e}")
            });
            self
        }
        pub fn defeasible_claims<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    super::EpistemicLedgerStateDefeasibleClaimsKey,
                    super::SemanticNodeState,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.defeasible_claims = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for defeasible_claims: {e}"));
            self
        }
        pub fn eviction_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EvictionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.eviction_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for eviction_policy: {e}"));
            self
        }
        pub fn history<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AnyStateEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.history = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for history: {e}"));
            self
        }
        pub fn retracted_nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::RetractedNodesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.retracted_nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for retracted_nodes: {e}"));
            self
        }
        pub fn truth_maintenance_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TruthMaintenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.truth_maintenance_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for truth_maintenance_policy: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicLedgerState> for super::EpistemicLedgerState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicLedgerState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                active_cascades: value.active_cascades?,
                active_rollbacks: value.active_rollbacks?,
                checkpoints: value.checkpoints?,
                crystallization_policy: value.crystallization_policy?,
                defeasible_claims: value.defeasible_claims?,
                eviction_policy: value.eviction_policy?,
                history: value.history?,
                retracted_nodes: value.retracted_nodes?,
                truth_maintenance_policy: value.truth_maintenance_policy?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicLedgerState> for EpistemicLedgerState {
        fn from(value: super::EpistemicLedgerState) -> Self {
            Self {
                active_cascades: Ok(value.active_cascades),
                active_rollbacks: Ok(value.active_rollbacks),
                checkpoints: Ok(value.checkpoints),
                crystallization_policy: Ok(value.crystallization_policy),
                defeasible_claims: Ok(value.defeasible_claims),
                eviction_policy: Ok(value.eviction_policy),
                history: Ok(value.history),
                retracted_nodes: Ok(value.retracted_nodes),
                truth_maintenance_policy: Ok(value.truth_maintenance_policy),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicLogEvent {
        context_profile: ::std::result::Result<
            ::std::option::Option<super::TelemetryContextProfile>,
            ::std::string::String,
        >,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        level: ::std::result::Result<super::Level, ::std::string::String>,
        message: ::std::result::Result<super::Message, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicLogEvent {
        fn default() -> Self {
            Self {
                context_profile: Ok(Default::default()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                level: Err("no value supplied for level".to_string()),
                message: Err("no value supplied for message".to_string()),
                prior_event_hash: Ok(Default::default()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl EpistemicLogEvent {
        pub fn context_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TelemetryContextProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.context_profile = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for context_profile: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn level<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Level>,
            T::Error: ::std::fmt::Display,
        {
            self.level = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for level: {e}"));
            self
        }
        pub fn message<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Message>,
            T::Error: ::std::fmt::Display,
        {
            self.message = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for message: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicLogEvent> for super::EpistemicLogEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicLogEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                context_profile: value.context_profile?,
                event_cid: value.event_cid?,
                level: value.level?,
                message: value.message?,
                prior_event_hash: value.prior_event_hash?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicLogEvent> for EpistemicLogEvent {
        fn from(value: super::EpistemicLogEvent) -> Self {
            Self {
                context_profile: Ok(value.context_profile),
                event_cid: Ok(value.event_cid),
                level: Ok(value.level),
                message: Ok(value.message),
                prior_event_hash: Ok(value.prior_event_hash),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicPromotionEvent {
        compression_ratio: ::std::result::Result<f64, ::std::string::String>,
        crystallized_semantic_node_cid:
            ::std::result::Result<super::CrystallizedSemanticNodeCid, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        source_episodic_event_cids: ::std::result::Result<
            ::std::vec::Vec<super::SourceEpisodicEventCidsItem>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicPromotionEvent {
        fn default() -> Self {
            Self {
                compression_ratio: Err("no value supplied for compression_ratio".to_string()),
                crystallized_semantic_node_cid: Err(
                    "no value supplied for crystallized_semantic_node_cid".to_string(),
                ),
                event_cid: Err("no value supplied for event_cid".to_string()),
                prior_event_hash: Ok(Default::default()),
                source_episodic_event_cids: Err(
                    "no value supplied for source_episodic_event_cids".to_string()
                ),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl EpistemicPromotionEvent {
        pub fn compression_ratio<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.compression_ratio = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for compression_ratio: {e}"));
            self
        }
        pub fn crystallized_semantic_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CrystallizedSemanticNodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.crystallized_semantic_node_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for crystallized_semantic_node_cid: {e}")
            });
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn source_episodic_event_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::SourceEpisodicEventCidsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.source_episodic_event_cids = value.try_into().map_err(|e| {
                format!("error converting supplied value for source_episodic_event_cids: {e}")
            });
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicPromotionEvent> for super::EpistemicPromotionEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicPromotionEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                compression_ratio: value.compression_ratio?,
                crystallized_semantic_node_cid: value.crystallized_semantic_node_cid?,
                event_cid: value.event_cid?,
                prior_event_hash: value.prior_event_hash?,
                source_episodic_event_cids: value.source_episodic_event_cids?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicPromotionEvent> for EpistemicPromotionEvent {
        fn from(value: super::EpistemicPromotionEvent) -> Self {
            Self {
                compression_ratio: Ok(value.compression_ratio),
                crystallized_semantic_node_cid: Ok(value.crystallized_semantic_node_cid),
                event_cid: Ok(value.event_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                source_episodic_event_cids: Ok(value.source_episodic_event_cids),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicProvenanceReceipt {
        derivation_mode: ::std::result::Result<super::DerivationModeProfile, ::std::string::String>,
        extracted_by: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        fidelity_receipt_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        justification_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        lineage_watermark: ::std::result::Result<
            ::std::option::Option<super::LineageWatermarkReceipt>,
            ::std::string::String,
        >,
        multimodal_anchor: ::std::result::Result<
            ::std::option::Option<super::MultimodalTokenAnchorState>,
            ::std::string::String,
        >,
        revision_loops_executed:
            ::std::result::Result<::std::option::Option<i64>, ::std::string::String>,
        source_artifact_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        source_event_cid: ::std::result::Result<super::SourceEventCid, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicProvenanceReceipt {
        fn default() -> Self {
            Self {
                derivation_mode: Err("no value supplied for derivation_mode".to_string()),
                extracted_by: Err("no value supplied for extracted_by".to_string()),
                fidelity_receipt_hash: Ok(Default::default()),
                justification_hash: Ok(Default::default()),
                lineage_watermark: Ok(Default::default()),
                multimodal_anchor: Ok(Default::default()),
                revision_loops_executed: Ok(Default::default()),
                source_artifact_cid: Ok(Default::default()),
                source_event_cid: Err("no value supplied for source_event_cid".to_string()),
            }
        }
    }
    impl EpistemicProvenanceReceipt {
        pub fn derivation_mode<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DerivationModeProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.derivation_mode = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for derivation_mode: {e}"));
            self
        }
        pub fn extracted_by<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.extracted_by = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for extracted_by: {e}"));
            self
        }
        pub fn fidelity_receipt_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.fidelity_receipt_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for fidelity_receipt_hash: {e}")
            });
            self
        }
        pub fn justification_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for justification_hash: {e}")
            });
            self
        }
        pub fn lineage_watermark<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LineageWatermarkReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.lineage_watermark = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lineage_watermark: {e}"));
            self
        }
        pub fn multimodal_anchor<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MultimodalTokenAnchorState>>,
            T::Error: ::std::fmt::Display,
        {
            self.multimodal_anchor = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for multimodal_anchor: {e}"));
            self
        }
        pub fn revision_loops_executed<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<i64>>,
            T::Error: ::std::fmt::Display,
        {
            self.revision_loops_executed = value.try_into().map_err(|e| {
                format!("error converting supplied value for revision_loops_executed: {e}")
            });
            self
        }
        pub fn source_artifact_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.source_artifact_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for source_artifact_cid: {e}")
            });
            self
        }
        pub fn source_event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceEventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_event_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicProvenanceReceipt> for super::EpistemicProvenanceReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicProvenanceReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                derivation_mode: value.derivation_mode?,
                extracted_by: value.extracted_by?,
                fidelity_receipt_hash: value.fidelity_receipt_hash?,
                justification_hash: value.justification_hash?,
                lineage_watermark: value.lineage_watermark?,
                multimodal_anchor: value.multimodal_anchor?,
                revision_loops_executed: value.revision_loops_executed?,
                source_artifact_cid: value.source_artifact_cid?,
                source_event_cid: value.source_event_cid?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicProvenanceReceipt> for EpistemicProvenanceReceipt {
        fn from(value: super::EpistemicProvenanceReceipt) -> Self {
            Self {
                derivation_mode: Ok(value.derivation_mode),
                extracted_by: Ok(value.extracted_by),
                fidelity_receipt_hash: Ok(value.fidelity_receipt_hash),
                justification_hash: Ok(value.justification_hash),
                lineage_watermark: Ok(value.lineage_watermark),
                multimodal_anchor: Ok(value.multimodal_anchor),
                revision_loops_executed: Ok(value.revision_loops_executed),
                source_artifact_cid: Ok(value.source_artifact_cid),
                source_event_cid: Ok(value.source_event_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicProxyState {
        proxy_cid: ::std::result::Result<super::ProxyCid, ::std::string::String>,
        structural_type: ::std::result::Result<super::StructuralType, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicProxyState {
        fn default() -> Self {
            Self {
                proxy_cid: Err("no value supplied for proxy_cid".to_string()),
                structural_type: Err("no value supplied for structural_type".to_string()),
            }
        }
    }
    impl EpistemicProxyState {
        pub fn proxy_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProxyCid>,
            T::Error: ::std::fmt::Display,
        {
            self.proxy_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proxy_cid: {e}"));
            self
        }
        pub fn structural_type<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StructuralType>,
            T::Error: ::std::fmt::Display,
        {
            self.structural_type = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for structural_type: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicProxyState> for super::EpistemicProxyState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicProxyState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                proxy_cid: value.proxy_cid?,
                structural_type: value.structural_type?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicProxyState> for EpistemicProxyState {
        fn from(value: super::EpistemicProxyState) -> Self {
            Self {
                proxy_cid: Ok(value.proxy_cid),
                structural_type: Ok(value.structural_type),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicProxyStateAny {
        proxy_cid: ::std::result::Result<super::ProxyCid, ::std::string::String>,
        structural_type: ::std::result::Result<super::StructuralType, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicProxyStateAny {
        fn default() -> Self {
            Self {
                proxy_cid: Err("no value supplied for proxy_cid".to_string()),
                structural_type: Err("no value supplied for structural_type".to_string()),
            }
        }
    }
    impl EpistemicProxyStateAny {
        pub fn proxy_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProxyCid>,
            T::Error: ::std::fmt::Display,
        {
            self.proxy_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proxy_cid: {e}"));
            self
        }
        pub fn structural_type<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StructuralType>,
            T::Error: ::std::fmt::Display,
        {
            self.structural_type = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for structural_type: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicProxyStateAny> for super::EpistemicProxyStateAny {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicProxyStateAny,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                proxy_cid: value.proxy_cid?,
                structural_type: value.structural_type?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicProxyStateAny> for EpistemicProxyStateAny {
        fn from(value: super::EpistemicProxyStateAny) -> Self {
            Self {
                proxy_cid: Ok(value.proxy_cid),
                structural_type: Ok(value.structural_type),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicQuarantineSnapshot {
        active_context: ::std::result::Result<
            ::std::collections::HashMap<
                ::std::string::String,
                super::EpistemicQuarantineSnapshotActiveContextValue,
            >,
            ::std::string::String,
        >,
        affordance_projection: ::std::result::Result<
            ::std::option::Option<super::OntologicalSurfaceProjectionManifest>,
            ::std::string::String,
        >,
        argumentation: ::std::result::Result<
            ::std::option::Option<super::EpistemicArgumentGraphState>,
            ::std::string::String,
        >,
        system_prompt: ::std::result::Result<super::SystemPrompt, ::std::string::String>,
        theory_of_mind_matrices: ::std::result::Result<
            ::std::vec::Vec<super::TheoryOfMindSnapshot>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicQuarantineSnapshot {
        fn default() -> Self {
            Self {
                active_context: Err("no value supplied for active_context".to_string()),
                affordance_projection: Ok(Default::default()),
                argumentation: Ok(Default::default()),
                system_prompt: Err("no value supplied for system_prompt".to_string()),
                theory_of_mind_matrices: Ok(Default::default()),
            }
        }
    }
    impl EpistemicQuarantineSnapshot {
        pub fn active_context<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::EpistemicQuarantineSnapshotActiveContextValue,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.active_context = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for active_context: {e}"));
            self
        }
        pub fn affordance_projection<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::OntologicalSurfaceProjectionManifest>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.affordance_projection = value.try_into().map_err(|e| {
                format!("error converting supplied value for affordance_projection: {e}")
            });
            self
        }
        pub fn argumentation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicArgumentGraphState>>,
            T::Error: ::std::fmt::Display,
        {
            self.argumentation = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for argumentation: {e}"));
            self
        }
        pub fn system_prompt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SystemPrompt>,
            T::Error: ::std::fmt::Display,
        {
            self.system_prompt = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for system_prompt: {e}"));
            self
        }
        pub fn theory_of_mind_matrices<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::TheoryOfMindSnapshot>>,
            T::Error: ::std::fmt::Display,
        {
            self.theory_of_mind_matrices = value.try_into().map_err(|e| {
                format!("error converting supplied value for theory_of_mind_matrices: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicQuarantineSnapshot> for super::EpistemicQuarantineSnapshot {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicQuarantineSnapshot,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                active_context: value.active_context?,
                affordance_projection: value.affordance_projection?,
                argumentation: value.argumentation?,
                system_prompt: value.system_prompt?,
                theory_of_mind_matrices: value.theory_of_mind_matrices?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicQuarantineSnapshot> for EpistemicQuarantineSnapshot {
        fn from(value: super::EpistemicQuarantineSnapshot) -> Self {
            Self {
                active_context: Ok(value.active_context),
                affordance_projection: Ok(value.affordance_projection),
                argumentation: Ok(value.argumentation),
                system_prompt: Ok(value.system_prompt),
                theory_of_mind_matrices: Ok(value.theory_of_mind_matrices),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicRejectionReceipt {
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        failed_projection_cid:
            ::std::result::Result<super::FailedProjectionCid, ::std::string::String>,
        kl_divergence_to_validity: ::std::result::Result<f64, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        receipt_cid: ::std::result::Result<super::ReceiptCid, ::std::string::String>,
        stochastic_mutation_gradient:
            ::std::result::Result<super::StochasticMutationGradient, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        violated_algebraic_constraint:
            ::std::result::Result<super::ViolatedAlgebraicConstraint, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicRejectionReceipt {
        fn default() -> Self {
            Self {
                event_cid: Err("no value supplied for event_cid".to_string()),
                failed_projection_cid: Err(
                    "no value supplied for failed_projection_cid".to_string()
                ),
                kl_divergence_to_validity: Err(
                    "no value supplied for kl_divergence_to_validity".to_string()
                ),
                prior_event_hash: Ok(Default::default()),
                receipt_cid: Err("no value supplied for receipt_cid".to_string()),
                stochastic_mutation_gradient: Err(
                    "no value supplied for stochastic_mutation_gradient".to_string(),
                ),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
                violated_algebraic_constraint: Err(
                    "no value supplied for violated_algebraic_constraint".to_string(),
                ),
            }
        }
    }
    impl EpistemicRejectionReceipt {
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn failed_projection_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FailedProjectionCid>,
            T::Error: ::std::fmt::Display,
        {
            self.failed_projection_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for failed_projection_cid: {e}")
            });
            self
        }
        pub fn kl_divergence_to_validity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.kl_divergence_to_validity = value.try_into().map_err(|e| {
                format!("error converting supplied value for kl_divergence_to_validity: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn receipt_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ReceiptCid>,
            T::Error: ::std::fmt::Display,
        {
            self.receipt_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for receipt_cid: {e}"));
            self
        }
        pub fn stochastic_mutation_gradient<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StochasticMutationGradient>,
            T::Error: ::std::fmt::Display,
        {
            self.stochastic_mutation_gradient = value.try_into().map_err(|e| {
                format!("error converting supplied value for stochastic_mutation_gradient: {e}")
            });
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn violated_algebraic_constraint<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ViolatedAlgebraicConstraint>,
            T::Error: ::std::fmt::Display,
        {
            self.violated_algebraic_constraint = value.try_into().map_err(|e| {
                format!("error converting supplied value for violated_algebraic_constraint: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicRejectionReceipt> for super::EpistemicRejectionReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicRejectionReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                event_cid: value.event_cid?,
                failed_projection_cid: value.failed_projection_cid?,
                kl_divergence_to_validity: value.kl_divergence_to_validity?,
                prior_event_hash: value.prior_event_hash?,
                receipt_cid: value.receipt_cid?,
                stochastic_mutation_gradient: value.stochastic_mutation_gradient?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
                violated_algebraic_constraint: value.violated_algebraic_constraint?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicRejectionReceipt> for EpistemicRejectionReceipt {
        fn from(value: super::EpistemicRejectionReceipt) -> Self {
            Self {
                event_cid: Ok(value.event_cid),
                failed_projection_cid: Ok(value.failed_projection_cid),
                kl_divergence_to_validity: Ok(value.kl_divergence_to_validity),
                prior_event_hash: Ok(value.prior_event_hash),
                receipt_cid: Ok(value.receipt_cid),
                stochastic_mutation_gradient: Ok(value.stochastic_mutation_gradient),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
                violated_algebraic_constraint: Ok(value.violated_algebraic_constraint),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicRigidityPolicy {
        max_retries_on_semantic_tax:
            ::std::result::Result<::std::option::Option<i64>, ::std::string::String>,
        maximum_latency_ms:
            ::std::result::Result<::std::option::Option<u64>, ::std::string::String>,
        minimum_rigidity_tier:
            ::std::result::Result<::std::option::Option<u8>, ::std::string::String>,
        minimum_vram_gb: ::std::result::Result<::std::option::Option<u64>, ::std::string::String>,
        permitted_remote_decoding_protocols: ::std::result::Result<
            ::std::vec::Vec<super::PermittedRemoteDecodingProtocolsItem>,
            ::std::string::String,
        >,
        required_epistemic_security: ::std::result::Result<
            ::std::option::Option<super::EpistemicSecurityPolicy>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicRigidityPolicy {
        fn default() -> Self {
            Self {
                max_retries_on_semantic_tax: Ok(Default::default()),
                maximum_latency_ms: Ok(Default::default()),
                minimum_rigidity_tier: Ok(Default::default()),
                minimum_vram_gb: Ok(Default::default()),
                permitted_remote_decoding_protocols: Ok(Default::default()),
                required_epistemic_security: Ok(Default::default()),
            }
        }
    }
    impl EpistemicRigidityPolicy {
        pub fn max_retries_on_semantic_tax<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<i64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_retries_on_semantic_tax = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_retries_on_semantic_tax: {e}")
            });
            self
        }
        pub fn maximum_latency_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.maximum_latency_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for maximum_latency_ms: {e}")
            });
            self
        }
        pub fn minimum_rigidity_tier<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<u8>>,
            T::Error: ::std::fmt::Display,
        {
            self.minimum_rigidity_tier = value.try_into().map_err(|e| {
                format!("error converting supplied value for minimum_rigidity_tier: {e}")
            });
            self
        }
        pub fn minimum_vram_gb<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.minimum_vram_gb = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for minimum_vram_gb: {e}"));
            self
        }
        pub fn permitted_remote_decoding_protocols<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::vec::Vec<super::PermittedRemoteDecodingProtocolsItem>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.permitted_remote_decoding_protocols = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for permitted_remote_decoding_protocols: {e}"
                )
            });
            self
        }
        pub fn required_epistemic_security<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicSecurityPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.required_epistemic_security = value.try_into().map_err(|e| {
                format!("error converting supplied value for required_epistemic_security: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicRigidityPolicy> for super::EpistemicRigidityPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicRigidityPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_retries_on_semantic_tax: value.max_retries_on_semantic_tax?,
                maximum_latency_ms: value.maximum_latency_ms?,
                minimum_rigidity_tier: value.minimum_rigidity_tier?,
                minimum_vram_gb: value.minimum_vram_gb?,
                permitted_remote_decoding_protocols: value.permitted_remote_decoding_protocols?,
                required_epistemic_security: value.required_epistemic_security?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicRigidityPolicy> for EpistemicRigidityPolicy {
        fn from(value: super::EpistemicRigidityPolicy) -> Self {
            Self {
                max_retries_on_semantic_tax: Ok(value.max_retries_on_semantic_tax),
                maximum_latency_ms: Ok(value.maximum_latency_ms),
                minimum_rigidity_tier: Ok(value.minimum_rigidity_tier),
                minimum_vram_gb: Ok(value.minimum_vram_gb),
                permitted_remote_decoding_protocols: Ok(value.permitted_remote_decoding_protocols),
                required_epistemic_security: Ok(value.required_epistemic_security),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicScanningPolicy {
        action_on_gap: ::std::result::Result<super::ActionOnGap, ::std::string::String>,
        active: ::std::result::Result<bool, ::std::string::String>,
        dissonance_threshold: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicScanningPolicy {
        fn default() -> Self {
            Self {
                action_on_gap: Err("no value supplied for action_on_gap".to_string()),
                active: Err("no value supplied for active".to_string()),
                dissonance_threshold: Err("no value supplied for dissonance_threshold".to_string()),
            }
        }
    }
    impl EpistemicScanningPolicy {
        pub fn action_on_gap<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ActionOnGap>,
            T::Error: ::std::fmt::Display,
        {
            self.action_on_gap = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for action_on_gap: {e}"));
            self
        }
        pub fn active<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.active = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for active: {e}"));
            self
        }
        pub fn dissonance_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.dissonance_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for dissonance_threshold: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicScanningPolicy> for super::EpistemicScanningPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicScanningPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                action_on_gap: value.action_on_gap?,
                active: value.active?,
                dissonance_threshold: value.dissonance_threshold?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicScanningPolicy> for EpistemicScanningPolicy {
        fn from(value: super::EpistemicScanningPolicy) -> Self {
            Self {
                action_on_gap: Ok(value.action_on_gap),
                active: Ok(value.active),
                dissonance_threshold: Ok(value.dissonance_threshold),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicSecurityProfile {
        clearance_tiers: ::std::result::Result<::std::vec::Vec<i64>, ::std::string::String>,
        egress_obfuscation:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        epistemic_security: ::std::result::Result<
            ::std::option::Option<super::EpistemicSecurityPolicy>,
            ::std::string::String,
        >,
        network_boundary: ::std::result::Result<
            ::std::option::Option<super::NetworkBoundary>,
            ::std::string::String,
        >,
        network_isolation:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        pii_quarantine_required:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicSecurityProfile {
        fn default() -> Self {
            Self {
                clearance_tiers: Ok(Default::default()),
                egress_obfuscation: Ok(Default::default()),
                epistemic_security: Ok(Default::default()),
                network_boundary: Ok(Default::default()),
                network_isolation: Ok(Default::default()),
                pii_quarantine_required: Ok(Default::default()),
            }
        }
    }
    impl EpistemicSecurityProfile {
        pub fn clearance_tiers<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<i64>>,
            T::Error: ::std::fmt::Display,
        {
            self.clearance_tiers = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for clearance_tiers: {e}"));
            self
        }
        pub fn egress_obfuscation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.egress_obfuscation = value.try_into().map_err(|e| {
                format!("error converting supplied value for egress_obfuscation: {e}")
            });
            self
        }
        pub fn epistemic_security<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicSecurityPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_security = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_security: {e}")
            });
            self
        }
        pub fn network_boundary<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NetworkBoundary>>,
            T::Error: ::std::fmt::Display,
        {
            self.network_boundary = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for network_boundary: {e}"));
            self
        }
        pub fn network_isolation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.network_isolation = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for network_isolation: {e}"));
            self
        }
        pub fn pii_quarantine_required<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.pii_quarantine_required = value.try_into().map_err(|e| {
                format!("error converting supplied value for pii_quarantine_required: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicSecurityProfile> for super::EpistemicSecurityProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicSecurityProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                clearance_tiers: value.clearance_tiers?,
                egress_obfuscation: value.egress_obfuscation?,
                epistemic_security: value.epistemic_security?,
                network_boundary: value.network_boundary?,
                network_isolation: value.network_isolation?,
                pii_quarantine_required: value.pii_quarantine_required?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicSecurityProfile> for EpistemicSecurityProfile {
        fn from(value: super::EpistemicSecurityProfile) -> Self {
            Self {
                clearance_tiers: Ok(value.clearance_tiers),
                egress_obfuscation: Ok(value.egress_obfuscation),
                epistemic_security: Ok(value.epistemic_security),
                network_boundary: Ok(value.network_boundary),
                network_isolation: Ok(value.network_isolation),
                pii_quarantine_required: Ok(value.pii_quarantine_required),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicSeedInjectionPolicy {
        relation_diversity_bucket_size:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        similarity_threshold_alpha: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicSeedInjectionPolicy {
        fn default() -> Self {
            Self {
                relation_diversity_bucket_size: Err(
                    "no value supplied for relation_diversity_bucket_size".to_string(),
                ),
                similarity_threshold_alpha: Err(
                    "no value supplied for similarity_threshold_alpha".to_string()
                ),
            }
        }
    }
    impl EpistemicSeedInjectionPolicy {
        pub fn relation_diversity_bucket_size<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.relation_diversity_bucket_size = value.try_into().map_err(|e| {
                format!("error converting supplied value for relation_diversity_bucket_size: {e}")
            });
            self
        }
        pub fn similarity_threshold_alpha<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.similarity_threshold_alpha = value.try_into().map_err(|e| {
                format!("error converting supplied value for similarity_threshold_alpha: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicSeedInjectionPolicy> for super::EpistemicSeedInjectionPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicSeedInjectionPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                relation_diversity_bucket_size: value.relation_diversity_bucket_size?,
                similarity_threshold_alpha: value.similarity_threshold_alpha?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicSeedInjectionPolicy> for EpistemicSeedInjectionPolicy {
        fn from(value: super::EpistemicSeedInjectionPolicy) -> Self {
            Self {
                relation_diversity_bucket_size: Ok(value.relation_diversity_bucket_size),
                similarity_threshold_alpha: Ok(value.similarity_threshold_alpha),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicSopManifest {
        chronological_flow_edges: ::std::result::Result<
            ::std::vec::Vec<[::serde_json::Value; 2usize]>,
            ::std::string::String,
        >,
        cognitive_steps: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::CognitiveStateProfile>,
            ::std::string::String,
        >,
        prm_evaluations: ::std::result::Result<
            ::std::vec::Vec<super::ProcessRewardContract>,
            ::std::string::String,
        >,
        sop_cid: ::std::result::Result<super::SopCid, ::std::string::String>,
        structural_grammar_hashes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, ::std::string::String>,
            ::std::string::String,
        >,
        target_persona: ::std::result::Result<super::ProfileCidState, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicSopManifest {
        fn default() -> Self {
            Self {
                chronological_flow_edges: Err(
                    "no value supplied for chronological_flow_edges".to_string()
                ),
                cognitive_steps: Err("no value supplied for cognitive_steps".to_string()),
                prm_evaluations: Ok(Default::default()),
                sop_cid: Err("no value supplied for sop_cid".to_string()),
                structural_grammar_hashes: Err(
                    "no value supplied for structural_grammar_hashes".to_string()
                ),
                target_persona: Err("no value supplied for target_persona".to_string()),
            }
        }
    }
    impl EpistemicSopManifest {
        pub fn chronological_flow_edges<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<[::serde_json::Value; 2usize]>>,
            T::Error: ::std::fmt::Display,
        {
            self.chronological_flow_edges = value.try_into().map_err(|e| {
                format!("error converting supplied value for chronological_flow_edges: {e}")
            });
            self
        }
        pub fn cognitive_steps<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::CognitiveStateProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.cognitive_steps = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for cognitive_steps: {e}"));
            self
        }
        pub fn prm_evaluations<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ProcessRewardContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.prm_evaluations = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prm_evaluations: {e}"));
            self
        }
        pub fn sop_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SopCid>,
            T::Error: ::std::fmt::Display,
        {
            self.sop_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for sop_cid: {e}"));
            self
        }
        pub fn structural_grammar_hashes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, ::std::string::String>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.structural_grammar_hashes = value.try_into().map_err(|e| {
                format!("error converting supplied value for structural_grammar_hashes: {e}")
            });
            self
        }
        pub fn target_persona<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProfileCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_persona = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_persona: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicSopManifest> for super::EpistemicSopManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicSopManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                chronological_flow_edges: value.chronological_flow_edges?,
                cognitive_steps: value.cognitive_steps?,
                prm_evaluations: value.prm_evaluations?,
                sop_cid: value.sop_cid?,
                structural_grammar_hashes: value.structural_grammar_hashes?,
                target_persona: value.target_persona?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicSopManifest> for EpistemicSopManifest {
        fn from(value: super::EpistemicSopManifest) -> Self {
            Self {
                chronological_flow_edges: Ok(value.chronological_flow_edges),
                cognitive_steps: Ok(value.cognitive_steps),
                prm_evaluations: Ok(value.prm_evaluations),
                sop_cid: Ok(value.sop_cid),
                structural_grammar_hashes: Ok(value.structural_grammar_hashes),
                target_persona: Ok(value.target_persona),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicStarvationEvent {
        diagnostic_reason: ::std::result::Result<super::DiagnosticReason, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        failed_citations: ::std::result::Result<
            ::std::vec::Vec<super::EvidentiaryCitationState>,
            ::std::string::String,
        >,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        starved_edge_cid: ::std::result::Result<super::StarvedEdgeCid, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicStarvationEvent {
        fn default() -> Self {
            Self {
                diagnostic_reason: Err("no value supplied for diagnostic_reason".to_string()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                failed_citations: Err("no value supplied for failed_citations".to_string()),
                prior_event_hash: Ok(Default::default()),
                starved_edge_cid: Err("no value supplied for starved_edge_cid".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl EpistemicStarvationEvent {
        pub fn diagnostic_reason<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DiagnosticReason>,
            T::Error: ::std::fmt::Display,
        {
            self.diagnostic_reason = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for diagnostic_reason: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn failed_citations<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EvidentiaryCitationState>>,
            T::Error: ::std::fmt::Display,
        {
            self.failed_citations = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for failed_citations: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn starved_edge_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StarvedEdgeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.starved_edge_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for starved_edge_cid: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicStarvationEvent> for super::EpistemicStarvationEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicStarvationEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                diagnostic_reason: value.diagnostic_reason?,
                event_cid: value.event_cid?,
                failed_citations: value.failed_citations?,
                prior_event_hash: value.prior_event_hash?,
                starved_edge_cid: value.starved_edge_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicStarvationEvent> for EpistemicStarvationEvent {
        fn from(value: super::EpistemicStarvationEvent) -> Self {
            Self {
                diagnostic_reason: Ok(value.diagnostic_reason),
                event_cid: Ok(value.event_cid),
                failed_citations: Ok(value.failed_citations),
                prior_event_hash: Ok(value.prior_event_hash),
                starved_edge_cid: Ok(value.starved_edge_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicTelemetryEvent {
        dwell_duration_ms: ::std::result::Result<::std::option::Option<u64>, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        interaction_modality:
            ::std::result::Result<super::InteractionModality, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        spatial_coordinates: ::std::result::Result<
            ::std::option::Option<super::Se3TransformProfile>,
            ::std::string::String,
        >,
        target_node_cid: ::std::result::Result<super::TargetNodeCid, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicTelemetryEvent {
        fn default() -> Self {
            Self {
                dwell_duration_ms: Ok(Default::default()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                interaction_modality: Err("no value supplied for interaction_modality".to_string()),
                prior_event_hash: Ok(Default::default()),
                spatial_coordinates: Ok(Default::default()),
                target_node_cid: Err("no value supplied for target_node_cid".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl EpistemicTelemetryEvent {
        pub fn dwell_duration_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.dwell_duration_ms = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for dwell_duration_ms: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn interaction_modality<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::InteractionModality>,
            T::Error: ::std::fmt::Display,
        {
            self.interaction_modality = value.try_into().map_err(|e| {
                format!("error converting supplied value for interaction_modality: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn spatial_coordinates<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::Se3TransformProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.spatial_coordinates = value.try_into().map_err(|e| {
                format!("error converting supplied value for spatial_coordinates: {e}")
            });
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetNodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicTelemetryEvent> for super::EpistemicTelemetryEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicTelemetryEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                dwell_duration_ms: value.dwell_duration_ms?,
                event_cid: value.event_cid?,
                interaction_modality: value.interaction_modality?,
                prior_event_hash: value.prior_event_hash?,
                spatial_coordinates: value.spatial_coordinates?,
                target_node_cid: value.target_node_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicTelemetryEvent> for EpistemicTelemetryEvent {
        fn from(value: super::EpistemicTelemetryEvent) -> Self {
            Self {
                dwell_duration_ms: Ok(value.dwell_duration_ms),
                event_cid: Ok(value.event_cid),
                interaction_modality: Ok(value.interaction_modality),
                prior_event_hash: Ok(value.prior_event_hash),
                spatial_coordinates: Ok(value.spatial_coordinates),
                target_node_cid: Ok(value.target_node_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicTopologicalProofManifest {
        axiomatic_chain: ::std::result::Result<
            ::std::vec::Vec<super::EpistemicAxiomState>,
            ::std::string::String,
        >,
        proof_cid: ::std::result::Result<super::ProofCid, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicTopologicalProofManifest {
        fn default() -> Self {
            Self {
                axiomatic_chain: Err("no value supplied for axiomatic_chain".to_string()),
                proof_cid: Err("no value supplied for proof_cid".to_string()),
            }
        }
    }
    impl EpistemicTopologicalProofManifest {
        pub fn axiomatic_chain<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EpistemicAxiomState>>,
            T::Error: ::std::fmt::Display,
        {
            self.axiomatic_chain = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for axiomatic_chain: {e}"));
            self
        }
        pub fn proof_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProofCid>,
            T::Error: ::std::fmt::Display,
        {
            self.proof_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proof_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicTopologicalProofManifest>
        for super::EpistemicTopologicalProofManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicTopologicalProofManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                axiomatic_chain: value.axiomatic_chain?,
                proof_cid: value.proof_cid?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicTopologicalProofManifest>
        for EpistemicTopologicalProofManifest
    {
        fn from(value: super::EpistemicTopologicalProofManifest) -> Self {
            Self {
                axiomatic_chain: Ok(value.axiomatic_chain),
                proof_cid: Ok(value.proof_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicTransmutationTask {
        artifact_event_cid: ::std::result::Result<super::ArtifactEventCid, ::std::string::String>,
        execution_cost_budget_magnitude:
            ::std::result::Result<::std::option::Option<u64>, ::std::string::String>,
        optical_governance: ::std::result::Result<
            ::std::option::Option<super::OpticalParsingSla>,
            ::std::string::String,
        >,
        schema_governance: ::std::result::Result<
            ::std::option::Option<super::SchemaDrivenExtractionSla>,
            ::std::string::String,
        >,
        target_modalities: ::std::result::Result<
            ::std::vec::Vec<super::TargetModalitiesItem>,
            ::std::string::String,
        >,
        task_cid: ::std::result::Result<super::TaskCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicTransmutationTask {
        fn default() -> Self {
            Self {
                artifact_event_cid: Err("no value supplied for artifact_event_cid".to_string()),
                execution_cost_budget_magnitude: Ok(Default::default()),
                optical_governance: Ok(Default::default()),
                schema_governance: Ok(Default::default()),
                target_modalities: Err("no value supplied for target_modalities".to_string()),
                task_cid: Err("no value supplied for task_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl EpistemicTransmutationTask {
        pub fn artifact_event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ArtifactEventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.artifact_event_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for artifact_event_cid: {e}")
            });
            self
        }
        pub fn execution_cost_budget_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.execution_cost_budget_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for execution_cost_budget_magnitude: {e}")
            });
            self
        }
        pub fn optical_governance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::OpticalParsingSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.optical_governance = value.try_into().map_err(|e| {
                format!("error converting supplied value for optical_governance: {e}")
            });
            self
        }
        pub fn schema_governance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SchemaDrivenExtractionSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.schema_governance = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for schema_governance: {e}"));
            self
        }
        pub fn target_modalities<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::TargetModalitiesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.target_modalities = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_modalities: {e}"));
            self
        }
        pub fn task_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TaskCid>,
            T::Error: ::std::fmt::Display,
        {
            self.task_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for task_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicTransmutationTask> for super::EpistemicTransmutationTask {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicTransmutationTask,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                artifact_event_cid: value.artifact_event_cid?,
                execution_cost_budget_magnitude: value.execution_cost_budget_magnitude?,
                optical_governance: value.optical_governance?,
                schema_governance: value.schema_governance?,
                target_modalities: value.target_modalities?,
                task_cid: value.task_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicTransmutationTask> for EpistemicTransmutationTask {
        fn from(value: super::EpistemicTransmutationTask) -> Self {
            Self {
                artifact_event_cid: Ok(value.artifact_event_cid),
                execution_cost_budget_magnitude: Ok(value.execution_cost_budget_magnitude),
                optical_governance: Ok(value.optical_governance),
                schema_governance: Ok(value.schema_governance),
                target_modalities: Ok(value.target_modalities),
                task_cid: Ok(value.task_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicUpsamplingTask {
        justification_vectors: ::std::result::Result<
            ::std::vec::Vec<super::JustificationVectorsItem>,
            ::std::string::String,
        >,
        source_entity:
            ::std::result::Result<super::ContextualizedSourceState, ::std::string::String>,
        target_ontological_granularity:
            ::std::result::Result<super::TargetOntologicalGranularity, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        upsampling_confidence_threshold: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicUpsamplingTask {
        fn default() -> Self {
            Self {
                justification_vectors: Err(
                    "no value supplied for justification_vectors".to_string()
                ),
                source_entity: Err("no value supplied for source_entity".to_string()),
                target_ontological_granularity: Err(
                    "no value supplied for target_ontological_granularity".to_string(),
                ),
                topology_class: Ok(Default::default()),
                upsampling_confidence_threshold: Err(
                    "no value supplied for upsampling_confidence_threshold".to_string(),
                ),
            }
        }
    }
    impl EpistemicUpsamplingTask {
        pub fn justification_vectors<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::JustificationVectorsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification_vectors = value.try_into().map_err(|e| {
                format!("error converting supplied value for justification_vectors: {e}")
            });
            self
        }
        pub fn source_entity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ContextualizedSourceState>,
            T::Error: ::std::fmt::Display,
        {
            self.source_entity = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_entity: {e}"));
            self
        }
        pub fn target_ontological_granularity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetOntologicalGranularity>,
            T::Error: ::std::fmt::Display,
        {
            self.target_ontological_granularity = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_ontological_granularity: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn upsampling_confidence_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.upsampling_confidence_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for upsampling_confidence_threshold: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicUpsamplingTask> for super::EpistemicUpsamplingTask {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicUpsamplingTask,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                justification_vectors: value.justification_vectors?,
                source_entity: value.source_entity?,
                target_ontological_granularity: value.target_ontological_granularity?,
                topology_class: value.topology_class?,
                upsampling_confidence_threshold: value.upsampling_confidence_threshold?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicUpsamplingTask> for EpistemicUpsamplingTask {
        fn from(value: super::EpistemicUpsamplingTask) -> Self {
            Self {
                justification_vectors: Ok(value.justification_vectors),
                source_entity: Ok(value.source_entity),
                target_ontological_granularity: Ok(value.target_ontological_granularity),
                topology_class: Ok(value.topology_class),
                upsampling_confidence_threshold: Ok(value.upsampling_confidence_threshold),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicZeroTrustContract {
        intent_cid: ::std::result::Result<super::IntentCid, ::std::string::String>,
        max_planning_remediation_epochs:
            ::std::result::Result<::std::option::Option<u64>, ::std::string::String>,
        schema_blueprint_name:
            ::std::result::Result<super::SchemaBlueprintName, ::std::string::String>,
        semantic_planning_task:
            ::std::result::Result<super::SemanticPlanningTask, ::std::string::String>,
        structural_post_conditions: ::std::result::Result<
            ::std::vec::Vec<super::EpistemicConstraintPolicy>,
            ::std::string::String,
        >,
        structural_pre_conditions: ::std::result::Result<
            ::std::vec::Vec<super::EpistemicConstraintPolicy>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EpistemicZeroTrustContract {
        fn default() -> Self {
            Self {
                intent_cid: Err("no value supplied for intent_cid".to_string()),
                max_planning_remediation_epochs: Ok(Default::default()),
                schema_blueprint_name: Err(
                    "no value supplied for schema_blueprint_name".to_string()
                ),
                semantic_planning_task: Err(
                    "no value supplied for semantic_planning_task".to_string()
                ),
                structural_post_conditions: Ok(Default::default()),
                structural_pre_conditions: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl EpistemicZeroTrustContract {
        pub fn intent_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::IntentCid>,
            T::Error: ::std::fmt::Display,
        {
            self.intent_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for intent_cid: {e}"));
            self
        }
        pub fn max_planning_remediation_epochs<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_planning_remediation_epochs = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_planning_remediation_epochs: {e}")
            });
            self
        }
        pub fn schema_blueprint_name<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SchemaBlueprintName>,
            T::Error: ::std::fmt::Display,
        {
            self.schema_blueprint_name = value.try_into().map_err(|e| {
                format!("error converting supplied value for schema_blueprint_name: {e}")
            });
            self
        }
        pub fn semantic_planning_task<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SemanticPlanningTask>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_planning_task = value.try_into().map_err(|e| {
                format!("error converting supplied value for semantic_planning_task: {e}")
            });
            self
        }
        pub fn structural_post_conditions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EpistemicConstraintPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.structural_post_conditions = value.try_into().map_err(|e| {
                format!("error converting supplied value for structural_post_conditions: {e}")
            });
            self
        }
        pub fn structural_pre_conditions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EpistemicConstraintPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.structural_pre_conditions = value.try_into().map_err(|e| {
                format!("error converting supplied value for structural_pre_conditions: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicZeroTrustContract> for super::EpistemicZeroTrustContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicZeroTrustContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                intent_cid: value.intent_cid?,
                max_planning_remediation_epochs: value.max_planning_remediation_epochs?,
                schema_blueprint_name: value.schema_blueprint_name?,
                semantic_planning_task: value.semantic_planning_task?,
                structural_post_conditions: value.structural_post_conditions?,
                structural_pre_conditions: value.structural_pre_conditions?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicZeroTrustContract> for EpistemicZeroTrustContract {
        fn from(value: super::EpistemicZeroTrustContract) -> Self {
            Self {
                intent_cid: Ok(value.intent_cid),
                max_planning_remediation_epochs: Ok(value.max_planning_remediation_epochs),
                schema_blueprint_name: Ok(value.schema_blueprint_name),
                semantic_planning_task: Ok(value.semantic_planning_task),
                structural_post_conditions: Ok(value.structural_post_conditions),
                structural_pre_conditions: Ok(value.structural_pre_conditions),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EpistemicZeroTrustReceipt {
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        firewall_breach_detected:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        intent_reference_cid:
            ::std::result::Result<super::IntentReferenceCid, ::std::string::String>,
        llm_blind_plan_hash: ::std::result::Result<super::LlmBlindPlanHash, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        remediation_epochs_consumed: ::std::result::Result<i64, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        transmuted_payload_hash:
            ::std::result::Result<super::TransmutedPayloadHash, ::std::string::String>,
    }
    impl ::std::default::Default for EpistemicZeroTrustReceipt {
        fn default() -> Self {
            Self {
                event_cid: Err("no value supplied for event_cid".to_string()),
                firewall_breach_detected: Ok(Default::default()),
                intent_reference_cid: Err("no value supplied for intent_reference_cid".to_string()),
                llm_blind_plan_hash: Err("no value supplied for llm_blind_plan_hash".to_string()),
                prior_event_hash: Ok(Default::default()),
                remediation_epochs_consumed: Err(
                    "no value supplied for remediation_epochs_consumed".to_string(),
                ),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
                transmuted_payload_hash: Err(
                    "no value supplied for transmuted_payload_hash".to_string()
                ),
            }
        }
    }
    impl EpistemicZeroTrustReceipt {
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn firewall_breach_detected<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.firewall_breach_detected = value.try_into().map_err(|e| {
                format!("error converting supplied value for firewall_breach_detected: {e}")
            });
            self
        }
        pub fn intent_reference_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::IntentReferenceCid>,
            T::Error: ::std::fmt::Display,
        {
            self.intent_reference_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for intent_reference_cid: {e}")
            });
            self
        }
        pub fn llm_blind_plan_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::LlmBlindPlanHash>,
            T::Error: ::std::fmt::Display,
        {
            self.llm_blind_plan_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for llm_blind_plan_hash: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn remediation_epochs_consumed<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<i64>,
            T::Error: ::std::fmt::Display,
        {
            self.remediation_epochs_consumed = value.try_into().map_err(|e| {
                format!("error converting supplied value for remediation_epochs_consumed: {e}")
            });
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn transmuted_payload_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TransmutedPayloadHash>,
            T::Error: ::std::fmt::Display,
        {
            self.transmuted_payload_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for transmuted_payload_hash: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EpistemicZeroTrustReceipt> for super::EpistemicZeroTrustReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EpistemicZeroTrustReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                event_cid: value.event_cid?,
                firewall_breach_detected: value.firewall_breach_detected?,
                intent_reference_cid: value.intent_reference_cid?,
                llm_blind_plan_hash: value.llm_blind_plan_hash?,
                prior_event_hash: value.prior_event_hash?,
                remediation_epochs_consumed: value.remediation_epochs_consumed?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
                transmuted_payload_hash: value.transmuted_payload_hash?,
            })
        }
    }
    impl ::std::convert::From<super::EpistemicZeroTrustReceipt> for EpistemicZeroTrustReceipt {
        fn from(value: super::EpistemicZeroTrustReceipt) -> Self {
            Self {
                event_cid: Ok(value.event_cid),
                firewall_breach_detected: Ok(value.firewall_breach_detected),
                intent_reference_cid: Ok(value.intent_reference_cid),
                llm_blind_plan_hash: Ok(value.llm_blind_plan_hash),
                prior_event_hash: Ok(value.prior_event_hash),
                remediation_epochs_consumed: Ok(value.remediation_epochs_consumed),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
                transmuted_payload_hash: Ok(value.transmuted_payload_hash),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EscalationContract {
        max_latent_tokens_budget:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        max_test_time_compute_ms:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        uncertainty_escalation_threshold: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for EscalationContract {
        fn default() -> Self {
            Self {
                max_latent_tokens_budget: Err(
                    "no value supplied for max_latent_tokens_budget".to_string()
                ),
                max_test_time_compute_ms: Err(
                    "no value supplied for max_test_time_compute_ms".to_string()
                ),
                uncertainty_escalation_threshold: Err(
                    "no value supplied for uncertainty_escalation_threshold".to_string(),
                ),
            }
        }
    }
    impl EscalationContract {
        pub fn max_latent_tokens_budget<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_latent_tokens_budget = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_latent_tokens_budget: {e}")
            });
            self
        }
        pub fn max_test_time_compute_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_test_time_compute_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_test_time_compute_ms: {e}")
            });
            self
        }
        pub fn uncertainty_escalation_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.uncertainty_escalation_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for uncertainty_escalation_threshold: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EscalationContract> for super::EscalationContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EscalationContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_latent_tokens_budget: value.max_latent_tokens_budget?,
                max_test_time_compute_ms: value.max_test_time_compute_ms?,
                uncertainty_escalation_threshold: value.uncertainty_escalation_threshold?,
            })
        }
    }
    impl ::std::convert::From<super::EscalationContract> for EscalationContract {
        fn from(value: super::EscalationContract) -> Self {
            Self {
                max_latent_tokens_budget: Ok(value.max_latent_tokens_budget),
                max_test_time_compute_ms: Ok(value.max_test_time_compute_ms),
                uncertainty_escalation_threshold: Ok(value.uncertainty_escalation_threshold),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EscalationIntent {
        context_window_cids: ::std::result::Result<
            ::std::vec::Vec<super::ContextWindowCidsItem>,
            ::std::string::String,
        >,
        epistemic_deficit_description:
            ::std::result::Result<super::EpistemicDeficitDescription, ::std::string::String>,
        target_solver_urn: ::std::result::Result<super::TargetSolverUrn, ::std::string::String>,
        thermodynamic_budget: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EscalationIntent {
        fn default() -> Self {
            Self {
                context_window_cids: Err("no value supplied for context_window_cids".to_string()),
                epistemic_deficit_description: Err(
                    "no value supplied for epistemic_deficit_description".to_string(),
                ),
                target_solver_urn: Err("no value supplied for target_solver_urn".to_string()),
                thermodynamic_budget: Err("no value supplied for thermodynamic_budget".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl EscalationIntent {
        pub fn context_window_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ContextWindowCidsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.context_window_cids = value.try_into().map_err(|e| {
                format!("error converting supplied value for context_window_cids: {e}")
            });
            self
        }
        pub fn epistemic_deficit_description<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EpistemicDeficitDescription>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_deficit_description = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_deficit_description: {e}")
            });
            self
        }
        pub fn target_solver_urn<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetSolverUrn>,
            T::Error: ::std::fmt::Display,
        {
            self.target_solver_urn = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_solver_urn: {e}"));
            self
        }
        pub fn thermodynamic_budget<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.thermodynamic_budget = value.try_into().map_err(|e| {
                format!("error converting supplied value for thermodynamic_budget: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EscalationIntent> for super::EscalationIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EscalationIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                context_window_cids: value.context_window_cids?,
                epistemic_deficit_description: value.epistemic_deficit_description?,
                target_solver_urn: value.target_solver_urn?,
                thermodynamic_budget: value.thermodynamic_budget?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::EscalationIntent> for EscalationIntent {
        fn from(value: super::EscalationIntent) -> Self {
            Self {
                context_window_cids: Ok(value.context_window_cids),
                epistemic_deficit_description: Ok(value.epistemic_deficit_description),
                target_solver_urn: Ok(value.target_solver_urn),
                thermodynamic_budget: Ok(value.thermodynamic_budget),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EscrowPolicy {
        escrow_locked_magnitude: ::std::result::Result<u64, ::std::string::String>,
        refund_target_node_cid:
            ::std::result::Result<super::RefundTargetNodeCid, ::std::string::String>,
        release_condition_metric:
            ::std::result::Result<super::ReleaseConditionMetric, ::std::string::String>,
    }
    impl ::std::default::Default for EscrowPolicy {
        fn default() -> Self {
            Self {
                escrow_locked_magnitude: Err(
                    "no value supplied for escrow_locked_magnitude".to_string()
                ),
                refund_target_node_cid: Err(
                    "no value supplied for refund_target_node_cid".to_string()
                ),
                release_condition_metric: Err(
                    "no value supplied for release_condition_metric".to_string()
                ),
            }
        }
    }
    impl EscrowPolicy {
        pub fn escrow_locked_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.escrow_locked_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for escrow_locked_magnitude: {e}")
            });
            self
        }
        pub fn refund_target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RefundTargetNodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.refund_target_node_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for refund_target_node_cid: {e}")
            });
            self
        }
        pub fn release_condition_metric<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ReleaseConditionMetric>,
            T::Error: ::std::fmt::Display,
        {
            self.release_condition_metric = value.try_into().map_err(|e| {
                format!("error converting supplied value for release_condition_metric: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EscrowPolicy> for super::EscrowPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EscrowPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                escrow_locked_magnitude: value.escrow_locked_magnitude?,
                refund_target_node_cid: value.refund_target_node_cid?,
                release_condition_metric: value.release_condition_metric?,
            })
        }
    }
    impl ::std::convert::From<super::EscrowPolicy> for EscrowPolicy {
        fn from(value: super::EscrowPolicy) -> Self {
            Self {
                escrow_locked_magnitude: Ok(value.escrow_locked_magnitude),
                refund_target_node_cid: Ok(value.refund_target_node_cid),
                release_condition_metric: Ok(value.release_condition_metric),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EvaluatorOptimizerTopologyManifest {
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        epistemic_enforcement: ::std::result::Result<
            ::std::option::Option<super::TruthMaintenancePolicy>,
            ::std::string::String,
        >,
        evaluator_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        generator_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        lifecycle_phase: ::std::result::Result<
            ::std::option::Option<super::LifecyclePhase>,
            ::std::string::String,
        >,
        max_revision_loops: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        nodes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            ::std::string::String,
        >,
        observability: ::std::result::Result<
            ::std::option::Option<super::ObservabilityLodPolicy>,
            ::std::string::String,
        >,
        require_multimodal_grounding:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        semantic_flow: ::std::result::Result<
            ::std::option::Option<super::SemanticFlowPolicy>,
            ::std::string::String,
        >,
        shared_state_contract: ::std::result::Result<
            ::std::option::Option<super::StateContract>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EvaluatorOptimizerTopologyManifest {
        fn default() -> Self {
            Self {
                architectural_intent: Ok(Default::default()),
                epistemic_enforcement: Ok(Default::default()),
                evaluator_node_cid: Err("no value supplied for evaluator_node_cid".to_string()),
                generator_node_cid: Err("no value supplied for generator_node_cid".to_string()),
                justification: Ok(Default::default()),
                lifecycle_phase: Ok(Default::default()),
                max_revision_loops: Err("no value supplied for max_revision_loops".to_string()),
                nodes: Err("no value supplied for nodes".to_string()),
                observability: Ok(Default::default()),
                require_multimodal_grounding: Ok(Default::default()),
                semantic_flow: Ok(Default::default()),
                shared_state_contract: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl EvaluatorOptimizerTopologyManifest {
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn epistemic_enforcement<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TruthMaintenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_enforcement = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_enforcement: {e}")
            });
            self
        }
        pub fn evaluator_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.evaluator_node_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for evaluator_node_cid: {e}")
            });
            self
        }
        pub fn generator_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.generator_node_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for generator_node_cid: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn lifecycle_phase<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LifecyclePhase>>,
            T::Error: ::std::fmt::Display,
        {
            self.lifecycle_phase = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lifecycle_phase: {e}"));
            self
        }
        pub fn max_revision_loops<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_revision_loops = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_revision_loops: {e}")
            });
            self
        }
        pub fn nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for nodes: {e}"));
            self
        }
        pub fn observability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ObservabilityLodPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.observability = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for observability: {e}"));
            self
        }
        pub fn require_multimodal_grounding<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.require_multimodal_grounding = value.try_into().map_err(|e| {
                format!("error converting supplied value for require_multimodal_grounding: {e}")
            });
            self
        }
        pub fn semantic_flow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFlowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_flow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_flow: {e}"));
            self
        }
        pub fn shared_state_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.shared_state_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for shared_state_contract: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EvaluatorOptimizerTopologyManifest>
        for super::EvaluatorOptimizerTopologyManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EvaluatorOptimizerTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                architectural_intent: value.architectural_intent?,
                epistemic_enforcement: value.epistemic_enforcement?,
                evaluator_node_cid: value.evaluator_node_cid?,
                generator_node_cid: value.generator_node_cid?,
                justification: value.justification?,
                lifecycle_phase: value.lifecycle_phase?,
                max_revision_loops: value.max_revision_loops?,
                nodes: value.nodes?,
                observability: value.observability?,
                require_multimodal_grounding: value.require_multimodal_grounding?,
                semantic_flow: value.semantic_flow?,
                shared_state_contract: value.shared_state_contract?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::EvaluatorOptimizerTopologyManifest>
        for EvaluatorOptimizerTopologyManifest
    {
        fn from(value: super::EvaluatorOptimizerTopologyManifest) -> Self {
            Self {
                architectural_intent: Ok(value.architectural_intent),
                epistemic_enforcement: Ok(value.epistemic_enforcement),
                evaluator_node_cid: Ok(value.evaluator_node_cid),
                generator_node_cid: Ok(value.generator_node_cid),
                justification: Ok(value.justification),
                lifecycle_phase: Ok(value.lifecycle_phase),
                max_revision_loops: Ok(value.max_revision_loops),
                nodes: Ok(value.nodes),
                observability: Ok(value.observability),
                require_multimodal_grounding: Ok(value.require_multimodal_grounding),
                semantic_flow: Ok(value.semantic_flow),
                shared_state_contract: Ok(value.shared_state_contract),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EvictionPolicy {
        max_retained_tokens: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        protected_event_cids: ::std::result::Result<
            ::std::vec::Vec<super::ProtectedEventCidsItem>,
            ::std::string::String,
        >,
        strategy: ::std::result::Result<super::Strategy, ::std::string::String>,
    }
    impl ::std::default::Default for EvictionPolicy {
        fn default() -> Self {
            Self {
                max_retained_tokens: Err("no value supplied for max_retained_tokens".to_string()),
                protected_event_cids: Ok(Default::default()),
                strategy: Err("no value supplied for strategy".to_string()),
            }
        }
    }
    impl EvictionPolicy {
        pub fn max_retained_tokens<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_retained_tokens = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_retained_tokens: {e}")
            });
            self
        }
        pub fn protected_event_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ProtectedEventCidsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.protected_event_cids = value.try_into().map_err(|e| {
                format!("error converting supplied value for protected_event_cids: {e}")
            });
            self
        }
        pub fn strategy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Strategy>,
            T::Error: ::std::fmt::Display,
        {
            self.strategy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for strategy: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EvictionPolicy> for super::EvictionPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EvictionPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_retained_tokens: value.max_retained_tokens?,
                protected_event_cids: value.protected_event_cids?,
                strategy: value.strategy?,
            })
        }
    }
    impl ::std::convert::From<super::EvictionPolicy> for EvictionPolicy {
        fn from(value: super::EvictionPolicy) -> Self {
            Self {
                max_retained_tokens: Ok(value.max_retained_tokens),
                protected_event_cids: Ok(value.protected_event_cids),
                strategy: Ok(value.strategy),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EvidentiaryCitationState {
        citation_cid: ::std::result::Result<super::CitationCid, ::std::string::String>,
        extracted_snippet: ::std::result::Result<super::ExtractedSnippet, ::std::string::String>,
        nli_entailment_score: ::std::result::Result<f64, ::std::string::String>,
        publication_timestamp:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        source_url: ::std::result::Result<::std::string::String, ::std::string::String>,
    }
    impl ::std::default::Default for EvidentiaryCitationState {
        fn default() -> Self {
            Self {
                citation_cid: Err("no value supplied for citation_cid".to_string()),
                extracted_snippet: Err("no value supplied for extracted_snippet".to_string()),
                nli_entailment_score: Err("no value supplied for nli_entailment_score".to_string()),
                publication_timestamp: Ok(Default::default()),
                source_url: Err("no value supplied for source_url".to_string()),
            }
        }
    }
    impl EvidentiaryCitationState {
        pub fn citation_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CitationCid>,
            T::Error: ::std::fmt::Display,
        {
            self.citation_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for citation_cid: {e}"));
            self
        }
        pub fn extracted_snippet<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ExtractedSnippet>,
            T::Error: ::std::fmt::Display,
        {
            self.extracted_snippet = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for extracted_snippet: {e}"));
            self
        }
        pub fn nli_entailment_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.nli_entailment_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for nli_entailment_score: {e}")
            });
            self
        }
        pub fn publication_timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.publication_timestamp = value.try_into().map_err(|e| {
                format!("error converting supplied value for publication_timestamp: {e}")
            });
            self
        }
        pub fn source_url<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.source_url = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_url: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EvidentiaryCitationState> for super::EvidentiaryCitationState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EvidentiaryCitationState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                citation_cid: value.citation_cid?,
                extracted_snippet: value.extracted_snippet?,
                nli_entailment_score: value.nli_entailment_score?,
                publication_timestamp: value.publication_timestamp?,
                source_url: value.source_url?,
            })
        }
    }
    impl ::std::convert::From<super::EvidentiaryCitationState> for EvidentiaryCitationState {
        fn from(value: super::EvidentiaryCitationState) -> Self {
            Self {
                citation_cid: Ok(value.citation_cid),
                extracted_snippet: Ok(value.extracted_snippet),
                nli_entailment_score: Ok(value.nli_entailment_score),
                publication_timestamp: Ok(value.publication_timestamp),
                source_url: Ok(value.source_url),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EvidentiaryGroundingSla {
        allowed_evidence_domains: ::std::result::Result<
            ::std::vec::Vec<super::AllowedEvidenceDomainsItem>,
            ::std::string::String,
        >,
        minimum_nli_entailment_score: ::std::result::Result<f64, ::std::string::String>,
        require_independent_sources: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
        required_deduction_receipt_cid: ::std::result::Result<
            ::std::option::Option<super::NodeCidState>,
            ::std::string::String,
        >,
        ungrounded_link_action: ::std::result::Result<
            ::std::option::Option<super::UngroundedLinkAction>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EvidentiaryGroundingSla {
        fn default() -> Self {
            Self {
                allowed_evidence_domains: Ok(Default::default()),
                minimum_nli_entailment_score: Err(
                    "no value supplied for minimum_nli_entailment_score".to_string(),
                ),
                require_independent_sources: Ok(Default::default()),
                required_deduction_receipt_cid: Ok(Default::default()),
                ungrounded_link_action: Ok(Default::default()),
            }
        }
    }
    impl EvidentiaryGroundingSla {
        pub fn allowed_evidence_domains<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AllowedEvidenceDomainsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.allowed_evidence_domains = value.try_into().map_err(|e| {
                format!("error converting supplied value for allowed_evidence_domains: {e}")
            });
            self
        }
        pub fn minimum_nli_entailment_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.minimum_nli_entailment_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for minimum_nli_entailment_score: {e}")
            });
            self
        }
        pub fn require_independent_sources<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.require_independent_sources = value.try_into().map_err(|e| {
                format!("error converting supplied value for require_independent_sources: {e}")
            });
            self
        }
        pub fn required_deduction_receipt_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.required_deduction_receipt_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for required_deduction_receipt_cid: {e}")
            });
            self
        }
        pub fn ungrounded_link_action<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::UngroundedLinkAction>>,
            T::Error: ::std::fmt::Display,
        {
            self.ungrounded_link_action = value.try_into().map_err(|e| {
                format!("error converting supplied value for ungrounded_link_action: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EvidentiaryGroundingSla> for super::EvidentiaryGroundingSla {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EvidentiaryGroundingSla,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                allowed_evidence_domains: value.allowed_evidence_domains?,
                minimum_nli_entailment_score: value.minimum_nli_entailment_score?,
                require_independent_sources: value.require_independent_sources?,
                required_deduction_receipt_cid: value.required_deduction_receipt_cid?,
                ungrounded_link_action: value.ungrounded_link_action?,
            })
        }
    }
    impl ::std::convert::From<super::EvidentiaryGroundingSla> for EvidentiaryGroundingSla {
        fn from(value: super::EvidentiaryGroundingSla) -> Self {
            Self {
                allowed_evidence_domains: Ok(value.allowed_evidence_domains),
                minimum_nli_entailment_score: Ok(value.minimum_nli_entailment_score),
                require_independent_sources: Ok(value.require_independent_sources),
                required_deduction_receipt_cid: Ok(value.required_deduction_receipt_cid),
                ungrounded_link_action: Ok(value.ungrounded_link_action),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EvidentiaryWarrantState {
        justification: ::std::result::Result<super::Justification, ::std::string::String>,
        source_event_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        source_semantic_node_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EvidentiaryWarrantState {
        fn default() -> Self {
            Self {
                justification: Err("no value supplied for justification".to_string()),
                source_event_cid: Ok(Default::default()),
                source_semantic_node_cid: Ok(Default::default()),
            }
        }
    }
    impl EvidentiaryWarrantState {
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Justification>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn source_event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.source_event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_event_cid: {e}"));
            self
        }
        pub fn source_semantic_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.source_semantic_node_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for source_semantic_node_cid: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<EvidentiaryWarrantState> for super::EvidentiaryWarrantState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EvidentiaryWarrantState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                justification: value.justification?,
                source_event_cid: value.source_event_cid?,
                source_semantic_node_cid: value.source_semantic_node_cid?,
            })
        }
    }
    impl ::std::convert::From<super::EvidentiaryWarrantState> for EvidentiaryWarrantState {
        fn from(value: super::EvidentiaryWarrantState) -> Self {
            Self {
                justification: Ok(value.justification),
                source_event_cid: Ok(value.source_event_cid),
                source_semantic_node_cid: Ok(value.source_semantic_node_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct EvolutionaryTopologyManifest {
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        crossover: ::std::result::Result<super::CrossoverPolicy, ::std::string::String>,
        epistemic_enforcement: ::std::result::Result<
            ::std::option::Option<super::TruthMaintenancePolicy>,
            ::std::string::String,
        >,
        fitness_objectives: ::std::result::Result<
            ::std::vec::Vec<super::FitnessObjectiveProfile>,
            ::std::string::String,
        >,
        generations: ::std::result::Result<i64, ::std::string::String>,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        lifecycle_phase: ::std::result::Result<
            ::std::option::Option<super::LifecyclePhase>,
            ::std::string::String,
        >,
        mutation: ::std::result::Result<super::MutationPolicy, ::std::string::String>,
        nodes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            ::std::string::String,
        >,
        observability: ::std::result::Result<
            ::std::option::Option<super::ObservabilityLodPolicy>,
            ::std::string::String,
        >,
        population_size: ::std::result::Result<u64, ::std::string::String>,
        semantic_flow: ::std::result::Result<
            ::std::option::Option<super::SemanticFlowPolicy>,
            ::std::string::String,
        >,
        shared_state_contract: ::std::result::Result<
            ::std::option::Option<super::StateContract>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for EvolutionaryTopologyManifest {
        fn default() -> Self {
            Self {
                architectural_intent: Ok(Default::default()),
                crossover: Err("no value supplied for crossover".to_string()),
                epistemic_enforcement: Ok(Default::default()),
                fitness_objectives: Err("no value supplied for fitness_objectives".to_string()),
                generations: Err("no value supplied for generations".to_string()),
                justification: Ok(Default::default()),
                lifecycle_phase: Ok(Default::default()),
                mutation: Err("no value supplied for mutation".to_string()),
                nodes: Err("no value supplied for nodes".to_string()),
                observability: Ok(Default::default()),
                population_size: Err("no value supplied for population_size".to_string()),
                semantic_flow: Ok(Default::default()),
                shared_state_contract: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl EvolutionaryTopologyManifest {
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn crossover<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CrossoverPolicy>,
            T::Error: ::std::fmt::Display,
        {
            self.crossover = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for crossover: {e}"));
            self
        }
        pub fn epistemic_enforcement<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TruthMaintenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_enforcement = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_enforcement: {e}")
            });
            self
        }
        pub fn fitness_objectives<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::FitnessObjectiveProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.fitness_objectives = value.try_into().map_err(|e| {
                format!("error converting supplied value for fitness_objectives: {e}")
            });
            self
        }
        pub fn generations<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<i64>,
            T::Error: ::std::fmt::Display,
        {
            self.generations = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for generations: {e}"));
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn lifecycle_phase<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LifecyclePhase>>,
            T::Error: ::std::fmt::Display,
        {
            self.lifecycle_phase = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lifecycle_phase: {e}"));
            self
        }
        pub fn mutation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MutationPolicy>,
            T::Error: ::std::fmt::Display,
        {
            self.mutation = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for mutation: {e}"));
            self
        }
        pub fn nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for nodes: {e}"));
            self
        }
        pub fn observability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ObservabilityLodPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.observability = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for observability: {e}"));
            self
        }
        pub fn population_size<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.population_size = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for population_size: {e}"));
            self
        }
        pub fn semantic_flow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFlowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_flow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_flow: {e}"));
            self
        }
        pub fn shared_state_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.shared_state_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for shared_state_contract: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<EvolutionaryTopologyManifest> for super::EvolutionaryTopologyManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: EvolutionaryTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                architectural_intent: value.architectural_intent?,
                crossover: value.crossover?,
                epistemic_enforcement: value.epistemic_enforcement?,
                fitness_objectives: value.fitness_objectives?,
                generations: value.generations?,
                justification: value.justification?,
                lifecycle_phase: value.lifecycle_phase?,
                mutation: value.mutation?,
                nodes: value.nodes?,
                observability: value.observability?,
                population_size: value.population_size?,
                semantic_flow: value.semantic_flow?,
                shared_state_contract: value.shared_state_contract?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::EvolutionaryTopologyManifest> for EvolutionaryTopologyManifest {
        fn from(value: super::EvolutionaryTopologyManifest) -> Self {
            Self {
                architectural_intent: Ok(value.architectural_intent),
                crossover: Ok(value.crossover),
                epistemic_enforcement: Ok(value.epistemic_enforcement),
                fitness_objectives: Ok(value.fitness_objectives),
                generations: Ok(value.generations),
                justification: Ok(value.justification),
                lifecycle_phase: Ok(value.lifecycle_phase),
                mutation: Ok(value.mutation),
                nodes: Ok(value.nodes),
                observability: Ok(value.observability),
                population_size: Ok(value.population_size),
                semantic_flow: Ok(value.semantic_flow),
                shared_state_contract: Ok(value.shared_state_contract),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ExecutionEnvelopeState {
        payload: ::std::result::Result<::serde_json::Value, ::std::string::String>,
        state_vector: ::std::result::Result<super::StateVectorProfile, ::std::string::String>,
        trace_context: ::std::result::Result<super::TraceContextState, ::std::string::String>,
    }
    impl ::std::default::Default for ExecutionEnvelopeState {
        fn default() -> Self {
            Self {
                payload: Err("no value supplied for payload".to_string()),
                state_vector: Err("no value supplied for state_vector".to_string()),
                trace_context: Err("no value supplied for trace_context".to_string()),
            }
        }
    }
    impl ExecutionEnvelopeState {
        pub fn payload<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::serde_json::Value>,
            T::Error: ::std::fmt::Display,
        {
            self.payload = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for payload: {e}"));
            self
        }
        pub fn state_vector<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StateVectorProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.state_vector = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for state_vector: {e}"));
            self
        }
        pub fn trace_context<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TraceContextState>,
            T::Error: ::std::fmt::Display,
        {
            self.trace_context = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for trace_context: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ExecutionEnvelopeState> for super::ExecutionEnvelopeState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ExecutionEnvelopeState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                payload: value.payload?,
                state_vector: value.state_vector?,
                trace_context: value.trace_context?,
            })
        }
    }
    impl ::std::convert::From<super::ExecutionEnvelopeState> for ExecutionEnvelopeState {
        fn from(value: super::ExecutionEnvelopeState) -> Self {
            Self {
                payload: Ok(value.payload),
                state_vector: Ok(value.state_vector),
                trace_context: Ok(value.trace_context),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ExecutionSla {
        max_compute_footprint_mb: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
        max_execution_time_ms: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for ExecutionSla {
        fn default() -> Self {
            Self {
                max_compute_footprint_mb: Ok(Default::default()),
                max_execution_time_ms: Err(
                    "no value supplied for max_execution_time_ms".to_string()
                ),
            }
        }
    }
    impl ExecutionSla {
        pub fn max_compute_footprint_mb<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_compute_footprint_mb = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_compute_footprint_mb: {e}")
            });
            self
        }
        pub fn max_execution_time_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_execution_time_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_execution_time_ms: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<ExecutionSla> for super::ExecutionSla {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ExecutionSla,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_compute_footprint_mb: value.max_compute_footprint_mb?,
                max_execution_time_ms: value.max_execution_time_ms?,
            })
        }
    }
    impl ::std::convert::From<super::ExecutionSla> for ExecutionSla {
        fn from(value: super::ExecutionSla) -> Self {
            Self {
                max_compute_footprint_mb: Ok(value.max_compute_footprint_mb),
                max_execution_time_ms: Ok(value.max_execution_time_ms),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ExecutionSubstrateProfile {
        dialect: ::std::result::Result<super::Dialect, ::std::string::String>,
        required_package_signatures: ::std::result::Result<
            ::std::vec::Vec<super::RequiredPackageSignaturesItem>,
            ::std::string::String,
        >,
        supports_lazy_hydration: ::std::result::Result<bool, ::std::string::String>,
        vram_overhead_mb: ::std::result::Result<u64, ::std::string::String>,
    }
    impl ::std::default::Default for ExecutionSubstrateProfile {
        fn default() -> Self {
            Self {
                dialect: Err("no value supplied for dialect".to_string()),
                required_package_signatures: Err(
                    "no value supplied for required_package_signatures".to_string(),
                ),
                supports_lazy_hydration: Err(
                    "no value supplied for supports_lazy_hydration".to_string()
                ),
                vram_overhead_mb: Err("no value supplied for vram_overhead_mb".to_string()),
            }
        }
    }
    impl ExecutionSubstrateProfile {
        pub fn dialect<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Dialect>,
            T::Error: ::std::fmt::Display,
        {
            self.dialect = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for dialect: {e}"));
            self
        }
        pub fn required_package_signatures<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::RequiredPackageSignaturesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.required_package_signatures = value.try_into().map_err(|e| {
                format!("error converting supplied value for required_package_signatures: {e}")
            });
            self
        }
        pub fn supports_lazy_hydration<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.supports_lazy_hydration = value.try_into().map_err(|e| {
                format!("error converting supplied value for supports_lazy_hydration: {e}")
            });
            self
        }
        pub fn vram_overhead_mb<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.vram_overhead_mb = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for vram_overhead_mb: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ExecutionSubstrateProfile> for super::ExecutionSubstrateProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ExecutionSubstrateProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                dialect: value.dialect?,
                required_package_signatures: value.required_package_signatures?,
                supports_lazy_hydration: value.supports_lazy_hydration?,
                vram_overhead_mb: value.vram_overhead_mb?,
            })
        }
    }
    impl ::std::convert::From<super::ExecutionSubstrateProfile> for ExecutionSubstrateProfile {
        fn from(value: super::ExecutionSubstrateProfile) -> Self {
            Self {
                dialect: Ok(value.dialect),
                required_package_signatures: Ok(value.required_package_signatures),
                supports_lazy_hydration: Ok(value.supports_lazy_hydration),
                vram_overhead_mb: Ok(value.vram_overhead_mb),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ExogenousEpistemicEvent {
        bayesian_surprise_score: ::std::result::Result<f64, ::std::string::String>,
        escrow: ::std::result::Result<super::SimulationEscrowContract, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        shock_cid: ::std::result::Result<super::ShockCid, ::std::string::String>,
        synthetic_payload: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        target_node_hash: ::std::result::Result<super::TargetNodeHash, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for ExogenousEpistemicEvent {
        fn default() -> Self {
            Self {
                bayesian_surprise_score: Err(
                    "no value supplied for bayesian_surprise_score".to_string()
                ),
                escrow: Err("no value supplied for escrow".to_string()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                prior_event_hash: Ok(Default::default()),
                shock_cid: Err("no value supplied for shock_cid".to_string()),
                synthetic_payload: Err("no value supplied for synthetic_payload".to_string()),
                target_node_hash: Err("no value supplied for target_node_hash".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl ExogenousEpistemicEvent {
        pub fn bayesian_surprise_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.bayesian_surprise_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for bayesian_surprise_score: {e}")
            });
            self
        }
        pub fn escrow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SimulationEscrowContract>,
            T::Error: ::std::fmt::Display,
        {
            self.escrow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for escrow: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn shock_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ShockCid>,
            T::Error: ::std::fmt::Display,
        {
            self.shock_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for shock_cid: {e}"));
            self
        }
        pub fn synthetic_payload<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.synthetic_payload = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for synthetic_payload: {e}"));
            self
        }
        pub fn target_node_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetNodeHash>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_hash: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ExogenousEpistemicEvent> for super::ExogenousEpistemicEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ExogenousEpistemicEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                bayesian_surprise_score: value.bayesian_surprise_score?,
                escrow: value.escrow?,
                event_cid: value.event_cid?,
                prior_event_hash: value.prior_event_hash?,
                shock_cid: value.shock_cid?,
                synthetic_payload: value.synthetic_payload?,
                target_node_hash: value.target_node_hash?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::ExogenousEpistemicEvent> for ExogenousEpistemicEvent {
        fn from(value: super::ExogenousEpistemicEvent) -> Self {
            Self {
                bayesian_surprise_score: Ok(value.bayesian_surprise_score),
                escrow: Ok(value.escrow),
                event_cid: Ok(value.event_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                shock_cid: Ok(value.shock_cid),
                synthetic_payload: Ok(value.synthetic_payload),
                target_node_hash: Ok(value.target_node_hash),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct FacetMatrixProfile {
        column_field: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        row_field: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for FacetMatrixProfile {
        fn default() -> Self {
            Self {
                column_field: Ok(Default::default()),
                row_field: Ok(Default::default()),
            }
        }
    }
    impl FacetMatrixProfile {
        pub fn column_field<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.column_field = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for column_field: {e}"));
            self
        }
        pub fn row_field<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.row_field = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for row_field: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<FacetMatrixProfile> for super::FacetMatrixProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: FacetMatrixProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                column_field: value.column_field?,
                row_field: value.row_field?,
            })
        }
    }
    impl ::std::convert::From<super::FacetMatrixProfile> for FacetMatrixProfile {
        fn from(value: super::FacetMatrixProfile) -> Self {
            Self {
                column_field: Ok(value.column_field),
                row_field: Ok(value.row_field),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct FallbackIntent {
        fallback_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        target_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for FallbackIntent {
        fn default() -> Self {
            Self {
                fallback_node_cid: Err("no value supplied for fallback_node_cid".to_string()),
                target_node_cid: Err("no value supplied for target_node_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl FallbackIntent {
        pub fn fallback_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.fallback_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for fallback_node_cid: {e}"));
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<FallbackIntent> for super::FallbackIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: FallbackIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                fallback_node_cid: value.fallback_node_cid?,
                target_node_cid: value.target_node_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::FallbackIntent> for FallbackIntent {
        fn from(value: super::FallbackIntent) -> Self {
            Self {
                fallback_node_cid: Ok(value.fallback_node_cid),
                target_node_cid: Ok(value.target_node_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct FallbackSla {
        escalation_target_node_cid: ::std::result::Result<
            ::std::option::Option<super::NodeCidState>,
            ::std::string::String,
        >,
        timeout_action: ::std::result::Result<super::TimeoutAction, ::std::string::String>,
        timeout_seconds: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for FallbackSla {
        fn default() -> Self {
            Self {
                escalation_target_node_cid: Ok(Default::default()),
                timeout_action: Err("no value supplied for timeout_action".to_string()),
                timeout_seconds: Err("no value supplied for timeout_seconds".to_string()),
            }
        }
    }
    impl FallbackSla {
        pub fn escalation_target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.escalation_target_node_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for escalation_target_node_cid: {e}")
            });
            self
        }
        pub fn timeout_action<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TimeoutAction>,
            T::Error: ::std::fmt::Display,
        {
            self.timeout_action = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timeout_action: {e}"));
            self
        }
        pub fn timeout_seconds<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.timeout_seconds = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timeout_seconds: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<FallbackSla> for super::FallbackSla {
        type Error = super::error::ConversionError;
        fn try_from(
            value: FallbackSla,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                escalation_target_node_cid: value.escalation_target_node_cid?,
                timeout_action: value.timeout_action?,
                timeout_seconds: value.timeout_seconds?,
            })
        }
    }
    impl ::std::convert::From<super::FallbackSla> for FallbackSla {
        fn from(value: super::FallbackSla) -> Self {
            Self {
                escalation_target_node_cid: Ok(value.escalation_target_node_cid),
                timeout_action: Ok(value.timeout_action),
                timeout_seconds: Ok(value.timeout_seconds),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct FalsificationContract {
        counter_model_receipt_cid: ::std::result::Result<
            ::std::option::Option<super::NodeCidState>,
            ::std::string::String,
        >,
        falsification_solver: ::std::result::Result<
            ::std::option::Option<super::FalsificationSolver>,
            ::std::string::String,
        >,
        target_hypothesis_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for FalsificationContract {
        fn default() -> Self {
            Self {
                counter_model_receipt_cid: Ok(Default::default()),
                falsification_solver: Ok(Default::default()),
                target_hypothesis_cid: Err(
                    "no value supplied for target_hypothesis_cid".to_string()
                ),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl FalsificationContract {
        pub fn counter_model_receipt_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.counter_model_receipt_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for counter_model_receipt_cid: {e}")
            });
            self
        }
        pub fn falsification_solver<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::FalsificationSolver>>,
            T::Error: ::std::fmt::Display,
        {
            self.falsification_solver = value.try_into().map_err(|e| {
                format!("error converting supplied value for falsification_solver: {e}")
            });
            self
        }
        pub fn target_hypothesis_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_hypothesis_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_hypothesis_cid: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<FalsificationContract> for super::FalsificationContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: FalsificationContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                counter_model_receipt_cid: value.counter_model_receipt_cid?,
                falsification_solver: value.falsification_solver?,
                target_hypothesis_cid: value.target_hypothesis_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::FalsificationContract> for FalsificationContract {
        fn from(value: super::FalsificationContract) -> Self {
            Self {
                counter_model_receipt_cid: Ok(value.counter_model_receipt_cid),
                falsification_solver: Ok(value.falsification_solver),
                target_hypothesis_cid: Ok(value.target_hypothesis_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct FitnessObjectiveProfile {
        direction:
            ::std::result::Result<super::OptimizationDirectionProfile, ::std::string::String>,
        target_metric: ::std::result::Result<super::TargetMetric, ::std::string::String>,
        weight: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
    }
    impl ::std::default::Default for FitnessObjectiveProfile {
        fn default() -> Self {
            Self {
                direction: Err("no value supplied for direction".to_string()),
                target_metric: Err("no value supplied for target_metric".to_string()),
                weight: Ok(Default::default()),
            }
        }
    }
    impl FitnessObjectiveProfile {
        pub fn direction<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::OptimizationDirectionProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.direction = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for direction: {e}"));
            self
        }
        pub fn target_metric<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetMetric>,
            T::Error: ::std::fmt::Display,
        {
            self.target_metric = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_metric: {e}"));
            self
        }
        pub fn weight<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.weight = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for weight: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<FitnessObjectiveProfile> for super::FitnessObjectiveProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: FitnessObjectiveProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                direction: value.direction?,
                target_metric: value.target_metric?,
                weight: value.weight?,
            })
        }
    }
    impl ::std::convert::From<super::FitnessObjectiveProfile> for FitnessObjectiveProfile {
        fn from(value: super::FitnessObjectiveProfile) -> Self {
            Self {
                direction: Ok(value.direction),
                target_metric: Ok(value.target_metric),
                weight: Ok(value.weight),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct FormalLogicPremise {
        dialect_urn: ::std::result::Result<super::DialectUrn, ::std::string::String>,
        formal_statement: ::std::result::Result<super::FormalStatement, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        verification_script: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for FormalLogicPremise {
        fn default() -> Self {
            Self {
                dialect_urn: Err("no value supplied for dialect_urn".to_string()),
                formal_statement: Err("no value supplied for formal_statement".to_string()),
                topology_class: Ok(Default::default()),
                verification_script: Ok(Default::default()),
            }
        }
    }
    impl FormalLogicPremise {
        pub fn dialect_urn<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DialectUrn>,
            T::Error: ::std::fmt::Display,
        {
            self.dialect_urn = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for dialect_urn: {e}"));
            self
        }
        pub fn formal_statement<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FormalStatement>,
            T::Error: ::std::fmt::Display,
        {
            self.formal_statement = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for formal_statement: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn verification_script<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.verification_script = value.try_into().map_err(|e| {
                format!("error converting supplied value for verification_script: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<FormalLogicPremise> for super::FormalLogicPremise {
        type Error = super::error::ConversionError;
        fn try_from(
            value: FormalLogicPremise,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                dialect_urn: value.dialect_urn?,
                formal_statement: value.formal_statement?,
                topology_class: value.topology_class?,
                verification_script: value.verification_script?,
            })
        }
    }
    impl ::std::convert::From<super::FormalLogicPremise> for FormalLogicPremise {
        fn from(value: super::FormalLogicPremise) -> Self {
            Self {
                dialect_urn: Ok(value.dialect_urn),
                formal_statement: Ok(value.formal_statement),
                topology_class: Ok(value.topology_class),
                verification_script: Ok(value.verification_script),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct FormalVerificationContract {
        compiled_proof_hash: ::std::result::Result<super::CompiledProofHash, ::std::string::String>,
        invariant_theorem: ::std::result::Result<super::InvariantTheorem, ::std::string::String>,
        proof_system: ::std::result::Result<super::ProofSystem, ::std::string::String>,
        verified_receipt_cid: ::std::result::Result<
            ::std::option::Option<super::NodeCidState>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for FormalVerificationContract {
        fn default() -> Self {
            Self {
                compiled_proof_hash: Err("no value supplied for compiled_proof_hash".to_string()),
                invariant_theorem: Err("no value supplied for invariant_theorem".to_string()),
                proof_system: Err("no value supplied for proof_system".to_string()),
                verified_receipt_cid: Ok(Default::default()),
            }
        }
    }
    impl FormalVerificationContract {
        pub fn compiled_proof_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CompiledProofHash>,
            T::Error: ::std::fmt::Display,
        {
            self.compiled_proof_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for compiled_proof_hash: {e}")
            });
            self
        }
        pub fn invariant_theorem<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::InvariantTheorem>,
            T::Error: ::std::fmt::Display,
        {
            self.invariant_theorem = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for invariant_theorem: {e}"));
            self
        }
        pub fn proof_system<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProofSystem>,
            T::Error: ::std::fmt::Display,
        {
            self.proof_system = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proof_system: {e}"));
            self
        }
        pub fn verified_receipt_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.verified_receipt_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for verified_receipt_cid: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<FormalVerificationContract> for super::FormalVerificationContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: FormalVerificationContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                compiled_proof_hash: value.compiled_proof_hash?,
                invariant_theorem: value.invariant_theorem?,
                proof_system: value.proof_system?,
                verified_receipt_cid: value.verified_receipt_cid?,
            })
        }
    }
    impl ::std::convert::From<super::FormalVerificationContract> for FormalVerificationContract {
        fn from(value: super::FormalVerificationContract) -> Self {
            Self {
                compiled_proof_hash: Ok(value.compiled_proof_hash),
                invariant_theorem: Ok(value.invariant_theorem),
                proof_system: Ok(value.proof_system),
                verified_receipt_cid: Ok(value.verified_receipt_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct FormalVerificationReceipt {
        causal_provenance_cid: ::std::result::Result<
            ::std::option::Option<super::NodeCidState>,
            ::std::string::String,
        >,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        extracted_bindings: ::std::result::Result<
            ::std::vec::Vec<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            ::std::string::String,
        >,
        failing_context: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        is_proved: ::std::result::Result<bool, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        satisfiability_state: ::std::result::Result<
            ::std::option::Option<super::FormalVerificationReceiptSatisfiabilityState>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for FormalVerificationReceipt {
        fn default() -> Self {
            Self {
                causal_provenance_cid: Ok(Default::default()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                extracted_bindings: Ok(Default::default()),
                failing_context: Ok(Default::default()),
                is_proved: Err("no value supplied for is_proved".to_string()),
                prior_event_hash: Ok(Default::default()),
                satisfiability_state: Ok(Default::default()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl FormalVerificationReceipt {
        pub fn causal_provenance_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_provenance_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for causal_provenance_cid: {e}")
            });
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn extracted_bindings<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::vec::Vec<
                    ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.extracted_bindings = value.try_into().map_err(|e| {
                format!("error converting supplied value for extracted_bindings: {e}")
            });
            self
        }
        pub fn failing_context<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.failing_context = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for failing_context: {e}"));
            self
        }
        pub fn is_proved<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.is_proved = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for is_proved: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn satisfiability_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::FormalVerificationReceiptSatisfiabilityState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.satisfiability_state = value.try_into().map_err(|e| {
                format!("error converting supplied value for satisfiability_state: {e}")
            });
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<FormalVerificationReceipt> for super::FormalVerificationReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: FormalVerificationReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                causal_provenance_cid: value.causal_provenance_cid?,
                event_cid: value.event_cid?,
                extracted_bindings: value.extracted_bindings?,
                failing_context: value.failing_context?,
                is_proved: value.is_proved?,
                prior_event_hash: value.prior_event_hash?,
                satisfiability_state: value.satisfiability_state?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::FormalVerificationReceipt> for FormalVerificationReceipt {
        fn from(value: super::FormalVerificationReceipt) -> Self {
            Self {
                causal_provenance_cid: Ok(value.causal_provenance_cid),
                event_cid: Ok(value.event_cid),
                extracted_bindings: Ok(value.extracted_bindings),
                failing_context: Ok(value.failing_context),
                is_proved: Ok(value.is_proved),
                prior_event_hash: Ok(value.prior_event_hash),
                satisfiability_state: Ok(value.satisfiability_state),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct FyiIntent {
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for FyiIntent {
        fn default() -> Self {
            Self {
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl FyiIntent {
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<FyiIntent> for super::FyiIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: FyiIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::FyiIntent> for FyiIntent {
        fn from(value: super::FyiIntent) -> Self {
            Self {
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct GenerativeManifoldSla {
        max_node_fanout: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        max_synthetic_tokens: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        max_topological_depth: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for GenerativeManifoldSla {
        fn default() -> Self {
            Self {
                max_node_fanout: Err("no value supplied for max_node_fanout".to_string()),
                max_synthetic_tokens: Err("no value supplied for max_synthetic_tokens".to_string()),
                max_topological_depth: Err(
                    "no value supplied for max_topological_depth".to_string()
                ),
            }
        }
    }
    impl GenerativeManifoldSla {
        pub fn max_node_fanout<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_node_fanout = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_node_fanout: {e}"));
            self
        }
        pub fn max_synthetic_tokens<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_synthetic_tokens = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_synthetic_tokens: {e}")
            });
            self
        }
        pub fn max_topological_depth<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_topological_depth = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_topological_depth: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<GenerativeManifoldSla> for super::GenerativeManifoldSla {
        type Error = super::error::ConversionError;
        fn try_from(
            value: GenerativeManifoldSla,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_node_fanout: value.max_node_fanout?,
                max_synthetic_tokens: value.max_synthetic_tokens?,
                max_topological_depth: value.max_topological_depth?,
            })
        }
    }
    impl ::std::convert::From<super::GenerativeManifoldSla> for GenerativeManifoldSla {
        fn from(value: super::GenerativeManifoldSla) -> Self {
            Self {
                max_node_fanout: Ok(value.max_node_fanout),
                max_synthetic_tokens: Ok(value.max_synthetic_tokens),
                max_topological_depth: Ok(value.max_topological_depth),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct GenerativeTaxonomyManifest {
        manifest_cid: ::std::result::Result<super::ManifestCid, ::std::string::String>,
        nodes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::TaxonomicNodeState>,
            ::std::string::String,
        >,
        root_node_cid: ::std::result::Result<super::RootNodeCid, ::std::string::String>,
    }
    impl ::std::default::Default for GenerativeTaxonomyManifest {
        fn default() -> Self {
            Self {
                manifest_cid: Err("no value supplied for manifest_cid".to_string()),
                nodes: Err("no value supplied for nodes".to_string()),
                root_node_cid: Err("no value supplied for root_node_cid".to_string()),
            }
        }
    }
    impl GenerativeTaxonomyManifest {
        pub fn manifest_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ManifestCid>,
            T::Error: ::std::fmt::Display,
        {
            self.manifest_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for manifest_cid: {e}"));
            self
        }
        pub fn nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::TaxonomicNodeState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for nodes: {e}"));
            self
        }
        pub fn root_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RootNodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.root_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for root_node_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<GenerativeTaxonomyManifest> for super::GenerativeTaxonomyManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: GenerativeTaxonomyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                manifest_cid: value.manifest_cid?,
                nodes: value.nodes?,
                root_node_cid: value.root_node_cid?,
            })
        }
    }
    impl ::std::convert::From<super::GenerativeTaxonomyManifest> for GenerativeTaxonomyManifest {
        fn from(value: super::GenerativeTaxonomyManifest) -> Self {
            Self {
                manifest_cid: Ok(value.manifest_cid),
                nodes: Ok(value.nodes),
                root_node_cid: Ok(value.root_node_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct GlobalGovernancePolicy {
        formal_verification: ::std::result::Result<
            ::std::option::Option<super::FormalVerificationContract>,
            ::std::string::String,
        >,
        global_timeout_seconds: ::std::result::Result<u64, ::std::string::String>,
        mandatory_license_rule:
            ::std::result::Result<super::EpistemicGuardrailsManifest, ::std::string::String>,
        max_budget_magnitude: ::std::result::Result<u64, ::std::string::String>,
        max_carbon_budget_gco2eq:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        max_global_tokens: ::std::result::Result<u64, ::std::string::String>,
        temporal_conflict_policy: ::std::result::Result<
            ::std::option::Option<super::TemporalConflictResolutionPolicy>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for GlobalGovernancePolicy {
        fn default() -> Self {
            Self {
                formal_verification: Ok(Default::default()),
                global_timeout_seconds: Err(
                    "no value supplied for global_timeout_seconds".to_string()
                ),
                mandatory_license_rule: Err(
                    "no value supplied for mandatory_license_rule".to_string()
                ),
                max_budget_magnitude: Err("no value supplied for max_budget_magnitude".to_string()),
                max_carbon_budget_gco2eq: Ok(Default::default()),
                max_global_tokens: Err("no value supplied for max_global_tokens".to_string()),
                temporal_conflict_policy: Ok(Default::default()),
            }
        }
    }
    impl GlobalGovernancePolicy {
        pub fn formal_verification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::FormalVerificationContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.formal_verification = value.try_into().map_err(|e| {
                format!("error converting supplied value for formal_verification: {e}")
            });
            self
        }
        pub fn global_timeout_seconds<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.global_timeout_seconds = value.try_into().map_err(|e| {
                format!("error converting supplied value for global_timeout_seconds: {e}")
            });
            self
        }
        pub fn mandatory_license_rule<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EpistemicGuardrailsManifest>,
            T::Error: ::std::fmt::Display,
        {
            self.mandatory_license_rule = value.try_into().map_err(|e| {
                format!("error converting supplied value for mandatory_license_rule: {e}")
            });
            self
        }
        pub fn max_budget_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_budget_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_budget_magnitude: {e}")
            });
            self
        }
        pub fn max_carbon_budget_gco2eq<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_carbon_budget_gco2eq = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_carbon_budget_gco2eq: {e}")
            });
            self
        }
        pub fn max_global_tokens<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_global_tokens = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_global_tokens: {e}"));
            self
        }
        pub fn temporal_conflict_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::TemporalConflictResolutionPolicy>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_conflict_policy = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_conflict_policy: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<GlobalGovernancePolicy> for super::GlobalGovernancePolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: GlobalGovernancePolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                formal_verification: value.formal_verification?,
                global_timeout_seconds: value.global_timeout_seconds?,
                mandatory_license_rule: value.mandatory_license_rule?,
                max_budget_magnitude: value.max_budget_magnitude?,
                max_carbon_budget_gco2eq: value.max_carbon_budget_gco2eq?,
                max_global_tokens: value.max_global_tokens?,
                temporal_conflict_policy: value.temporal_conflict_policy?,
            })
        }
    }
    impl ::std::convert::From<super::GlobalGovernancePolicy> for GlobalGovernancePolicy {
        fn from(value: super::GlobalGovernancePolicy) -> Self {
            Self {
                formal_verification: Ok(value.formal_verification),
                global_timeout_seconds: Ok(value.global_timeout_seconds),
                mandatory_license_rule: Ok(value.mandatory_license_rule),
                max_budget_magnitude: Ok(value.max_budget_magnitude),
                max_carbon_budget_gco2eq: Ok(value.max_carbon_budget_gco2eq),
                max_global_tokens: Ok(value.max_global_tokens),
                temporal_conflict_policy: Ok(value.temporal_conflict_policy),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct GlobalSemanticInvariantProfile {
        categorical_cohorts: ::std::result::Result<
            ::std::vec::Vec<super::CategoricalCohortsItem>,
            ::std::string::String,
        >,
        invariant_cid: ::std::result::Result<super::InvariantCid, ::std::string::String>,
        operational_perimeters: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        temporal_observation_horizons: ::std::result::Result<
            ::std::vec::Vec<super::TemporalBoundsProfile>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for GlobalSemanticInvariantProfile {
        fn default() -> Self {
            Self {
                categorical_cohorts: Ok(Default::default()),
                invariant_cid: Err("no value supplied for invariant_cid".to_string()),
                operational_perimeters: Ok(Default::default()),
                temporal_observation_horizons: Ok(Default::default()),
            }
        }
    }
    impl GlobalSemanticInvariantProfile {
        pub fn categorical_cohorts<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::CategoricalCohortsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.categorical_cohorts = value.try_into().map_err(|e| {
                format!("error converting supplied value for categorical_cohorts: {e}")
            });
            self
        }
        pub fn invariant_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::InvariantCid>,
            T::Error: ::std::fmt::Display,
        {
            self.invariant_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for invariant_cid: {e}"));
            self
        }
        pub fn operational_perimeters<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.operational_perimeters = value.try_into().map_err(|e| {
                format!("error converting supplied value for operational_perimeters: {e}")
            });
            self
        }
        pub fn temporal_observation_horizons<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::TemporalBoundsProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_observation_horizons = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_observation_horizons: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<GlobalSemanticInvariantProfile>
        for super::GlobalSemanticInvariantProfile
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: GlobalSemanticInvariantProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                categorical_cohorts: value.categorical_cohorts?,
                invariant_cid: value.invariant_cid?,
                operational_perimeters: value.operational_perimeters?,
                temporal_observation_horizons: value.temporal_observation_horizons?,
            })
        }
    }
    impl ::std::convert::From<super::GlobalSemanticInvariantProfile>
        for GlobalSemanticInvariantProfile
    {
        fn from(value: super::GlobalSemanticInvariantProfile) -> Self {
            Self {
                categorical_cohorts: Ok(value.categorical_cohorts),
                invariant_cid: Ok(value.invariant_cid),
                operational_perimeters: Ok(value.operational_perimeters),
                temporal_observation_horizons: Ok(value.temporal_observation_horizons),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct GlobalSemanticProfile {
        artifact_event_cid: ::std::result::Result<super::ArtifactEventCid, ::std::string::String>,
        detected_modalities: ::std::result::Result<
            ::std::vec::Vec<super::DetectedModalitiesItem>,
            ::std::string::String,
        >,
        token_density: ::std::result::Result<u64, ::std::string::String>,
    }
    impl ::std::default::Default for GlobalSemanticProfile {
        fn default() -> Self {
            Self {
                artifact_event_cid: Err("no value supplied for artifact_event_cid".to_string()),
                detected_modalities: Err("no value supplied for detected_modalities".to_string()),
                token_density: Err("no value supplied for token_density".to_string()),
            }
        }
    }
    impl GlobalSemanticProfile {
        pub fn artifact_event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ArtifactEventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.artifact_event_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for artifact_event_cid: {e}")
            });
            self
        }
        pub fn detected_modalities<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::DetectedModalitiesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.detected_modalities = value.try_into().map_err(|e| {
                format!("error converting supplied value for detected_modalities: {e}")
            });
            self
        }
        pub fn token_density<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.token_density = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for token_density: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<GlobalSemanticProfile> for super::GlobalSemanticProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: GlobalSemanticProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                artifact_event_cid: value.artifact_event_cid?,
                detected_modalities: value.detected_modalities?,
                token_density: value.token_density?,
            })
        }
    }
    impl ::std::convert::From<super::GlobalSemanticProfile> for GlobalSemanticProfile {
        fn from(value: super::GlobalSemanticProfile) -> Self {
            Self {
                artifact_event_cid: Ok(value.artifact_event_cid),
                detected_modalities: Ok(value.detected_modalities),
                token_density: Ok(value.token_density),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct GradingCriterionProfile {
        criterion_cid: ::std::result::Result<super::CriterionCid, ::std::string::String>,
        description: ::std::result::Result<super::Description, ::std::string::String>,
        weight: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for GradingCriterionProfile {
        fn default() -> Self {
            Self {
                criterion_cid: Err("no value supplied for criterion_cid".to_string()),
                description: Err("no value supplied for description".to_string()),
                weight: Err("no value supplied for weight".to_string()),
            }
        }
    }
    impl GradingCriterionProfile {
        pub fn criterion_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CriterionCid>,
            T::Error: ::std::fmt::Display,
        {
            self.criterion_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for criterion_cid: {e}"));
            self
        }
        pub fn description<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Description>,
            T::Error: ::std::fmt::Display,
        {
            self.description = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for description: {e}"));
            self
        }
        pub fn weight<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.weight = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for weight: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<GradingCriterionProfile> for super::GradingCriterionProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: GradingCriterionProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                criterion_cid: value.criterion_cid?,
                description: value.description?,
                weight: value.weight?,
            })
        }
    }
    impl ::std::convert::From<super::GradingCriterionProfile> for GradingCriterionProfile {
        fn from(value: super::GradingCriterionProfile) -> Self {
            Self {
                criterion_cid: Ok(value.criterion_cid),
                description: Ok(value.description),
                weight: Ok(value.weight),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct GrammarPanelProfile {
        billboard_physics: ::std::result::Result<
            ::std::option::Option<super::SpatialBillboardContract>,
            ::std::string::String,
        >,
        encodings: ::std::result::Result<
            ::std::vec::Vec<super::VisualEncodingProfile>,
            ::std::string::String,
        >,
        facet: ::std::result::Result<
            ::std::option::Option<super::FacetMatrixProfile>,
            ::std::string::String,
        >,
        ledger_source_cid: ::std::result::Result<super::LedgerSourceCid, ::std::string::String>,
        mark: ::std::result::Result<super::Mark, ::std::string::String>,
        panel_cid: ::std::result::Result<super::PanelCid, ::std::string::String>,
        title: ::std::result::Result<super::Title, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for GrammarPanelProfile {
        fn default() -> Self {
            Self {
                billboard_physics: Ok(Default::default()),
                encodings: Err("no value supplied for encodings".to_string()),
                facet: Ok(Default::default()),
                ledger_source_cid: Err("no value supplied for ledger_source_cid".to_string()),
                mark: Err("no value supplied for mark".to_string()),
                panel_cid: Err("no value supplied for panel_cid".to_string()),
                title: Err("no value supplied for title".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl GrammarPanelProfile {
        pub fn billboard_physics<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialBillboardContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.billboard_physics = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for billboard_physics: {e}"));
            self
        }
        pub fn encodings<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::VisualEncodingProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.encodings = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for encodings: {e}"));
            self
        }
        pub fn facet<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::FacetMatrixProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.facet = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for facet: {e}"));
            self
        }
        pub fn ledger_source_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::LedgerSourceCid>,
            T::Error: ::std::fmt::Display,
        {
            self.ledger_source_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for ledger_source_cid: {e}"));
            self
        }
        pub fn mark<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Mark>,
            T::Error: ::std::fmt::Display,
        {
            self.mark = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for mark: {e}"));
            self
        }
        pub fn panel_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PanelCid>,
            T::Error: ::std::fmt::Display,
        {
            self.panel_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for panel_cid: {e}"));
            self
        }
        pub fn title<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Title>,
            T::Error: ::std::fmt::Display,
        {
            self.title = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for title: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<GrammarPanelProfile> for super::GrammarPanelProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: GrammarPanelProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                billboard_physics: value.billboard_physics?,
                encodings: value.encodings?,
                facet: value.facet?,
                ledger_source_cid: value.ledger_source_cid?,
                mark: value.mark?,
                panel_cid: value.panel_cid?,
                title: value.title?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::GrammarPanelProfile> for GrammarPanelProfile {
        fn from(value: super::GrammarPanelProfile) -> Self {
            Self {
                billboard_physics: Ok(value.billboard_physics),
                encodings: Ok(value.encodings),
                facet: Ok(value.facet),
                ledger_source_cid: Ok(value.ledger_source_cid),
                mark: Ok(value.mark),
                panel_cid: Ok(value.panel_cid),
                title: Ok(value.title),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct GraphFlatteningPolicy {
        edge_projection_mode:
            ::std::result::Result<super::EdgeProjectionMode, ::std::string::String>,
        node_projection_mode:
            ::std::result::Result<super::NodeProjectionMode, ::std::string::String>,
        preserve_cryptographic_lineage:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
    }
    impl ::std::default::Default for GraphFlatteningPolicy {
        fn default() -> Self {
            Self {
                edge_projection_mode: Err("no value supplied for edge_projection_mode".to_string()),
                node_projection_mode: Err("no value supplied for node_projection_mode".to_string()),
                preserve_cryptographic_lineage: Ok(Default::default()),
            }
        }
    }
    impl GraphFlatteningPolicy {
        pub fn edge_projection_mode<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EdgeProjectionMode>,
            T::Error: ::std::fmt::Display,
        {
            self.edge_projection_mode = value.try_into().map_err(|e| {
                format!("error converting supplied value for edge_projection_mode: {e}")
            });
            self
        }
        pub fn node_projection_mode<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeProjectionMode>,
            T::Error: ::std::fmt::Display,
        {
            self.node_projection_mode = value.try_into().map_err(|e| {
                format!("error converting supplied value for node_projection_mode: {e}")
            });
            self
        }
        pub fn preserve_cryptographic_lineage<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.preserve_cryptographic_lineage = value.try_into().map_err(|e| {
                format!("error converting supplied value for preserve_cryptographic_lineage: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<GraphFlatteningPolicy> for super::GraphFlatteningPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: GraphFlatteningPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                edge_projection_mode: value.edge_projection_mode?,
                node_projection_mode: value.node_projection_mode?,
                preserve_cryptographic_lineage: value.preserve_cryptographic_lineage?,
            })
        }
    }
    impl ::std::convert::From<super::GraphFlatteningPolicy> for GraphFlatteningPolicy {
        fn from(value: super::GraphFlatteningPolicy) -> Self {
            Self {
                edge_projection_mode: Ok(value.edge_projection_mode),
                node_projection_mode: Ok(value.node_projection_mode),
                preserve_cryptographic_lineage: Ok(value.preserve_cryptographic_lineage),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct GuardrailViolationEvent {
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        status_code: ::std::result::Result<i64, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        violation_details: ::std::result::Result<
            ::serde_json::Map<::std::string::String, ::serde_json::Value>,
            ::std::string::String,
        >,
        violation_id: ::std::result::Result<::std::string::String, ::std::string::String>,
        violation_type: ::std::result::Result<::std::string::String, ::std::string::String>,
    }
    impl ::std::default::Default for GuardrailViolationEvent {
        fn default() -> Self {
            Self {
                event_cid: Err("no value supplied for event_cid".to_string()),
                prior_event_hash: Ok(Default::default()),
                status_code: Err("no value supplied for status_code".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
                violation_details: Ok(Default::default()),
                violation_id: Err("no value supplied for violation_id".to_string()),
                violation_type: Err("no value supplied for violation_type".to_string()),
            }
        }
    }
    impl GuardrailViolationEvent {
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn status_code<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<i64>,
            T::Error: ::std::fmt::Display,
        {
            self.status_code = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for status_code: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn violation_details<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.violation_details = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for violation_details: {e}"));
            self
        }
        pub fn violation_id<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.violation_id = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for violation_id: {e}"));
            self
        }
        pub fn violation_type<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.violation_type = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for violation_type: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<GuardrailViolationEvent> for super::GuardrailViolationEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: GuardrailViolationEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                event_cid: value.event_cid?,
                prior_event_hash: value.prior_event_hash?,
                status_code: value.status_code?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
                violation_details: value.violation_details?,
                violation_id: value.violation_id?,
                violation_type: value.violation_type?,
            })
        }
    }
    impl ::std::convert::From<super::GuardrailViolationEvent> for GuardrailViolationEvent {
        fn from(value: super::GuardrailViolationEvent) -> Self {
            Self {
                event_cid: Ok(value.event_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                status_code: Ok(value.status_code),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
                violation_details: Ok(value.violation_details),
                violation_id: Ok(value.violation_id),
                violation_type: Ok(value.violation_type),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct HardwareEnclaveReceipt {
        enclave_class: ::std::result::Result<super::EnclaveClass, ::std::string::String>,
        hardware_signature_blob:
            ::std::result::Result<super::HardwareSignatureBlob, ::std::string::String>,
        platform_measurement_hash:
            ::std::result::Result<super::PlatformMeasurementHash, ::std::string::String>,
    }
    impl ::std::default::Default for HardwareEnclaveReceipt {
        fn default() -> Self {
            Self {
                enclave_class: Err("no value supplied for enclave_class".to_string()),
                hardware_signature_blob: Err(
                    "no value supplied for hardware_signature_blob".to_string()
                ),
                platform_measurement_hash: Err(
                    "no value supplied for platform_measurement_hash".to_string()
                ),
            }
        }
    }
    impl HardwareEnclaveReceipt {
        pub fn enclave_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EnclaveClass>,
            T::Error: ::std::fmt::Display,
        {
            self.enclave_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for enclave_class: {e}"));
            self
        }
        pub fn hardware_signature_blob<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::HardwareSignatureBlob>,
            T::Error: ::std::fmt::Display,
        {
            self.hardware_signature_blob = value.try_into().map_err(|e| {
                format!("error converting supplied value for hardware_signature_blob: {e}")
            });
            self
        }
        pub fn platform_measurement_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PlatformMeasurementHash>,
            T::Error: ::std::fmt::Display,
        {
            self.platform_measurement_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for platform_measurement_hash: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<HardwareEnclaveReceipt> for super::HardwareEnclaveReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: HardwareEnclaveReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                enclave_class: value.enclave_class?,
                hardware_signature_blob: value.hardware_signature_blob?,
                platform_measurement_hash: value.platform_measurement_hash?,
            })
        }
    }
    impl ::std::convert::From<super::HardwareEnclaveReceipt> for HardwareEnclaveReceipt {
        fn from(value: super::HardwareEnclaveReceipt) -> Self {
            Self {
                enclave_class: Ok(value.enclave_class),
                hardware_signature_blob: Ok(value.hardware_signature_blob),
                platform_measurement_hash: Ok(value.platform_measurement_hash),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct HierarchicalDomManifest {
        blocks: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::DocumentLayoutRegionState>,
            ::std::string::String,
        >,
        containment_edges: ::std::result::Result<
            ::std::vec::Vec<[::serde_json::Value; 2usize]>,
            ::std::string::String,
        >,
        dom_cid: ::std::result::Result<super::DomCid, ::std::string::String>,
        root_block_cid: ::std::result::Result<super::RootBlockCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for HierarchicalDomManifest {
        fn default() -> Self {
            Self {
                blocks: Err("no value supplied for blocks".to_string()),
                containment_edges: Ok(Default::default()),
                dom_cid: Err("no value supplied for dom_cid".to_string()),
                root_block_cid: Err("no value supplied for root_block_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl HierarchicalDomManifest {
        pub fn blocks<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::DocumentLayoutRegionState,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.blocks = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for blocks: {e}"));
            self
        }
        pub fn containment_edges<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<[::serde_json::Value; 2usize]>>,
            T::Error: ::std::fmt::Display,
        {
            self.containment_edges = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for containment_edges: {e}"));
            self
        }
        pub fn dom_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DomCid>,
            T::Error: ::std::fmt::Display,
        {
            self.dom_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for dom_cid: {e}"));
            self
        }
        pub fn root_block_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RootBlockCid>,
            T::Error: ::std::fmt::Display,
        {
            self.root_block_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for root_block_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<HierarchicalDomManifest> for super::HierarchicalDomManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: HierarchicalDomManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                blocks: value.blocks?,
                containment_edges: value.containment_edges?,
                dom_cid: value.dom_cid?,
                root_block_cid: value.root_block_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::HierarchicalDomManifest> for HierarchicalDomManifest {
        fn from(value: super::HierarchicalDomManifest) -> Self {
            Self {
                blocks: Ok(value.blocks),
                containment_edges: Ok(value.containment_edges),
                dom_cid: Ok(value.dom_cid),
                root_block_cid: Ok(value.root_block_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct HoareLogicProofReceipt {
        capability_cid: ::std::result::Result<super::CapabilityCid, ::std::string::String>,
        postconditions: ::std::result::Result<
            ::std::vec::Vec<super::AlgebraicRefinementContract>,
            ::std::string::String,
        >,
        preconditions: ::std::result::Result<
            ::std::vec::Vec<super::AlgebraicRefinementContract>,
            ::std::string::String,
        >,
        proof_system: ::std::result::Result<super::ProofSystem, ::std::string::String>,
        verified_theorem_hash:
            ::std::result::Result<super::VerifiedTheoremHash, ::std::string::String>,
    }
    impl ::std::default::Default for HoareLogicProofReceipt {
        fn default() -> Self {
            Self {
                capability_cid: Err("no value supplied for capability_cid".to_string()),
                postconditions: Err("no value supplied for postconditions".to_string()),
                preconditions: Err("no value supplied for preconditions".to_string()),
                proof_system: Err("no value supplied for proof_system".to_string()),
                verified_theorem_hash: Err(
                    "no value supplied for verified_theorem_hash".to_string()
                ),
            }
        }
    }
    impl HoareLogicProofReceipt {
        pub fn capability_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CapabilityCid>,
            T::Error: ::std::fmt::Display,
        {
            self.capability_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for capability_cid: {e}"));
            self
        }
        pub fn postconditions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AlgebraicRefinementContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.postconditions = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for postconditions: {e}"));
            self
        }
        pub fn preconditions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AlgebraicRefinementContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.preconditions = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for preconditions: {e}"));
            self
        }
        pub fn proof_system<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProofSystem>,
            T::Error: ::std::fmt::Display,
        {
            self.proof_system = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proof_system: {e}"));
            self
        }
        pub fn verified_theorem_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VerifiedTheoremHash>,
            T::Error: ::std::fmt::Display,
        {
            self.verified_theorem_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for verified_theorem_hash: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<HoareLogicProofReceipt> for super::HoareLogicProofReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: HoareLogicProofReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                capability_cid: value.capability_cid?,
                postconditions: value.postconditions?,
                preconditions: value.preconditions?,
                proof_system: value.proof_system?,
                verified_theorem_hash: value.verified_theorem_hash?,
            })
        }
    }
    impl ::std::convert::From<super::HoareLogicProofReceipt> for HoareLogicProofReceipt {
        fn from(value: super::HoareLogicProofReceipt) -> Self {
            Self {
                capability_cid: Ok(value.capability_cid),
                postconditions: Ok(value.postconditions),
                preconditions: Ok(value.preconditions),
                proof_system: Ok(value.proof_system),
                verified_theorem_hash: Ok(value.verified_theorem_hash),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct HomomorphicEncryptionProfile {
        ciphertext_blob: ::std::result::Result<super::CiphertextBlob, ::std::string::String>,
        fhe_scheme: ::std::result::Result<super::FheScheme, ::std::string::String>,
        public_key_cid: ::std::result::Result<super::PublicKeyCid, ::std::string::String>,
    }
    impl ::std::default::Default for HomomorphicEncryptionProfile {
        fn default() -> Self {
            Self {
                ciphertext_blob: Err("no value supplied for ciphertext_blob".to_string()),
                fhe_scheme: Err("no value supplied for fhe_scheme".to_string()),
                public_key_cid: Err("no value supplied for public_key_cid".to_string()),
            }
        }
    }
    impl HomomorphicEncryptionProfile {
        pub fn ciphertext_blob<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CiphertextBlob>,
            T::Error: ::std::fmt::Display,
        {
            self.ciphertext_blob = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for ciphertext_blob: {e}"));
            self
        }
        pub fn fhe_scheme<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FheScheme>,
            T::Error: ::std::fmt::Display,
        {
            self.fhe_scheme = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for fhe_scheme: {e}"));
            self
        }
        pub fn public_key_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PublicKeyCid>,
            T::Error: ::std::fmt::Display,
        {
            self.public_key_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for public_key_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<HomomorphicEncryptionProfile> for super::HomomorphicEncryptionProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: HomomorphicEncryptionProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                ciphertext_blob: value.ciphertext_blob?,
                fhe_scheme: value.fhe_scheme?,
                public_key_cid: value.public_key_cid?,
            })
        }
    }
    impl ::std::convert::From<super::HomomorphicEncryptionProfile> for HomomorphicEncryptionProfile {
        fn from(value: super::HomomorphicEncryptionProfile) -> Self {
            Self {
                ciphertext_blob: Ok(value.ciphertext_blob),
                fhe_scheme: Ok(value.fhe_scheme),
                public_key_cid: Ok(value.public_key_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct HttpTransportProfile {
        headers: ::std::result::Result<
            ::std::collections::HashMap<
                ::std::string::String,
                super::HttpTransportProfileHeadersValue,
            >,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        uri: ::std::result::Result<::std::string::String, ::std::string::String>,
    }
    impl ::std::default::Default for HttpTransportProfile {
        fn default() -> Self {
            Self {
                headers: Ok(Default::default()),
                topology_class: Ok(Default::default()),
                uri: Err("no value supplied for uri".to_string()),
            }
        }
    }
    impl HttpTransportProfile {
        pub fn headers<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::HttpTransportProfileHeadersValue,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.headers = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for headers: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn uri<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.uri = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for uri: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<HttpTransportProfile> for super::HttpTransportProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: HttpTransportProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                headers: value.headers?,
                topology_class: value.topology_class?,
                uri: value.uri?,
            })
        }
    }
    impl ::std::convert::From<super::HttpTransportProfile> for HttpTransportProfile {
        fn from(value: super::HttpTransportProfile) -> Self {
            Self {
                headers: Ok(value.headers),
                topology_class: Ok(value.topology_class),
                uri: Ok(value.uri),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct HumanDirectiveIntent {
        allocated_budget_magnitude:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        natural_language_goal:
            ::std::result::Result<super::NaturalLanguageGoal, ::std::string::String>,
        target_qos: ::std::result::Result<super::QoSClassificationProfile, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for HumanDirectiveIntent {
        fn default() -> Self {
            Self {
                allocated_budget_magnitude: Err(
                    "no value supplied for allocated_budget_magnitude".to_string()
                ),
                natural_language_goal: Err(
                    "no value supplied for natural_language_goal".to_string()
                ),
                target_qos: Err("no value supplied for target_qos".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl HumanDirectiveIntent {
        pub fn allocated_budget_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.allocated_budget_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for allocated_budget_magnitude: {e}")
            });
            self
        }
        pub fn natural_language_goal<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NaturalLanguageGoal>,
            T::Error: ::std::fmt::Display,
        {
            self.natural_language_goal = value.try_into().map_err(|e| {
                format!("error converting supplied value for natural_language_goal: {e}")
            });
            self
        }
        pub fn target_qos<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::QoSClassificationProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.target_qos = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_qos: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<HumanDirectiveIntent> for super::HumanDirectiveIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: HumanDirectiveIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                allocated_budget_magnitude: value.allocated_budget_magnitude?,
                natural_language_goal: value.natural_language_goal?,
                target_qos: value.target_qos?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::HumanDirectiveIntent> for HumanDirectiveIntent {
        fn from(value: super::HumanDirectiveIntent) -> Self {
            Self {
                allocated_budget_magnitude: Ok(value.allocated_budget_magnitude),
                natural_language_goal: Ok(value.natural_language_goal),
                target_qos: Ok(value.target_qos),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct HypothesisGenerationEvent {
        bayesian_prior: ::std::result::Result<f64, ::std::string::String>,
        causal_model: ::std::result::Result<
            ::std::option::Option<super::StructuralCausalGraphProfile>,
            ::std::string::String,
        >,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        falsification_conditions: ::std::result::Result<
            ::std::vec::Vec<super::EmpiricalFalsificationContract>,
            ::std::string::String,
        >,
        hypothesis_cid: ::std::result::Result<super::HypothesisCid, ::std::string::String>,
        premise_text: ::std::result::Result<super::PremiseText, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        status: ::std::result::Result<::std::option::Option<super::Status>, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for HypothesisGenerationEvent {
        fn default() -> Self {
            Self {
                bayesian_prior: Err("no value supplied for bayesian_prior".to_string()),
                causal_model: Ok(Default::default()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                falsification_conditions: Err(
                    "no value supplied for falsification_conditions".to_string()
                ),
                hypothesis_cid: Err("no value supplied for hypothesis_cid".to_string()),
                premise_text: Err("no value supplied for premise_text".to_string()),
                prior_event_hash: Ok(Default::default()),
                status: Ok(Default::default()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl HypothesisGenerationEvent {
        pub fn bayesian_prior<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.bayesian_prior = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for bayesian_prior: {e}"));
            self
        }
        pub fn causal_model<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StructuralCausalGraphProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_model = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for causal_model: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn falsification_conditions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EmpiricalFalsificationContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.falsification_conditions = value.try_into().map_err(|e| {
                format!("error converting supplied value for falsification_conditions: {e}")
            });
            self
        }
        pub fn hypothesis_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::HypothesisCid>,
            T::Error: ::std::fmt::Display,
        {
            self.hypothesis_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for hypothesis_cid: {e}"));
            self
        }
        pub fn premise_text<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PremiseText>,
            T::Error: ::std::fmt::Display,
        {
            self.premise_text = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for premise_text: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn status<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::Status>>,
            T::Error: ::std::fmt::Display,
        {
            self.status = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for status: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<HypothesisGenerationEvent> for super::HypothesisGenerationEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: HypothesisGenerationEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                bayesian_prior: value.bayesian_prior?,
                causal_model: value.causal_model?,
                event_cid: value.event_cid?,
                falsification_conditions: value.falsification_conditions?,
                hypothesis_cid: value.hypothesis_cid?,
                premise_text: value.premise_text?,
                prior_event_hash: value.prior_event_hash?,
                status: value.status?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::HypothesisGenerationEvent> for HypothesisGenerationEvent {
        fn from(value: super::HypothesisGenerationEvent) -> Self {
            Self {
                bayesian_prior: Ok(value.bayesian_prior),
                causal_model: Ok(value.causal_model),
                event_cid: Ok(value.event_cid),
                falsification_conditions: Ok(value.falsification_conditions),
                hypothesis_cid: Ok(value.hypothesis_cid),
                premise_text: Ok(value.premise_text),
                prior_event_hash: Ok(value.prior_event_hash),
                status: Ok(value.status),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct HypothesisStakeReceipt {
        agent_cid: ::std::result::Result<super::AgentCid, ::std::string::String>,
        implied_probability: ::std::result::Result<f64, ::std::string::String>,
        staked_magnitude: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        target_hypothesis_cid:
            ::std::result::Result<super::TargetHypothesisCid, ::std::string::String>,
    }
    impl ::std::default::Default for HypothesisStakeReceipt {
        fn default() -> Self {
            Self {
                agent_cid: Err("no value supplied for agent_cid".to_string()),
                implied_probability: Err("no value supplied for implied_probability".to_string()),
                staked_magnitude: Err("no value supplied for staked_magnitude".to_string()),
                target_hypothesis_cid: Err(
                    "no value supplied for target_hypothesis_cid".to_string()
                ),
            }
        }
    }
    impl HypothesisStakeReceipt {
        pub fn agent_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AgentCid>,
            T::Error: ::std::fmt::Display,
        {
            self.agent_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for agent_cid: {e}"));
            self
        }
        pub fn implied_probability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.implied_probability = value.try_into().map_err(|e| {
                format!("error converting supplied value for implied_probability: {e}")
            });
            self
        }
        pub fn staked_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.staked_magnitude = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for staked_magnitude: {e}"));
            self
        }
        pub fn target_hypothesis_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetHypothesisCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_hypothesis_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_hypothesis_cid: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<HypothesisStakeReceipt> for super::HypothesisStakeReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: HypothesisStakeReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                agent_cid: value.agent_cid?,
                implied_probability: value.implied_probability?,
                staked_magnitude: value.staked_magnitude?,
                target_hypothesis_cid: value.target_hypothesis_cid?,
            })
        }
    }
    impl ::std::convert::From<super::HypothesisStakeReceipt> for HypothesisStakeReceipt {
        fn from(value: super::HypothesisStakeReceipt) -> Self {
            Self {
                agent_cid: Ok(value.agent_cid),
                implied_probability: Ok(value.implied_probability),
                staked_magnitude: Ok(value.staked_magnitude),
                target_hypothesis_cid: Ok(value.target_hypothesis_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct HypothesisSuperpositionState {
        competing_manifolds: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, f64>,
            ::std::string::String,
        >,
        residual_entropy_vectors: ::std::result::Result<
            ::std::vec::Vec<super::ResidualEntropyVectorsItem>,
            ::std::string::String,
        >,
        superposition_cid: ::std::result::Result<super::SuperpositionCid, ::std::string::String>,
        wave_collapse_function:
            ::std::result::Result<super::WaveCollapseFunction, ::std::string::String>,
    }
    impl ::std::default::Default for HypothesisSuperpositionState {
        fn default() -> Self {
            Self {
                competing_manifolds: Err("no value supplied for competing_manifolds".to_string()),
                residual_entropy_vectors: Ok(Default::default()),
                superposition_cid: Err("no value supplied for superposition_cid".to_string()),
                wave_collapse_function: Err(
                    "no value supplied for wave_collapse_function".to_string()
                ),
            }
        }
    }
    impl HypothesisSuperpositionState {
        pub fn competing_manifolds<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::collections::HashMap<::std::string::String, f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.competing_manifolds = value.try_into().map_err(|e| {
                format!("error converting supplied value for competing_manifolds: {e}")
            });
            self
        }
        pub fn residual_entropy_vectors<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ResidualEntropyVectorsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.residual_entropy_vectors = value.try_into().map_err(|e| {
                format!("error converting supplied value for residual_entropy_vectors: {e}")
            });
            self
        }
        pub fn superposition_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SuperpositionCid>,
            T::Error: ::std::fmt::Display,
        {
            self.superposition_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for superposition_cid: {e}"));
            self
        }
        pub fn wave_collapse_function<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::WaveCollapseFunction>,
            T::Error: ::std::fmt::Display,
        {
            self.wave_collapse_function = value.try_into().map_err(|e| {
                format!("error converting supplied value for wave_collapse_function: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<HypothesisSuperpositionState> for super::HypothesisSuperpositionState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: HypothesisSuperpositionState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                competing_manifolds: value.competing_manifolds?,
                residual_entropy_vectors: value.residual_entropy_vectors?,
                superposition_cid: value.superposition_cid?,
                wave_collapse_function: value.wave_collapse_function?,
            })
        }
    }
    impl ::std::convert::From<super::HypothesisSuperpositionState> for HypothesisSuperpositionState {
        fn from(value: super::HypothesisSuperpositionState) -> Self {
            Self {
                competing_manifolds: Ok(value.competing_manifolds),
                residual_entropy_vectors: Ok(value.residual_entropy_vectors),
                superposition_cid: Ok(value.superposition_cid),
                wave_collapse_function: Ok(value.wave_collapse_function),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct InputMappingContract {
        child_key: ::std::result::Result<super::ChildKey, ::std::string::String>,
        parent_key: ::std::result::Result<super::ParentKey, ::std::string::String>,
    }
    impl ::std::default::Default for InputMappingContract {
        fn default() -> Self {
            Self {
                child_key: Err("no value supplied for child_key".to_string()),
                parent_key: Err("no value supplied for parent_key".to_string()),
            }
        }
    }
    impl InputMappingContract {
        pub fn child_key<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ChildKey>,
            T::Error: ::std::fmt::Display,
        {
            self.child_key = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for child_key: {e}"));
            self
        }
        pub fn parent_key<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ParentKey>,
            T::Error: ::std::fmt::Display,
        {
            self.parent_key = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for parent_key: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<InputMappingContract> for super::InputMappingContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: InputMappingContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                child_key: value.child_key?,
                parent_key: value.parent_key?,
            })
        }
    }
    impl ::std::convert::From<super::InputMappingContract> for InputMappingContract {
        fn from(value: super::InputMappingContract) -> Self {
            Self {
                child_key: Ok(value.child_key),
                parent_key: Ok(value.parent_key),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct InsightCardProfile {
        billboard_physics: ::std::result::Result<
            ::std::option::Option<super::SpatialBillboardContract>,
            ::std::string::String,
        >,
        markdown_content: ::std::result::Result<super::MarkdownContent, ::std::string::String>,
        panel_cid: ::std::result::Result<super::PanelCid, ::std::string::String>,
        title: ::std::result::Result<super::Title, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for InsightCardProfile {
        fn default() -> Self {
            Self {
                billboard_physics: Ok(Default::default()),
                markdown_content: Err("no value supplied for markdown_content".to_string()),
                panel_cid: Err("no value supplied for panel_cid".to_string()),
                title: Err("no value supplied for title".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl InsightCardProfile {
        pub fn billboard_physics<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialBillboardContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.billboard_physics = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for billboard_physics: {e}"));
            self
        }
        pub fn markdown_content<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MarkdownContent>,
            T::Error: ::std::fmt::Display,
        {
            self.markdown_content = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for markdown_content: {e}"));
            self
        }
        pub fn panel_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PanelCid>,
            T::Error: ::std::fmt::Display,
        {
            self.panel_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for panel_cid: {e}"));
            self
        }
        pub fn title<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Title>,
            T::Error: ::std::fmt::Display,
        {
            self.title = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for title: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<InsightCardProfile> for super::InsightCardProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: InsightCardProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                billboard_physics: value.billboard_physics?,
                markdown_content: value.markdown_content?,
                panel_cid: value.panel_cid?,
                title: value.title?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::InsightCardProfile> for InsightCardProfile {
        fn from(value: super::InsightCardProfile) -> Self {
            Self {
                billboard_physics: Ok(value.billboard_physics),
                markdown_content: Ok(value.markdown_content),
                panel_cid: Ok(value.panel_cid),
                title: Ok(value.title),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct IntentClassificationReceipt {
        classified_intent: ::std::result::Result<super::ClassifiedIntent, ::std::string::String>,
        confidence_score: ::std::result::Result<f64, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        raw_input_string: ::std::result::Result<super::RawInputString, ::std::string::String>,
        routing_policy_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for IntentClassificationReceipt {
        fn default() -> Self {
            Self {
                classified_intent: Err("no value supplied for classified_intent".to_string()),
                confidence_score: Err("no value supplied for confidence_score".to_string()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                prior_event_hash: Ok(Default::default()),
                raw_input_string: Err("no value supplied for raw_input_string".to_string()),
                routing_policy_cid: Ok(Default::default()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl IntentClassificationReceipt {
        pub fn classified_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ClassifiedIntent>,
            T::Error: ::std::fmt::Display,
        {
            self.classified_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for classified_intent: {e}"));
            self
        }
        pub fn confidence_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.confidence_score = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for confidence_score: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn raw_input_string<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RawInputString>,
            T::Error: ::std::fmt::Display,
        {
            self.raw_input_string = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for raw_input_string: {e}"));
            self
        }
        pub fn routing_policy_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.routing_policy_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for routing_policy_cid: {e}")
            });
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<IntentClassificationReceipt> for super::IntentClassificationReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: IntentClassificationReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                classified_intent: value.classified_intent?,
                confidence_score: value.confidence_score?,
                event_cid: value.event_cid?,
                prior_event_hash: value.prior_event_hash?,
                raw_input_string: value.raw_input_string?,
                routing_policy_cid: value.routing_policy_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::IntentClassificationReceipt> for IntentClassificationReceipt {
        fn from(value: super::IntentClassificationReceipt) -> Self {
            Self {
                classified_intent: Ok(value.classified_intent),
                confidence_score: Ok(value.confidence_score),
                event_cid: Ok(value.event_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                raw_input_string: Ok(value.raw_input_string),
                routing_policy_cid: Ok(value.routing_policy_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct IntentElicitationTopologyManifest {
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        epistemic_enforcement: ::std::result::Result<
            ::std::option::Option<super::TruthMaintenancePolicy>,
            ::std::string::String,
        >,
        human_oracle_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        lifecycle_phase: ::std::result::Result<
            ::std::option::Option<super::LifecyclePhase>,
            ::std::string::String,
        >,
        max_clarification_loops: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
        nodes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            ::std::string::String,
        >,
        observability: ::std::result::Result<
            ::std::option::Option<super::ObservabilityLodPolicy>,
            ::std::string::String,
        >,
        raw_human_artifact_cid:
            ::std::result::Result<super::RawHumanArtifactCid, ::std::string::String>,
        scanner_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        semantic_flow: ::std::result::Result<
            ::std::option::Option<super::SemanticFlowPolicy>,
            ::std::string::String,
        >,
        shared_state_contract: ::std::result::Result<
            ::std::option::Option<super::StateContract>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        transmuter_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
    }
    impl ::std::default::Default for IntentElicitationTopologyManifest {
        fn default() -> Self {
            Self {
                architectural_intent: Ok(Default::default()),
                epistemic_enforcement: Ok(Default::default()),
                human_oracle_cid: Err("no value supplied for human_oracle_cid".to_string()),
                justification: Ok(Default::default()),
                lifecycle_phase: Ok(Default::default()),
                max_clarification_loops: Ok(Default::default()),
                nodes: Err("no value supplied for nodes".to_string()),
                observability: Ok(Default::default()),
                raw_human_artifact_cid: Err(
                    "no value supplied for raw_human_artifact_cid".to_string()
                ),
                scanner_node_cid: Err("no value supplied for scanner_node_cid".to_string()),
                semantic_flow: Ok(Default::default()),
                shared_state_contract: Ok(Default::default()),
                topology_class: Ok(Default::default()),
                transmuter_node_cid: Err("no value supplied for transmuter_node_cid".to_string()),
            }
        }
    }
    impl IntentElicitationTopologyManifest {
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn epistemic_enforcement<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TruthMaintenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_enforcement = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_enforcement: {e}")
            });
            self
        }
        pub fn human_oracle_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.human_oracle_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for human_oracle_cid: {e}"));
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn lifecycle_phase<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LifecyclePhase>>,
            T::Error: ::std::fmt::Display,
        {
            self.lifecycle_phase = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lifecycle_phase: {e}"));
            self
        }
        pub fn max_clarification_loops<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_clarification_loops = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_clarification_loops: {e}")
            });
            self
        }
        pub fn nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for nodes: {e}"));
            self
        }
        pub fn observability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ObservabilityLodPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.observability = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for observability: {e}"));
            self
        }
        pub fn raw_human_artifact_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RawHumanArtifactCid>,
            T::Error: ::std::fmt::Display,
        {
            self.raw_human_artifact_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for raw_human_artifact_cid: {e}")
            });
            self
        }
        pub fn scanner_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.scanner_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for scanner_node_cid: {e}"));
            self
        }
        pub fn semantic_flow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFlowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_flow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_flow: {e}"));
            self
        }
        pub fn shared_state_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.shared_state_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for shared_state_contract: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn transmuter_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.transmuter_node_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for transmuter_node_cid: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<IntentElicitationTopologyManifest>
        for super::IntentElicitationTopologyManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: IntentElicitationTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                architectural_intent: value.architectural_intent?,
                epistemic_enforcement: value.epistemic_enforcement?,
                human_oracle_cid: value.human_oracle_cid?,
                justification: value.justification?,
                lifecycle_phase: value.lifecycle_phase?,
                max_clarification_loops: value.max_clarification_loops?,
                nodes: value.nodes?,
                observability: value.observability?,
                raw_human_artifact_cid: value.raw_human_artifact_cid?,
                scanner_node_cid: value.scanner_node_cid?,
                semantic_flow: value.semantic_flow?,
                shared_state_contract: value.shared_state_contract?,
                topology_class: value.topology_class?,
                transmuter_node_cid: value.transmuter_node_cid?,
            })
        }
    }
    impl ::std::convert::From<super::IntentElicitationTopologyManifest>
        for IntentElicitationTopologyManifest
    {
        fn from(value: super::IntentElicitationTopologyManifest) -> Self {
            Self {
                architectural_intent: Ok(value.architectural_intent),
                epistemic_enforcement: Ok(value.epistemic_enforcement),
                human_oracle_cid: Ok(value.human_oracle_cid),
                justification: Ok(value.justification),
                lifecycle_phase: Ok(value.lifecycle_phase),
                max_clarification_loops: Ok(value.max_clarification_loops),
                nodes: Ok(value.nodes),
                observability: Ok(value.observability),
                raw_human_artifact_cid: Ok(value.raw_human_artifact_cid),
                scanner_node_cid: Ok(value.scanner_node_cid),
                semantic_flow: Ok(value.semantic_flow),
                shared_state_contract: Ok(value.shared_state_contract),
                topology_class: Ok(value.topology_class),
                transmuter_node_cid: Ok(value.transmuter_node_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct InterventionIntent {
        adjudication_deadline: ::std::result::Result<f64, ::std::string::String>,
        context_summary: ::std::result::Result<super::ContextSummary, ::std::string::String>,
        failure_context: ::std::result::Result<
            ::std::option::Option<super::TerminalCognitiveEvent>,
            ::std::string::String,
        >,
        fallback_sla:
            ::std::result::Result<::std::option::Option<super::FallbackSla>, ::std::string::String>,
        intervention_scope: ::std::result::Result<
            ::std::option::Option<super::BoundedInterventionScopePolicy>,
            ::std::string::String,
        >,
        proposed_action: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        target_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for InterventionIntent {
        fn default() -> Self {
            Self {
                adjudication_deadline: Err(
                    "no value supplied for adjudication_deadline".to_string()
                ),
                context_summary: Err("no value supplied for context_summary".to_string()),
                failure_context: Ok(Default::default()),
                fallback_sla: Ok(Default::default()),
                intervention_scope: Ok(Default::default()),
                proposed_action: Err("no value supplied for proposed_action".to_string()),
                target_node_cid: Err("no value supplied for target_node_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl InterventionIntent {
        pub fn adjudication_deadline<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.adjudication_deadline = value.try_into().map_err(|e| {
                format!("error converting supplied value for adjudication_deadline: {e}")
            });
            self
        }
        pub fn context_summary<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ContextSummary>,
            T::Error: ::std::fmt::Display,
        {
            self.context_summary = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for context_summary: {e}"));
            self
        }
        pub fn failure_context<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TerminalCognitiveEvent>>,
            T::Error: ::std::fmt::Display,
        {
            self.failure_context = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for failure_context: {e}"));
            self
        }
        pub fn fallback_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::FallbackSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.fallback_sla = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for fallback_sla: {e}"));
            self
        }
        pub fn intervention_scope<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::BoundedInterventionScopePolicy>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.intervention_scope = value.try_into().map_err(|e| {
                format!("error converting supplied value for intervention_scope: {e}")
            });
            self
        }
        pub fn proposed_action<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.proposed_action = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proposed_action: {e}"));
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<InterventionIntent> for super::InterventionIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: InterventionIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                adjudication_deadline: value.adjudication_deadline?,
                context_summary: value.context_summary?,
                failure_context: value.failure_context?,
                fallback_sla: value.fallback_sla?,
                intervention_scope: value.intervention_scope?,
                proposed_action: value.proposed_action?,
                target_node_cid: value.target_node_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::InterventionIntent> for InterventionIntent {
        fn from(value: super::InterventionIntent) -> Self {
            Self {
                adjudication_deadline: Ok(value.adjudication_deadline),
                context_summary: Ok(value.context_summary),
                failure_context: Ok(value.failure_context),
                fallback_sla: Ok(value.fallback_sla),
                intervention_scope: Ok(value.intervention_scope),
                proposed_action: Ok(value.proposed_action),
                target_node_cid: Ok(value.target_node_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct InterventionPolicy {
        async_observation_port: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        blocking: ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        emit_telemetry_on_revision:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        scope: ::std::result::Result<
            ::std::option::Option<super::BoundedInterventionScopePolicy>,
            ::std::string::String,
        >,
        trigger: ::std::result::Result<super::LifecycleTriggerEvent, ::std::string::String>,
    }
    impl ::std::default::Default for InterventionPolicy {
        fn default() -> Self {
            Self {
                async_observation_port: Ok(Default::default()),
                blocking: Ok(Default::default()),
                emit_telemetry_on_revision: Ok(Default::default()),
                scope: Ok(Default::default()),
                trigger: Err("no value supplied for trigger".to_string()),
            }
        }
    }
    impl InterventionPolicy {
        pub fn async_observation_port<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.async_observation_port = value.try_into().map_err(|e| {
                format!("error converting supplied value for async_observation_port: {e}")
            });
            self
        }
        pub fn blocking<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.blocking = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for blocking: {e}"));
            self
        }
        pub fn emit_telemetry_on_revision<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.emit_telemetry_on_revision = value.try_into().map_err(|e| {
                format!("error converting supplied value for emit_telemetry_on_revision: {e}")
            });
            self
        }
        pub fn scope<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::BoundedInterventionScopePolicy>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.scope = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for scope: {e}"));
            self
        }
        pub fn trigger<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::LifecycleTriggerEvent>,
            T::Error: ::std::fmt::Display,
        {
            self.trigger = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for trigger: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<InterventionPolicy> for super::InterventionPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: InterventionPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                async_observation_port: value.async_observation_port?,
                blocking: value.blocking?,
                emit_telemetry_on_revision: value.emit_telemetry_on_revision?,
                scope: value.scope?,
                trigger: value.trigger?,
            })
        }
    }
    impl ::std::convert::From<super::InterventionPolicy> for InterventionPolicy {
        fn from(value: super::InterventionPolicy) -> Self {
            Self {
                async_observation_port: Ok(value.async_observation_port),
                blocking: Ok(value.blocking),
                emit_telemetry_on_revision: Ok(value.emit_telemetry_on_revision),
                scope: Ok(value.scope),
                trigger: Ok(value.trigger),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct InterventionReceipt {
        approved: ::std::result::Result<bool, ::std::string::String>,
        attestation: ::std::result::Result<
            ::std::option::Option<super::WetwareAttestationContract>,
            ::std::string::String,
        >,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        feedback: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        intervention_request_cid:
            ::std::result::Result<super::InterventionRequestCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        target_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for InterventionReceipt {
        fn default() -> Self {
            Self {
                approved: Err("no value supplied for approved".to_string()),
                attestation: Ok(Default::default()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                feedback: Err("no value supplied for feedback".to_string()),
                intervention_request_cid: Err(
                    "no value supplied for intervention_request_cid".to_string()
                ),
                prior_event_hash: Ok(Default::default()),
                target_node_cid: Err("no value supplied for target_node_cid".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl InterventionReceipt {
        pub fn approved<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.approved = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for approved: {e}"));
            self
        }
        pub fn attestation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::WetwareAttestationContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.attestation = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for attestation: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn feedback<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.feedback = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for feedback: {e}"));
            self
        }
        pub fn intervention_request_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::InterventionRequestCid>,
            T::Error: ::std::fmt::Display,
        {
            self.intervention_request_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for intervention_request_cid: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<InterventionReceipt> for super::InterventionReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: InterventionReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                approved: value.approved?,
                attestation: value.attestation?,
                event_cid: value.event_cid?,
                feedback: value.feedback?,
                intervention_request_cid: value.intervention_request_cid?,
                prior_event_hash: value.prior_event_hash?,
                target_node_cid: value.target_node_cid?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::InterventionReceipt> for InterventionReceipt {
        fn from(value: super::InterventionReceipt) -> Self {
            Self {
                approved: Ok(value.approved),
                attestation: Ok(value.attestation),
                event_cid: Ok(value.event_cid),
                feedback: Ok(value.feedback),
                intervention_request_cid: Ok(value.intervention_request_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                target_node_cid: Ok(value.target_node_cid),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct InterventionalCausalTask {
        do_operator_state: ::std::result::Result<super::DoOperatorState, ::std::string::String>,
        execution_cost_budget_magnitude: ::std::result::Result<u64, ::std::string::String>,
        expected_causal_information_gain: ::std::result::Result<f64, ::std::string::String>,
        intervention_variable:
            ::std::result::Result<super::InterventionVariable, ::std::string::String>,
        target_hypothesis_cid:
            ::std::result::Result<super::TargetHypothesisCid, ::std::string::String>,
        task_cid: ::std::result::Result<super::TaskCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for InterventionalCausalTask {
        fn default() -> Self {
            Self {
                do_operator_state: Err("no value supplied for do_operator_state".to_string()),
                execution_cost_budget_magnitude: Err(
                    "no value supplied for execution_cost_budget_magnitude".to_string(),
                ),
                expected_causal_information_gain: Err(
                    "no value supplied for expected_causal_information_gain".to_string(),
                ),
                intervention_variable: Err(
                    "no value supplied for intervention_variable".to_string()
                ),
                target_hypothesis_cid: Err(
                    "no value supplied for target_hypothesis_cid".to_string()
                ),
                task_cid: Err("no value supplied for task_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl InterventionalCausalTask {
        pub fn do_operator_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DoOperatorState>,
            T::Error: ::std::fmt::Display,
        {
            self.do_operator_state = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for do_operator_state: {e}"));
            self
        }
        pub fn execution_cost_budget_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.execution_cost_budget_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for execution_cost_budget_magnitude: {e}")
            });
            self
        }
        pub fn expected_causal_information_gain<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.expected_causal_information_gain = value.try_into().map_err(|e| {
                format!("error converting supplied value for expected_causal_information_gain: {e}")
            });
            self
        }
        pub fn intervention_variable<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::InterventionVariable>,
            T::Error: ::std::fmt::Display,
        {
            self.intervention_variable = value.try_into().map_err(|e| {
                format!("error converting supplied value for intervention_variable: {e}")
            });
            self
        }
        pub fn target_hypothesis_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetHypothesisCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_hypothesis_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_hypothesis_cid: {e}")
            });
            self
        }
        pub fn task_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TaskCid>,
            T::Error: ::std::fmt::Display,
        {
            self.task_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for task_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<InterventionalCausalTask> for super::InterventionalCausalTask {
        type Error = super::error::ConversionError;
        fn try_from(
            value: InterventionalCausalTask,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                do_operator_state: value.do_operator_state?,
                execution_cost_budget_magnitude: value.execution_cost_budget_magnitude?,
                expected_causal_information_gain: value.expected_causal_information_gain?,
                intervention_variable: value.intervention_variable?,
                target_hypothesis_cid: value.target_hypothesis_cid?,
                task_cid: value.task_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::InterventionalCausalTask> for InterventionalCausalTask {
        fn from(value: super::InterventionalCausalTask) -> Self {
            Self {
                do_operator_state: Ok(value.do_operator_state),
                execution_cost_budget_magnitude: Ok(value.execution_cost_budget_magnitude),
                expected_causal_information_gain: Ok(value.expected_causal_information_gain),
                intervention_variable: Ok(value.intervention_variable),
                target_hypothesis_cid: Ok(value.target_hypothesis_cid),
                task_cid: Ok(value.task_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct JsonPrimitiveState {
        subtype_0: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        subtype_1: ::std::result::Result<::std::option::Option<i64>, ::std::string::String>,
        subtype_2: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        subtype_3: ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        subtype_4: ::std::result::Result<
            ::std::option::Option<::std::vec::Vec<super::JsonPrimitiveState>>,
            ::std::string::String,
        >,
        subtype_5: ::std::result::Result<
            ::std::option::Option<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            ::std::string::String,
        >,
        subtype_6: ::std::result::Result<
            ::std::option::Option<super::EpistemicProxyStateAny>,
            ::std::string::String,
        >,
        subtype_7: ::std::result::Result<::std::option::Option<()>, ::std::string::String>,
    }
    impl ::std::default::Default for JsonPrimitiveState {
        fn default() -> Self {
            Self {
                subtype_0: Ok(Default::default()),
                subtype_1: Ok(Default::default()),
                subtype_2: Ok(Default::default()),
                subtype_3: Ok(Default::default()),
                subtype_4: Ok(Default::default()),
                subtype_5: Ok(Default::default()),
                subtype_6: Ok(Default::default()),
                subtype_7: Ok(Default::default()),
            }
        }
    }
    impl JsonPrimitiveState {
        pub fn subtype_0<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.subtype_0 = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for subtype_0: {e}"));
            self
        }
        pub fn subtype_1<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<i64>>,
            T::Error: ::std::fmt::Display,
        {
            self.subtype_1 = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for subtype_1: {e}"));
            self
        }
        pub fn subtype_2<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.subtype_2 = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for subtype_2: {e}"));
            self
        }
        pub fn subtype_3<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.subtype_3 = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for subtype_3: {e}"));
            self
        }
        pub fn subtype_4<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<::std::vec::Vec<super::JsonPrimitiveState>>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.subtype_4 = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for subtype_4: {e}"));
            self
        }
        pub fn subtype_5<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.subtype_5 = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for subtype_5: {e}"));
            self
        }
        pub fn subtype_6<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicProxyStateAny>>,
            T::Error: ::std::fmt::Display,
        {
            self.subtype_6 = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for subtype_6: {e}"));
            self
        }
        pub fn subtype_7<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<()>>,
            T::Error: ::std::fmt::Display,
        {
            self.subtype_7 = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for subtype_7: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<JsonPrimitiveState> for super::JsonPrimitiveState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: JsonPrimitiveState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                subtype_0: value.subtype_0?,
                subtype_1: value.subtype_1?,
                subtype_2: value.subtype_2?,
                subtype_3: value.subtype_3?,
                subtype_4: value.subtype_4?,
                subtype_5: value.subtype_5?,
                subtype_6: value.subtype_6?,
                subtype_7: value.subtype_7?,
            })
        }
    }
    impl ::std::convert::From<super::JsonPrimitiveState> for JsonPrimitiveState {
        fn from(value: super::JsonPrimitiveState) -> Self {
            Self {
                subtype_0: Ok(value.subtype_0),
                subtype_1: Ok(value.subtype_1),
                subtype_2: Ok(value.subtype_2),
                subtype_3: Ok(value.subtype_3),
                subtype_4: Ok(value.subtype_4),
                subtype_5: Ok(value.subtype_5),
                subtype_6: Ok(value.subtype_6),
                subtype_7: Ok(value.subtype_7),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct JsonrpcErrorResponseState {
        error: ::std::result::Result<super::JsonrpcErrorState, ::std::string::String>,
        id: ::std::result::Result<
            ::std::option::Option<super::JsonrpcErrorResponseStateId>,
            ::std::string::String,
        >,
        jsonrpc: ::std::result::Result<::std::string::String, ::std::string::String>,
    }
    impl ::std::default::Default for JsonrpcErrorResponseState {
        fn default() -> Self {
            Self {
                error: Err("no value supplied for error".to_string()),
                id: Ok(Default::default()),
                jsonrpc: Err("no value supplied for jsonrpc".to_string()),
            }
        }
    }
    impl JsonrpcErrorResponseState {
        pub fn error<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::JsonrpcErrorState>,
            T::Error: ::std::fmt::Display,
        {
            self.error = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for error: {e}"));
            self
        }
        pub fn id<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::JsonrpcErrorResponseStateId>>,
            T::Error: ::std::fmt::Display,
        {
            self.id = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for id: {e}"));
            self
        }
        pub fn jsonrpc<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.jsonrpc = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for jsonrpc: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<JsonrpcErrorResponseState> for super::JsonrpcErrorResponseState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: JsonrpcErrorResponseState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                error: value.error?,
                id: value.id?,
                jsonrpc: value.jsonrpc?,
            })
        }
    }
    impl ::std::convert::From<super::JsonrpcErrorResponseState> for JsonrpcErrorResponseState {
        fn from(value: super::JsonrpcErrorResponseState) -> Self {
            Self {
                error: Ok(value.error),
                id: Ok(value.id),
                jsonrpc: Ok(value.jsonrpc),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct JsonrpcErrorState {
        code: ::std::result::Result<u64, ::std::string::String>,
        data: ::std::result::Result<
            ::std::option::Option<super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        message: ::std::result::Result<super::Message, ::std::string::String>,
    }
    impl ::std::default::Default for JsonrpcErrorState {
        fn default() -> Self {
            Self {
                code: Err("no value supplied for code".to_string()),
                data: Ok(Default::default()),
                message: Err("no value supplied for message".to_string()),
            }
        }
    }
    impl JsonrpcErrorState {
        pub fn code<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.code = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for code: {e}"));
            self
        }
        pub fn data<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::JsonPrimitiveState>>,
            T::Error: ::std::fmt::Display,
        {
            self.data = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for data: {e}"));
            self
        }
        pub fn message<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Message>,
            T::Error: ::std::fmt::Display,
        {
            self.message = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for message: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<JsonrpcErrorState> for super::JsonrpcErrorState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: JsonrpcErrorState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                code: value.code?,
                data: value.data?,
                message: value.message?,
            })
        }
    }
    impl ::std::convert::From<super::JsonrpcErrorState> for JsonrpcErrorState {
        fn from(value: super::JsonrpcErrorState) -> Self {
            Self {
                code: Ok(value.code),
                data: Ok(value.data),
                message: Ok(value.message),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct KinematicDeltaManifest {
        deltas: ::std::result::Result<
            ::std::vec::Vec<[::serde_json::Value; 16usize]>,
            ::std::string::String,
        >,
        stream_cid: ::std::result::Result<super::StreamCid, ::std::string::String>,
    }
    impl ::std::default::Default for KinematicDeltaManifest {
        fn default() -> Self {
            Self {
                deltas: Err("no value supplied for deltas".to_string()),
                stream_cid: Err("no value supplied for stream_cid".to_string()),
            }
        }
    }
    impl KinematicDeltaManifest {
        pub fn deltas<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<[::serde_json::Value; 16usize]>>,
            T::Error: ::std::fmt::Display,
        {
            self.deltas = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for deltas: {e}"));
            self
        }
        pub fn stream_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StreamCid>,
            T::Error: ::std::fmt::Display,
        {
            self.stream_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for stream_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<KinematicDeltaManifest> for super::KinematicDeltaManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: KinematicDeltaManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                deltas: value.deltas?,
                stream_cid: value.stream_cid?,
            })
        }
    }
    impl ::std::convert::From<super::KinematicDeltaManifest> for KinematicDeltaManifest {
        fn from(value: super::KinematicDeltaManifest) -> Self {
            Self {
                deltas: Ok(value.deltas),
                stream_cid: Ok(value.stream_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct KinematicDerivativeProfile {
        angular_acceleration:
            ::std::result::Result<[::serde_json::Value; 3usize], ::std::string::String>,
        angular_velocity:
            ::std::result::Result<[::serde_json::Value; 3usize], ::std::string::String>,
        linear_acceleration:
            ::std::result::Result<[::serde_json::Value; 3usize], ::std::string::String>,
        linear_velocity:
            ::std::result::Result<[::serde_json::Value; 3usize], ::std::string::String>,
    }
    impl ::std::default::Default for KinematicDerivativeProfile {
        fn default() -> Self {
            Self {
                angular_acceleration: Err("no value supplied for angular_acceleration".to_string()),
                angular_velocity: Err("no value supplied for angular_velocity".to_string()),
                linear_acceleration: Err("no value supplied for linear_acceleration".to_string()),
                linear_velocity: Err("no value supplied for linear_velocity".to_string()),
            }
        }
    }
    impl KinematicDerivativeProfile {
        pub fn angular_acceleration<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<[::serde_json::Value; 3usize]>,
            T::Error: ::std::fmt::Display,
        {
            self.angular_acceleration = value.try_into().map_err(|e| {
                format!("error converting supplied value for angular_acceleration: {e}")
            });
            self
        }
        pub fn angular_velocity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<[::serde_json::Value; 3usize]>,
            T::Error: ::std::fmt::Display,
        {
            self.angular_velocity = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for angular_velocity: {e}"));
            self
        }
        pub fn linear_acceleration<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<[::serde_json::Value; 3usize]>,
            T::Error: ::std::fmt::Display,
        {
            self.linear_acceleration = value.try_into().map_err(|e| {
                format!("error converting supplied value for linear_acceleration: {e}")
            });
            self
        }
        pub fn linear_velocity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<[::serde_json::Value; 3usize]>,
            T::Error: ::std::fmt::Display,
        {
            self.linear_velocity = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for linear_velocity: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<KinematicDerivativeProfile> for super::KinematicDerivativeProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: KinematicDerivativeProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                angular_acceleration: value.angular_acceleration?,
                angular_velocity: value.angular_velocity?,
                linear_acceleration: value.linear_acceleration?,
                linear_velocity: value.linear_velocity?,
            })
        }
    }
    impl ::std::convert::From<super::KinematicDerivativeProfile> for KinematicDerivativeProfile {
        fn from(value: super::KinematicDerivativeProfile) -> Self {
            Self {
                angular_acceleration: Ok(value.angular_acceleration),
                angular_velocity: Ok(value.angular_velocity),
                linear_acceleration: Ok(value.linear_acceleration),
                linear_velocity: Ok(value.linear_velocity),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct KineticBudgetPolicy {
        dynamic_temperature_asymptote: ::std::result::Result<f64, ::std::string::String>,
        exploration_decay_curve:
            ::std::result::Result<super::ExplorationDecayCurve, ::std::string::String>,
        forced_exploitation_threshold_ms:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for KineticBudgetPolicy {
        fn default() -> Self {
            Self {
                dynamic_temperature_asymptote: Err(
                    "no value supplied for dynamic_temperature_asymptote".to_string(),
                ),
                exploration_decay_curve: Err(
                    "no value supplied for exploration_decay_curve".to_string()
                ),
                forced_exploitation_threshold_ms: Err(
                    "no value supplied for forced_exploitation_threshold_ms".to_string(),
                ),
            }
        }
    }
    impl KineticBudgetPolicy {
        pub fn dynamic_temperature_asymptote<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.dynamic_temperature_asymptote = value.try_into().map_err(|e| {
                format!("error converting supplied value for dynamic_temperature_asymptote: {e}")
            });
            self
        }
        pub fn exploration_decay_curve<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ExplorationDecayCurve>,
            T::Error: ::std::fmt::Display,
        {
            self.exploration_decay_curve = value.try_into().map_err(|e| {
                format!("error converting supplied value for exploration_decay_curve: {e}")
            });
            self
        }
        pub fn forced_exploitation_threshold_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.forced_exploitation_threshold_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for forced_exploitation_threshold_ms: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<KineticBudgetPolicy> for super::KineticBudgetPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: KineticBudgetPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                dynamic_temperature_asymptote: value.dynamic_temperature_asymptote?,
                exploration_decay_curve: value.exploration_decay_curve?,
                forced_exploitation_threshold_ms: value.forced_exploitation_threshold_ms?,
            })
        }
    }
    impl ::std::convert::From<super::KineticBudgetPolicy> for KineticBudgetPolicy {
        fn from(value: super::KineticBudgetPolicy) -> Self {
            Self {
                dynamic_temperature_asymptote: Ok(value.dynamic_temperature_asymptote),
                exploration_decay_curve: Ok(value.exploration_decay_curve),
                forced_exploitation_threshold_ms: Ok(value.forced_exploitation_threshold_ms),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct KineticSeparationPolicy {
        enforcement_action: ::std::result::Result<super::EnforcementAction, ::std::string::String>,
        mutually_exclusive_clusters: ::std::result::Result<
            ::std::vec::Vec<::std::vec::Vec<super::MutuallyExclusiveClustersItemItem>>,
            ::std::string::String,
        >,
        policy_cid: ::std::result::Result<super::PolicyCid, ::std::string::String>,
    }
    impl ::std::default::Default for KineticSeparationPolicy {
        fn default() -> Self {
            Self {
                enforcement_action: Err("no value supplied for enforcement_action".to_string()),
                mutually_exclusive_clusters: Err(
                    "no value supplied for mutually_exclusive_clusters".to_string(),
                ),
                policy_cid: Err("no value supplied for policy_cid".to_string()),
            }
        }
    }
    impl KineticSeparationPolicy {
        pub fn enforcement_action<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EnforcementAction>,
            T::Error: ::std::fmt::Display,
        {
            self.enforcement_action = value.try_into().map_err(|e| {
                format!("error converting supplied value for enforcement_action: {e}")
            });
            self
        }
        pub fn mutually_exclusive_clusters<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::vec::Vec<::std::vec::Vec<super::MutuallyExclusiveClustersItemItem>>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.mutually_exclusive_clusters = value.try_into().map_err(|e| {
                format!("error converting supplied value for mutually_exclusive_clusters: {e}")
            });
            self
        }
        pub fn policy_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PolicyCid>,
            T::Error: ::std::fmt::Display,
        {
            self.policy_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for policy_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<KineticSeparationPolicy> for super::KineticSeparationPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: KineticSeparationPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                enforcement_action: value.enforcement_action?,
                mutually_exclusive_clusters: value.mutually_exclusive_clusters?,
                policy_cid: value.policy_cid?,
            })
        }
    }
    impl ::std::convert::From<super::KineticSeparationPolicy> for KineticSeparationPolicy {
        fn from(value: super::KineticSeparationPolicy) -> Self {
            Self {
                enforcement_action: Ok(value.enforcement_action),
                mutually_exclusive_clusters: Ok(value.mutually_exclusive_clusters),
                policy_cid: Ok(value.policy_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct LatentProjectionIntent {
        context_expansion: ::std::result::Result<
            ::std::option::Option<super::ContextExpansionPolicy>,
            ::std::string::String,
        >,
        min_isometry_score: ::std::result::Result<f64, ::std::string::String>,
        synthetic_target_vector:
            ::std::result::Result<super::VectorEmbeddingState, ::std::string::String>,
        top_k_candidates: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        topological_bounds: ::std::result::Result<
            ::std::option::Option<super::TopologicalRetrievalContract>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for LatentProjectionIntent {
        fn default() -> Self {
            Self {
                context_expansion: Ok(Default::default()),
                min_isometry_score: Err("no value supplied for min_isometry_score".to_string()),
                synthetic_target_vector: Err(
                    "no value supplied for synthetic_target_vector".to_string()
                ),
                top_k_candidates: Err("no value supplied for top_k_candidates".to_string()),
                topological_bounds: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl LatentProjectionIntent {
        pub fn context_expansion<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ContextExpansionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.context_expansion = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for context_expansion: {e}"));
            self
        }
        pub fn min_isometry_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.min_isometry_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for min_isometry_score: {e}")
            });
            self
        }
        pub fn synthetic_target_vector<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VectorEmbeddingState>,
            T::Error: ::std::fmt::Display,
        {
            self.synthetic_target_vector = value.try_into().map_err(|e| {
                format!("error converting supplied value for synthetic_target_vector: {e}")
            });
            self
        }
        pub fn top_k_candidates<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.top_k_candidates = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for top_k_candidates: {e}"));
            self
        }
        pub fn topological_bounds<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TopologicalRetrievalContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.topological_bounds = value.try_into().map_err(|e| {
                format!("error converting supplied value for topological_bounds: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<LatentProjectionIntent> for super::LatentProjectionIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: LatentProjectionIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                context_expansion: value.context_expansion?,
                min_isometry_score: value.min_isometry_score?,
                synthetic_target_vector: value.synthetic_target_vector?,
                top_k_candidates: value.top_k_candidates?,
                topological_bounds: value.topological_bounds?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::LatentProjectionIntent> for LatentProjectionIntent {
        fn from(value: super::LatentProjectionIntent) -> Self {
            Self {
                context_expansion: Ok(value.context_expansion),
                min_isometry_score: Ok(value.min_isometry_score),
                synthetic_target_vector: Ok(value.synthetic_target_vector),
                top_k_candidates: Ok(value.top_k_candidates),
                topological_bounds: Ok(value.topological_bounds),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct LatentSchemaInferenceIntent {
        max_properties: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        max_schema_depth: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        require_strict_validation:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        target_buffer_cid: ::std::result::Result<super::TargetBufferCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for LatentSchemaInferenceIntent {
        fn default() -> Self {
            Self {
                max_properties: Err("no value supplied for max_properties".to_string()),
                max_schema_depth: Err("no value supplied for max_schema_depth".to_string()),
                require_strict_validation: Ok(Default::default()),
                target_buffer_cid: Err("no value supplied for target_buffer_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl LatentSchemaInferenceIntent {
        pub fn max_properties<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_properties = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_properties: {e}"));
            self
        }
        pub fn max_schema_depth<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_schema_depth = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_schema_depth: {e}"));
            self
        }
        pub fn require_strict_validation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.require_strict_validation = value.try_into().map_err(|e| {
                format!("error converting supplied value for require_strict_validation: {e}")
            });
            self
        }
        pub fn target_buffer_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetBufferCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_buffer_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_buffer_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<LatentSchemaInferenceIntent> for super::LatentSchemaInferenceIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: LatentSchemaInferenceIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_properties: value.max_properties?,
                max_schema_depth: value.max_schema_depth?,
                require_strict_validation: value.require_strict_validation?,
                target_buffer_cid: value.target_buffer_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::LatentSchemaInferenceIntent> for LatentSchemaInferenceIntent {
        fn from(value: super::LatentSchemaInferenceIntent) -> Self {
            Self {
                max_properties: Ok(value.max_properties),
                max_schema_depth: Ok(value.max_schema_depth),
                require_strict_validation: Ok(value.require_strict_validation),
                target_buffer_cid: Ok(value.target_buffer_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct LatentScratchpadReceipt {
        discarded_branches: ::std::result::Result<
            ::std::vec::Vec<super::DiscardedBranchesItem>,
            ::std::string::String,
        >,
        explored_branches: ::std::result::Result<
            ::std::vec::Vec<super::AnyExplorationBranch>,
            ::std::string::String,
        >,
        resolution_branch_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        total_latent_tokens: ::std::result::Result<u64, ::std::string::String>,
        trace_cid: ::std::result::Result<super::TraceCid, ::std::string::String>,
    }
    impl ::std::default::Default for LatentScratchpadReceipt {
        fn default() -> Self {
            Self {
                discarded_branches: Err("no value supplied for discarded_branches".to_string()),
                explored_branches: Err("no value supplied for explored_branches".to_string()),
                resolution_branch_cid: Ok(Default::default()),
                total_latent_tokens: Err("no value supplied for total_latent_tokens".to_string()),
                trace_cid: Err("no value supplied for trace_cid".to_string()),
            }
        }
    }
    impl LatentScratchpadReceipt {
        pub fn discarded_branches<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::DiscardedBranchesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.discarded_branches = value.try_into().map_err(|e| {
                format!("error converting supplied value for discarded_branches: {e}")
            });
            self
        }
        pub fn explored_branches<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AnyExplorationBranch>>,
            T::Error: ::std::fmt::Display,
        {
            self.explored_branches = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for explored_branches: {e}"));
            self
        }
        pub fn resolution_branch_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.resolution_branch_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for resolution_branch_cid: {e}")
            });
            self
        }
        pub fn total_latent_tokens<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.total_latent_tokens = value.try_into().map_err(|e| {
                format!("error converting supplied value for total_latent_tokens: {e}")
            });
            self
        }
        pub fn trace_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TraceCid>,
            T::Error: ::std::fmt::Display,
        {
            self.trace_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for trace_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<LatentScratchpadReceipt> for super::LatentScratchpadReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: LatentScratchpadReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                discarded_branches: value.discarded_branches?,
                explored_branches: value.explored_branches?,
                resolution_branch_cid: value.resolution_branch_cid?,
                total_latent_tokens: value.total_latent_tokens?,
                trace_cid: value.trace_cid?,
            })
        }
    }
    impl ::std::convert::From<super::LatentScratchpadReceipt> for LatentScratchpadReceipt {
        fn from(value: super::LatentScratchpadReceipt) -> Self {
            Self {
                discarded_branches: Ok(value.discarded_branches),
                explored_branches: Ok(value.explored_branches),
                resolution_branch_cid: Ok(value.resolution_branch_cid),
                total_latent_tokens: Ok(value.total_latent_tokens),
                trace_cid: Ok(value.trace_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct LatentSmoothingProfile {
        decay_function: ::std::result::Result<super::DecayFunction, ::std::string::String>,
        decay_rate_param: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        transition_window_tokens:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for LatentSmoothingProfile {
        fn default() -> Self {
            Self {
                decay_function: Err("no value supplied for decay_function".to_string()),
                decay_rate_param: Ok(Default::default()),
                transition_window_tokens: Err(
                    "no value supplied for transition_window_tokens".to_string()
                ),
            }
        }
    }
    impl LatentSmoothingProfile {
        pub fn decay_function<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DecayFunction>,
            T::Error: ::std::fmt::Display,
        {
            self.decay_function = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for decay_function: {e}"));
            self
        }
        pub fn decay_rate_param<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.decay_rate_param = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for decay_rate_param: {e}"));
            self
        }
        pub fn transition_window_tokens<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.transition_window_tokens = value.try_into().map_err(|e| {
                format!("error converting supplied value for transition_window_tokens: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<LatentSmoothingProfile> for super::LatentSmoothingProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: LatentSmoothingProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                decay_function: value.decay_function?,
                decay_rate_param: value.decay_rate_param?,
                transition_window_tokens: value.transition_window_tokens?,
            })
        }
    }
    impl ::std::convert::From<super::LatentSmoothingProfile> for LatentSmoothingProfile {
        fn from(value: super::LatentSmoothingProfile) -> Self {
            Self {
                decay_function: Ok(value.decay_function),
                decay_rate_param: Ok(value.decay_rate_param),
                transition_window_tokens: Ok(value.transition_window_tokens),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct LineageWatermarkReceipt {
        hop_signatures: ::std::result::Result<
            ::std::collections::HashMap<
                ::std::string::String,
                super::LineageWatermarkReceiptHopSignaturesValue,
            >,
            ::std::string::String,
        >,
        tamper_evident_root: ::std::result::Result<super::TamperEvidentRoot, ::std::string::String>,
        watermark_protocol: ::std::result::Result<super::WatermarkProtocol, ::std::string::String>,
    }
    impl ::std::default::Default for LineageWatermarkReceipt {
        fn default() -> Self {
            Self {
                hop_signatures: Err("no value supplied for hop_signatures".to_string()),
                tamper_evident_root: Err("no value supplied for tamper_evident_root".to_string()),
                watermark_protocol: Err("no value supplied for watermark_protocol".to_string()),
            }
        }
    }
    impl LineageWatermarkReceipt {
        pub fn hop_signatures<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::LineageWatermarkReceiptHopSignaturesValue,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.hop_signatures = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for hop_signatures: {e}"));
            self
        }
        pub fn tamper_evident_root<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TamperEvidentRoot>,
            T::Error: ::std::fmt::Display,
        {
            self.tamper_evident_root = value.try_into().map_err(|e| {
                format!("error converting supplied value for tamper_evident_root: {e}")
            });
            self
        }
        pub fn watermark_protocol<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::WatermarkProtocol>,
            T::Error: ::std::fmt::Display,
        {
            self.watermark_protocol = value.try_into().map_err(|e| {
                format!("error converting supplied value for watermark_protocol: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<LineageWatermarkReceipt> for super::LineageWatermarkReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: LineageWatermarkReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                hop_signatures: value.hop_signatures?,
                tamper_evident_root: value.tamper_evident_root?,
                watermark_protocol: value.watermark_protocol?,
            })
        }
    }
    impl ::std::convert::From<super::LineageWatermarkReceipt> for LineageWatermarkReceipt {
        fn from(value: super::LineageWatermarkReceipt) -> Self {
            Self {
                hop_signatures: Ok(value.hop_signatures),
                tamper_evident_root: Ok(value.tamper_evident_root),
                watermark_protocol: Ok(value.watermark_protocol),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct LinkMlValidationSla {
        linkml_schema_uri: ::std::result::Result<::std::string::String, ::std::string::String>,
    }
    impl ::std::default::Default for LinkMlValidationSla {
        fn default() -> Self {
            Self {
                linkml_schema_uri: Err("no value supplied for linkml_schema_uri".to_string()),
            }
        }
    }
    impl LinkMlValidationSla {
        pub fn linkml_schema_uri<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.linkml_schema_uri = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for linkml_schema_uri: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<LinkMlValidationSla> for super::LinkMlValidationSla {
        type Error = super::error::ConversionError;
        fn try_from(
            value: LinkMlValidationSla,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                linkml_schema_uri: value.linkml_schema_uri?,
            })
        }
    }
    impl ::std::convert::From<super::LinkMlValidationSla> for LinkMlValidationSla {
        fn from(value: super::LinkMlValidationSla) -> Self {
            Self {
                linkml_schema_uri: Ok(value.linkml_schema_uri),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct LogitSteganographyContract {
        context_history_window: ::std::result::Result<u64, ::std::string::String>,
        prf_seed_hash: ::std::result::Result<super::PrfSeedHash, ::std::string::String>,
        target_bits_per_token: ::std::result::Result<f64, ::std::string::String>,
        verification_public_key_cid:
            ::std::result::Result<super::VerificationPublicKeyCid, ::std::string::String>,
        watermark_strength_delta: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for LogitSteganographyContract {
        fn default() -> Self {
            Self {
                context_history_window: Err(
                    "no value supplied for context_history_window".to_string()
                ),
                prf_seed_hash: Err("no value supplied for prf_seed_hash".to_string()),
                target_bits_per_token: Err(
                    "no value supplied for target_bits_per_token".to_string()
                ),
                verification_public_key_cid: Err(
                    "no value supplied for verification_public_key_cid".to_string(),
                ),
                watermark_strength_delta: Err(
                    "no value supplied for watermark_strength_delta".to_string()
                ),
            }
        }
    }
    impl LogitSteganographyContract {
        pub fn context_history_window<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.context_history_window = value.try_into().map_err(|e| {
                format!("error converting supplied value for context_history_window: {e}")
            });
            self
        }
        pub fn prf_seed_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PrfSeedHash>,
            T::Error: ::std::fmt::Display,
        {
            self.prf_seed_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prf_seed_hash: {e}"));
            self
        }
        pub fn target_bits_per_token<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.target_bits_per_token = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_bits_per_token: {e}")
            });
            self
        }
        pub fn verification_public_key_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VerificationPublicKeyCid>,
            T::Error: ::std::fmt::Display,
        {
            self.verification_public_key_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for verification_public_key_cid: {e}")
            });
            self
        }
        pub fn watermark_strength_delta<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.watermark_strength_delta = value.try_into().map_err(|e| {
                format!("error converting supplied value for watermark_strength_delta: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<LogitSteganographyContract> for super::LogitSteganographyContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: LogitSteganographyContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                context_history_window: value.context_history_window?,
                prf_seed_hash: value.prf_seed_hash?,
                target_bits_per_token: value.target_bits_per_token?,
                verification_public_key_cid: value.verification_public_key_cid?,
                watermark_strength_delta: value.watermark_strength_delta?,
            })
        }
    }
    impl ::std::convert::From<super::LogitSteganographyContract> for LogitSteganographyContract {
        fn from(value: super::LogitSteganographyContract) -> Self {
            Self {
                context_history_window: Ok(value.context_history_window),
                prf_seed_hash: Ok(value.prf_seed_hash),
                target_bits_per_token: Ok(value.target_bits_per_token),
                verification_public_key_cid: Ok(value.verification_public_key_cid),
                watermark_strength_delta: Ok(value.watermark_strength_delta),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct MacroGridProfile {
        column_fractional_weights:
            ::std::result::Result<::std::vec::Vec<f64>, ::std::string::String>,
        layout_matrix: ::std::result::Result<
            ::std::vec::Vec<::std::vec::Vec<super::LayoutMatrixItemItem>>,
            ::std::string::String,
        >,
        panels:
            ::std::result::Result<::std::vec::Vec<super::AnyPanelProfile>, ::std::string::String>,
        row_fractional_weights: ::std::result::Result<::std::vec::Vec<f64>, ::std::string::String>,
    }
    impl ::std::default::Default for MacroGridProfile {
        fn default() -> Self {
            Self {
                column_fractional_weights: Ok(Default::default()),
                layout_matrix: Err("no value supplied for layout_matrix".to_string()),
                panels: Err("no value supplied for panels".to_string()),
                row_fractional_weights: Ok(Default::default()),
            }
        }
    }
    impl MacroGridProfile {
        pub fn column_fractional_weights<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.column_fractional_weights = value.try_into().map_err(|e| {
                format!("error converting supplied value for column_fractional_weights: {e}")
            });
            self
        }
        pub fn layout_matrix<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::vec::Vec<::std::vec::Vec<super::LayoutMatrixItemItem>>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.layout_matrix = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for layout_matrix: {e}"));
            self
        }
        pub fn panels<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AnyPanelProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.panels = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for panels: {e}"));
            self
        }
        pub fn row_fractional_weights<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.row_fractional_weights = value.try_into().map_err(|e| {
                format!("error converting supplied value for row_fractional_weights: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<MacroGridProfile> for super::MacroGridProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: MacroGridProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                column_fractional_weights: value.column_fractional_weights?,
                layout_matrix: value.layout_matrix?,
                panels: value.panels?,
                row_fractional_weights: value.row_fractional_weights?,
            })
        }
    }
    impl ::std::convert::From<super::MacroGridProfile> for MacroGridProfile {
        fn from(value: super::MacroGridProfile) -> Self {
            Self {
                column_fractional_weights: Ok(value.column_fractional_weights),
                layout_matrix: Ok(value.layout_matrix),
                panels: Ok(value.panels),
                row_fractional_weights: Ok(value.row_fractional_weights),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ManifestViolationReceipt {
        diagnostic_message: ::std::result::Result<super::DiagnosticMessage, ::std::string::String>,
        failing_pointer: ::std::result::Result<super::FailingPointer, ::std::string::String>,
        violation_category: ::std::result::Result<super::ViolationCategory, ::std::string::String>,
    }
    impl ::std::default::Default for ManifestViolationReceipt {
        fn default() -> Self {
            Self {
                diagnostic_message: Err("no value supplied for diagnostic_message".to_string()),
                failing_pointer: Err("no value supplied for failing_pointer".to_string()),
                violation_category: Err("no value supplied for violation_category".to_string()),
            }
        }
    }
    impl ManifestViolationReceipt {
        pub fn diagnostic_message<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DiagnosticMessage>,
            T::Error: ::std::fmt::Display,
        {
            self.diagnostic_message = value.try_into().map_err(|e| {
                format!("error converting supplied value for diagnostic_message: {e}")
            });
            self
        }
        pub fn failing_pointer<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FailingPointer>,
            T::Error: ::std::fmt::Display,
        {
            self.failing_pointer = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for failing_pointer: {e}"));
            self
        }
        pub fn violation_category<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ViolationCategory>,
            T::Error: ::std::fmt::Display,
        {
            self.violation_category = value.try_into().map_err(|e| {
                format!("error converting supplied value for violation_category: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<ManifestViolationReceipt> for super::ManifestViolationReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ManifestViolationReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                diagnostic_message: value.diagnostic_message?,
                failing_pointer: value.failing_pointer?,
                violation_category: value.violation_category?,
            })
        }
    }
    impl ::std::convert::From<super::ManifestViolationReceipt> for ManifestViolationReceipt {
        fn from(value: super::ManifestViolationReceipt) -> Self {
            Self {
                diagnostic_message: Ok(value.diagnostic_message),
                failing_pointer: Ok(value.failing_pointer),
                violation_category: Ok(value.violation_category),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct MarketContract {
        minimum_collateral: ::std::result::Result<u64, ::std::string::String>,
        slashing_penalty: ::std::result::Result<u64, ::std::string::String>,
    }
    impl ::std::default::Default for MarketContract {
        fn default() -> Self {
            Self {
                minimum_collateral: Err("no value supplied for minimum_collateral".to_string()),
                slashing_penalty: Err("no value supplied for slashing_penalty".to_string()),
            }
        }
    }
    impl MarketContract {
        pub fn minimum_collateral<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.minimum_collateral = value.try_into().map_err(|e| {
                format!("error converting supplied value for minimum_collateral: {e}")
            });
            self
        }
        pub fn slashing_penalty<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.slashing_penalty = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for slashing_penalty: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<MarketContract> for super::MarketContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: MarketContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                minimum_collateral: value.minimum_collateral?,
                slashing_penalty: value.slashing_penalty?,
            })
        }
    }
    impl ::std::convert::From<super::MarketContract> for MarketContract {
        fn from(value: super::MarketContract) -> Self {
            Self {
                minimum_collateral: Ok(value.minimum_collateral),
                slashing_penalty: Ok(value.slashing_penalty),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct MarketResolutionState {
        falsified_hypothesis_cids: ::std::result::Result<
            ::std::vec::Vec<super::FalsifiedHypothesisCidsItem>,
            ::std::string::String,
        >,
        market_cid: ::std::result::Result<super::MarketCid, ::std::string::String>,
        payout_distribution: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, u64>,
            ::std::string::String,
        >,
        winning_hypothesis_cid:
            ::std::result::Result<super::WinningHypothesisCid, ::std::string::String>,
    }
    impl ::std::default::Default for MarketResolutionState {
        fn default() -> Self {
            Self {
                falsified_hypothesis_cids: Err(
                    "no value supplied for falsified_hypothesis_cids".to_string()
                ),
                market_cid: Err("no value supplied for market_cid".to_string()),
                payout_distribution: Err("no value supplied for payout_distribution".to_string()),
                winning_hypothesis_cid: Err(
                    "no value supplied for winning_hypothesis_cid".to_string()
                ),
            }
        }
    }
    impl MarketResolutionState {
        pub fn falsified_hypothesis_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::FalsifiedHypothesisCidsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.falsified_hypothesis_cids = value.try_into().map_err(|e| {
                format!("error converting supplied value for falsified_hypothesis_cids: {e}")
            });
            self
        }
        pub fn market_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MarketCid>,
            T::Error: ::std::fmt::Display,
        {
            self.market_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for market_cid: {e}"));
            self
        }
        pub fn payout_distribution<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::collections::HashMap<::std::string::String, u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.payout_distribution = value.try_into().map_err(|e| {
                format!("error converting supplied value for payout_distribution: {e}")
            });
            self
        }
        pub fn winning_hypothesis_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::WinningHypothesisCid>,
            T::Error: ::std::fmt::Display,
        {
            self.winning_hypothesis_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for winning_hypothesis_cid: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<MarketResolutionState> for super::MarketResolutionState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: MarketResolutionState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                falsified_hypothesis_cids: value.falsified_hypothesis_cids?,
                market_cid: value.market_cid?,
                payout_distribution: value.payout_distribution?,
                winning_hypothesis_cid: value.winning_hypothesis_cid?,
            })
        }
    }
    impl ::std::convert::From<super::MarketResolutionState> for MarketResolutionState {
        fn from(value: super::MarketResolutionState) -> Self {
            Self {
                falsified_hypothesis_cids: Ok(value.falsified_hypothesis_cids),
                market_cid: Ok(value.market_cid),
                payout_distribution: Ok(value.payout_distribution),
                winning_hypothesis_cid: Ok(value.winning_hypothesis_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct MarkovBlanketRenderingPolicy {
        expose_sensory_active_states:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        occlude_internal_mechanistics:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        pierce_distance_meters: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for MarkovBlanketRenderingPolicy {
        fn default() -> Self {
            Self {
                expose_sensory_active_states: Ok(Default::default()),
                occlude_internal_mechanistics: Ok(Default::default()),
                pierce_distance_meters: Err(
                    "no value supplied for pierce_distance_meters".to_string()
                ),
            }
        }
    }
    impl MarkovBlanketRenderingPolicy {
        pub fn expose_sensory_active_states<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.expose_sensory_active_states = value.try_into().map_err(|e| {
                format!("error converting supplied value for expose_sensory_active_states: {e}")
            });
            self
        }
        pub fn occlude_internal_mechanistics<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.occlude_internal_mechanistics = value.try_into().map_err(|e| {
                format!("error converting supplied value for occlude_internal_mechanistics: {e}")
            });
            self
        }
        pub fn pierce_distance_meters<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.pierce_distance_meters = value.try_into().map_err(|e| {
                format!("error converting supplied value for pierce_distance_meters: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<MarkovBlanketRenderingPolicy> for super::MarkovBlanketRenderingPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: MarkovBlanketRenderingPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                expose_sensory_active_states: value.expose_sensory_active_states?,
                occlude_internal_mechanistics: value.occlude_internal_mechanistics?,
                pierce_distance_meters: value.pierce_distance_meters?,
            })
        }
    }
    impl ::std::convert::From<super::MarkovBlanketRenderingPolicy> for MarkovBlanketRenderingPolicy {
        fn from(value: super::MarkovBlanketRenderingPolicy) -> Self {
            Self {
                expose_sensory_active_states: Ok(value.expose_sensory_active_states),
                occlude_internal_mechanistics: Ok(value.occlude_internal_mechanistics),
                pierce_distance_meters: Ok(value.pierce_distance_meters),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct McpCapabilityWhitelistPolicy {
        allowed_prompts: ::std::result::Result<
            ::std::vec::Vec<super::AllowedPromptsItem>,
            ::std::string::String,
        >,
        allowed_resources: ::std::result::Result<
            ::std::vec::Vec<super::AllowedResourcesItem>,
            ::std::string::String,
        >,
        authorized_capability_array: ::std::result::Result<
            ::std::vec::Vec<super::AuthorizedCapabilityArrayItem>,
            ::std::string::String,
        >,
        required_licenses: ::std::result::Result<
            ::std::vec::Vec<super::RequiredLicensesItem>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for McpCapabilityWhitelistPolicy {
        fn default() -> Self {
            Self {
                allowed_prompts: Ok(Default::default()),
                allowed_resources: Ok(Default::default()),
                authorized_capability_array: Ok(Default::default()),
                required_licenses: Ok(Default::default()),
            }
        }
    }
    impl McpCapabilityWhitelistPolicy {
        pub fn allowed_prompts<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AllowedPromptsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.allowed_prompts = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for allowed_prompts: {e}"));
            self
        }
        pub fn allowed_resources<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AllowedResourcesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.allowed_resources = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for allowed_resources: {e}"));
            self
        }
        pub fn authorized_capability_array<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AuthorizedCapabilityArrayItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.authorized_capability_array = value.try_into().map_err(|e| {
                format!("error converting supplied value for authorized_capability_array: {e}")
            });
            self
        }
        pub fn required_licenses<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::RequiredLicensesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.required_licenses = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for required_licenses: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<McpCapabilityWhitelistPolicy> for super::McpCapabilityWhitelistPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: McpCapabilityWhitelistPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                allowed_prompts: value.allowed_prompts?,
                allowed_resources: value.allowed_resources?,
                authorized_capability_array: value.authorized_capability_array?,
                required_licenses: value.required_licenses?,
            })
        }
    }
    impl ::std::convert::From<super::McpCapabilityWhitelistPolicy> for McpCapabilityWhitelistPolicy {
        fn from(value: super::McpCapabilityWhitelistPolicy) -> Self {
            Self {
                allowed_prompts: Ok(value.allowed_prompts),
                allowed_resources: Ok(value.allowed_resources),
                authorized_capability_array: Ok(value.authorized_capability_array),
                required_licenses: Ok(value.required_licenses),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct McpClientIntent {
        holographic_projection:
            ::std::result::Result<super::DynamicManifoldProjectionManifest, ::std::string::String>,
        id: ::std::result::Result<::std::option::Option<super::Id>, ::std::string::String>,
        jsonrpc: ::std::result::Result<::std::string::String, ::std::string::String>,
        method: ::std::result::Result<::std::string::String, ::std::string::String>,
        params: ::std::result::Result<
            ::std::option::Option<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for McpClientIntent {
        fn default() -> Self {
            Self {
                holographic_projection: Err(
                    "no value supplied for holographic_projection".to_string()
                ),
                id: Ok(Default::default()),
                jsonrpc: Err("no value supplied for jsonrpc".to_string()),
                method: Err("no value supplied for method".to_string()),
                params: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl McpClientIntent {
        pub fn holographic_projection<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DynamicManifoldProjectionManifest>,
            T::Error: ::std::fmt::Display,
        {
            self.holographic_projection = value.try_into().map_err(|e| {
                format!("error converting supplied value for holographic_projection: {e}")
            });
            self
        }
        pub fn id<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::Id>>,
            T::Error: ::std::fmt::Display,
        {
            self.id = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for id: {e}"));
            self
        }
        pub fn jsonrpc<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.jsonrpc = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for jsonrpc: {e}"));
            self
        }
        pub fn method<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.method = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for method: {e}"));
            self
        }
        pub fn params<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.params = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for params: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<McpClientIntent> for super::McpClientIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: McpClientIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                holographic_projection: value.holographic_projection?,
                id: value.id?,
                jsonrpc: value.jsonrpc?,
                method: value.method?,
                params: value.params?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::McpClientIntent> for McpClientIntent {
        fn from(value: super::McpClientIntent) -> Self {
            Self {
                holographic_projection: Ok(value.holographic_projection),
                id: Ok(value.id),
                jsonrpc: Ok(value.jsonrpc),
                method: Ok(value.method),
                params: Ok(value.params),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct McpPromptReferenceState {
        arguments: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        fallback_persona: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        prompt_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        prompt_name: ::std::result::Result<super::PromptName, ::std::string::String>,
        server_cid: ::std::result::Result<super::ServerCid, ::std::string::String>,
    }
    impl ::std::default::Default for McpPromptReferenceState {
        fn default() -> Self {
            Self {
                arguments: Ok(Default::default()),
                fallback_persona: Ok(Default::default()),
                prompt_hash: Ok(Default::default()),
                prompt_name: Err("no value supplied for prompt_name".to_string()),
                server_cid: Err("no value supplied for server_cid".to_string()),
            }
        }
    }
    impl McpPromptReferenceState {
        pub fn arguments<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.arguments = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for arguments: {e}"));
            self
        }
        pub fn fallback_persona<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.fallback_persona = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for fallback_persona: {e}"));
            self
        }
        pub fn prompt_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prompt_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prompt_hash: {e}"));
            self
        }
        pub fn prompt_name<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PromptName>,
            T::Error: ::std::fmt::Display,
        {
            self.prompt_name = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prompt_name: {e}"));
            self
        }
        pub fn server_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ServerCid>,
            T::Error: ::std::fmt::Display,
        {
            self.server_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for server_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<McpPromptReferenceState> for super::McpPromptReferenceState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: McpPromptReferenceState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                arguments: value.arguments?,
                fallback_persona: value.fallback_persona?,
                prompt_hash: value.prompt_hash?,
                prompt_name: value.prompt_name?,
                server_cid: value.server_cid?,
            })
        }
    }
    impl ::std::convert::From<super::McpPromptReferenceState> for McpPromptReferenceState {
        fn from(value: super::McpPromptReferenceState) -> Self {
            Self {
                arguments: Ok(value.arguments),
                fallback_persona: Ok(value.fallback_persona),
                prompt_hash: Ok(value.prompt_hash),
                prompt_name: Ok(value.prompt_name),
                server_cid: Ok(value.server_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct McpResourceManifest {
        server_cid: ::std::result::Result<super::ServerCid, ::std::string::String>,
        uris: ::std::result::Result<::std::vec::Vec<super::UrisItem>, ::std::string::String>,
    }
    impl ::std::default::Default for McpResourceManifest {
        fn default() -> Self {
            Self {
                server_cid: Err("no value supplied for server_cid".to_string()),
                uris: Ok(Default::default()),
            }
        }
    }
    impl McpResourceManifest {
        pub fn server_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ServerCid>,
            T::Error: ::std::fmt::Display,
        {
            self.server_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for server_cid: {e}"));
            self
        }
        pub fn uris<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::UrisItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.uris = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for uris: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<McpResourceManifest> for super::McpResourceManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: McpResourceManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                server_cid: value.server_cid?,
                uris: value.uris?,
            })
        }
    }
    impl ::std::convert::From<super::McpResourceManifest> for McpResourceManifest {
        fn from(value: super::McpResourceManifest) -> Self {
            Self {
                server_cid: Ok(value.server_cid),
                uris: Ok(value.uris),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct McpServerManifest {
        attestation_receipt: ::std::result::Result<
            super::VerifiableCredentialPresentationReceipt,
            ::std::string::String,
        >,
        binary_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        capability_whitelist:
            ::std::result::Result<super::McpCapabilityWhitelistPolicy, ::std::string::String>,
        server_cid: ::std::result::Result<super::ServerCid, ::std::string::String>,
        state_synchronization_optics: ::std::result::Result<
            ::std::vec::Vec<super::OpticalMappingContract>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        transport: ::std::result::Result<super::Transport, ::std::string::String>,
    }
    impl ::std::default::Default for McpServerManifest {
        fn default() -> Self {
            Self {
                attestation_receipt: Err("no value supplied for attestation_receipt".to_string()),
                binary_hash: Ok(Default::default()),
                capability_whitelist: Err("no value supplied for capability_whitelist".to_string()),
                server_cid: Err("no value supplied for server_cid".to_string()),
                state_synchronization_optics: Ok(Default::default()),
                topology_class: Ok(Default::default()),
                transport: Err("no value supplied for transport".to_string()),
            }
        }
    }
    impl McpServerManifest {
        pub fn attestation_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VerifiableCredentialPresentationReceipt>,
            T::Error: ::std::fmt::Display,
        {
            self.attestation_receipt = value.try_into().map_err(|e| {
                format!("error converting supplied value for attestation_receipt: {e}")
            });
            self
        }
        pub fn binary_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.binary_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for binary_hash: {e}"));
            self
        }
        pub fn capability_whitelist<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::McpCapabilityWhitelistPolicy>,
            T::Error: ::std::fmt::Display,
        {
            self.capability_whitelist = value.try_into().map_err(|e| {
                format!("error converting supplied value for capability_whitelist: {e}")
            });
            self
        }
        pub fn server_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ServerCid>,
            T::Error: ::std::fmt::Display,
        {
            self.server_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for server_cid: {e}"));
            self
        }
        pub fn state_synchronization_optics<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::OpticalMappingContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.state_synchronization_optics = value.try_into().map_err(|e| {
                format!("error converting supplied value for state_synchronization_optics: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn transport<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Transport>,
            T::Error: ::std::fmt::Display,
        {
            self.transport = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for transport: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<McpServerManifest> for super::McpServerManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: McpServerManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                attestation_receipt: value.attestation_receipt?,
                binary_hash: value.binary_hash?,
                capability_whitelist: value.capability_whitelist?,
                server_cid: value.server_cid?,
                state_synchronization_optics: value.state_synchronization_optics?,
                topology_class: value.topology_class?,
                transport: value.transport?,
            })
        }
    }
    impl ::std::convert::From<super::McpServerManifest> for McpServerManifest {
        fn from(value: super::McpServerManifest) -> Self {
            Self {
                attestation_receipt: Ok(value.attestation_receipt),
                binary_hash: Ok(value.binary_hash),
                capability_whitelist: Ok(value.capability_whitelist),
                server_cid: Ok(value.server_cid),
                state_synchronization_optics: Ok(value.state_synchronization_optics),
                topology_class: Ok(value.topology_class),
                transport: Ok(value.transport),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct McpToolDefinition {
        description: ::std::result::Result<super::Description, ::std::string::String>,
        event_cid:
            ::std::result::Result<::std::option::Option<super::EventCid>, ::std::string::String>,
        input_schema: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        name: ::std::result::Result<super::Name, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for McpToolDefinition {
        fn default() -> Self {
            Self {
                description: Err("no value supplied for description".to_string()),
                event_cid: Ok(Default::default()),
                input_schema: Err("no value supplied for input_schema".to_string()),
                name: Err("no value supplied for name".to_string()),
                prior_event_hash: Ok(Default::default()),
                timestamp: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl McpToolDefinition {
        pub fn description<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Description>,
            T::Error: ::std::fmt::Display,
        {
            self.description = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for description: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EventCid>>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn input_schema<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.input_schema = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for input_schema: {e}"));
            self
        }
        pub fn name<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Name>,
            T::Error: ::std::fmt::Display,
        {
            self.name = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for name: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<McpToolDefinition> for super::McpToolDefinition {
        type Error = super::error::ConversionError;
        fn try_from(
            value: McpToolDefinition,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                description: value.description?,
                event_cid: value.event_cid?,
                input_schema: value.input_schema?,
                name: value.name?,
                prior_event_hash: value.prior_event_hash?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::McpToolDefinition> for McpToolDefinition {
        fn from(value: super::McpToolDefinition) -> Self {
            Self {
                description: Ok(value.description),
                event_cid: Ok(value.event_cid),
                input_schema: Ok(value.input_schema),
                name: Ok(value.name),
                prior_event_hash: Ok(value.prior_event_hash),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct MechanisticAuditContract {
        max_features_per_layer:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        require_zk_commitments:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        target_hook_points: ::std::result::Result<
            ::std::vec::Vec<super::TargetHookPointsItem>,
            ::std::string::String,
        >,
        trigger_conditions: ::std::result::Result<
            ::std::vec::Vec<super::TriggerConditionsItem>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for MechanisticAuditContract {
        fn default() -> Self {
            Self {
                max_features_per_layer: Err(
                    "no value supplied for max_features_per_layer".to_string()
                ),
                require_zk_commitments: Ok(Default::default()),
                target_hook_points: Err("no value supplied for target_hook_points".to_string()),
                trigger_conditions: Err("no value supplied for trigger_conditions".to_string()),
            }
        }
    }
    impl MechanisticAuditContract {
        pub fn max_features_per_layer<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_features_per_layer = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_features_per_layer: {e}")
            });
            self
        }
        pub fn require_zk_commitments<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.require_zk_commitments = value.try_into().map_err(|e| {
                format!("error converting supplied value for require_zk_commitments: {e}")
            });
            self
        }
        pub fn target_hook_points<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::TargetHookPointsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.target_hook_points = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_hook_points: {e}")
            });
            self
        }
        pub fn trigger_conditions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::TriggerConditionsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.trigger_conditions = value.try_into().map_err(|e| {
                format!("error converting supplied value for trigger_conditions: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<MechanisticAuditContract> for super::MechanisticAuditContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: MechanisticAuditContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_features_per_layer: value.max_features_per_layer?,
                require_zk_commitments: value.require_zk_commitments?,
                target_hook_points: value.target_hook_points?,
                trigger_conditions: value.trigger_conditions?,
            })
        }
    }
    impl ::std::convert::From<super::MechanisticAuditContract> for MechanisticAuditContract {
        fn from(value: super::MechanisticAuditContract) -> Self {
            Self {
                max_features_per_layer: Ok(value.max_features_per_layer),
                require_zk_commitments: Ok(value.require_zk_commitments),
                target_hook_points: Ok(value.target_hook_points),
                trigger_conditions: Ok(value.trigger_conditions),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct MemoizedNodeProfile {
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        description: ::std::result::Result<super::Description, ::std::string::String>,
        domain_extensions: ::std::result::Result<
            ::std::option::Option<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            ::std::string::String,
        >,
        expected_output_schema: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        intervention_policies: ::std::result::Result<
            ::std::vec::Vec<super::InterventionPolicy>,
            ::std::string::String,
        >,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        markov_blanket: ::std::result::Result<
            ::std::option::Option<super::MarkovBlanketRenderingPolicy>,
            ::std::string::String,
        >,
        render_material: ::std::result::Result<
            ::std::option::Option<super::SpatialRenderMaterial>,
            ::std::string::String,
        >,
        semantic_zoom: ::std::result::Result<
            ::std::option::Option<super::SemanticZoomProfile>,
            ::std::string::String,
        >,
        target_topology_hash:
            ::std::result::Result<super::TopologyHashReceipt, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for MemoizedNodeProfile {
        fn default() -> Self {
            Self {
                architectural_intent: Ok(Default::default()),
                description: Err("no value supplied for description".to_string()),
                domain_extensions: Ok(Default::default()),
                expected_output_schema: Err(
                    "no value supplied for expected_output_schema".to_string()
                ),
                intervention_policies: Ok(Default::default()),
                justification: Ok(Default::default()),
                markov_blanket: Ok(Default::default()),
                render_material: Ok(Default::default()),
                semantic_zoom: Ok(Default::default()),
                target_topology_hash: Err("no value supplied for target_topology_hash".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl MemoizedNodeProfile {
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn description<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Description>,
            T::Error: ::std::fmt::Display,
        {
            self.description = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for description: {e}"));
            self
        }
        pub fn domain_extensions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.domain_extensions = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for domain_extensions: {e}"));
            self
        }
        pub fn expected_output_schema<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.expected_output_schema = value.try_into().map_err(|e| {
                format!("error converting supplied value for expected_output_schema: {e}")
            });
            self
        }
        pub fn intervention_policies<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::InterventionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.intervention_policies = value.try_into().map_err(|e| {
                format!("error converting supplied value for intervention_policies: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn markov_blanket<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::MarkovBlanketRenderingPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.markov_blanket = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for markov_blanket: {e}"));
            self
        }
        pub fn render_material<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialRenderMaterial>>,
            T::Error: ::std::fmt::Display,
        {
            self.render_material = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for render_material: {e}"));
            self
        }
        pub fn semantic_zoom<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticZoomProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_zoom = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_zoom: {e}"));
            self
        }
        pub fn target_topology_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TopologyHashReceipt>,
            T::Error: ::std::fmt::Display,
        {
            self.target_topology_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_topology_hash: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<MemoizedNodeProfile> for super::MemoizedNodeProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: MemoizedNodeProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                architectural_intent: value.architectural_intent?,
                description: value.description?,
                domain_extensions: value.domain_extensions?,
                expected_output_schema: value.expected_output_schema?,
                intervention_policies: value.intervention_policies?,
                justification: value.justification?,
                markov_blanket: value.markov_blanket?,
                render_material: value.render_material?,
                semantic_zoom: value.semantic_zoom?,
                target_topology_hash: value.target_topology_hash?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::MemoizedNodeProfile> for MemoizedNodeProfile {
        fn from(value: super::MemoizedNodeProfile) -> Self {
            Self {
                architectural_intent: Ok(value.architectural_intent),
                description: Ok(value.description),
                domain_extensions: Ok(value.domain_extensions),
                expected_output_schema: Ok(value.expected_output_schema),
                intervention_policies: Ok(value.intervention_policies),
                justification: Ok(value.justification),
                markov_blanket: Ok(value.markov_blanket),
                render_material: Ok(value.render_material),
                semantic_zoom: Ok(value.semantic_zoom),
                target_topology_hash: Ok(value.target_topology_hash),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct MultimodalArtifactReceipt {
        artifact_cid: ::std::result::Result<super::ArtifactCid, ::std::string::String>,
        byte_stream_hash: ::std::result::Result<super::ByteStreamHash, ::std::string::String>,
        global_invariants: ::std::result::Result<
            ::std::option::Option<super::GlobalSemanticInvariantProfile>,
            ::std::string::String,
        >,
        mime_type: ::std::result::Result<super::MimeType, ::std::string::String>,
        temporal_ingest_timestamp: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for MultimodalArtifactReceipt {
        fn default() -> Self {
            Self {
                artifact_cid: Err("no value supplied for artifact_cid".to_string()),
                byte_stream_hash: Err("no value supplied for byte_stream_hash".to_string()),
                global_invariants: Ok(Default::default()),
                mime_type: Err("no value supplied for mime_type".to_string()),
                temporal_ingest_timestamp: Err(
                    "no value supplied for temporal_ingest_timestamp".to_string()
                ),
            }
        }
    }
    impl MultimodalArtifactReceipt {
        pub fn artifact_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ArtifactCid>,
            T::Error: ::std::fmt::Display,
        {
            self.artifact_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for artifact_cid: {e}"));
            self
        }
        pub fn byte_stream_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ByteStreamHash>,
            T::Error: ::std::fmt::Display,
        {
            self.byte_stream_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for byte_stream_hash: {e}"));
            self
        }
        pub fn global_invariants<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::GlobalSemanticInvariantProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.global_invariants = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for global_invariants: {e}"));
            self
        }
        pub fn mime_type<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MimeType>,
            T::Error: ::std::fmt::Display,
        {
            self.mime_type = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for mime_type: {e}"));
            self
        }
        pub fn temporal_ingest_timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_ingest_timestamp = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_ingest_timestamp: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<MultimodalArtifactReceipt> for super::MultimodalArtifactReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: MultimodalArtifactReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                artifact_cid: value.artifact_cid?,
                byte_stream_hash: value.byte_stream_hash?,
                global_invariants: value.global_invariants?,
                mime_type: value.mime_type?,
                temporal_ingest_timestamp: value.temporal_ingest_timestamp?,
            })
        }
    }
    impl ::std::convert::From<super::MultimodalArtifactReceipt> for MultimodalArtifactReceipt {
        fn from(value: super::MultimodalArtifactReceipt) -> Self {
            Self {
                artifact_cid: Ok(value.artifact_cid),
                byte_stream_hash: Ok(value.byte_stream_hash),
                global_invariants: Ok(value.global_invariants),
                mime_type: Ok(value.mime_type),
                temporal_ingest_timestamp: Ok(value.temporal_ingest_timestamp),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct MultimodalTokenAnchorState {
        block_class: ::std::result::Result<
            ::std::option::Option<super::MultimodalTokenAnchorStateBlockClass>,
            ::std::string::String,
        >,
        bounding_box: ::std::result::Result<
            ::std::option::Option<::std::vec::Vec<::serde_json::Value>>,
            ::std::string::String,
        >,
        temporal_frame_end_ms:
            ::std::result::Result<::std::option::Option<u64>, ::std::string::String>,
        temporal_frame_start_ms:
            ::std::result::Result<::std::option::Option<u64>, ::std::string::String>,
        token_span_end: ::std::result::Result<::std::option::Option<u64>, ::std::string::String>,
        token_span_start: ::std::result::Result<::std::option::Option<u64>, ::std::string::String>,
        visual_patch_hashes: ::std::result::Result<
            ::std::vec::Vec<super::VisualPatchHashesItem>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for MultimodalTokenAnchorState {
        fn default() -> Self {
            Self {
                block_class: Ok(Default::default()),
                bounding_box: Ok(Default::default()),
                temporal_frame_end_ms: Ok(Default::default()),
                temporal_frame_start_ms: Ok(Default::default()),
                token_span_end: Ok(Default::default()),
                token_span_start: Ok(Default::default()),
                visual_patch_hashes: Ok(Default::default()),
            }
        }
    }
    impl MultimodalTokenAnchorState {
        pub fn block_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<super::MultimodalTokenAnchorStateBlockClass>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.block_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for block_class: {e}"));
            self
        }
        pub fn bounding_box<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::vec::Vec<::serde_json::Value>>>,
            T::Error: ::std::fmt::Display,
        {
            self.bounding_box = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for bounding_box: {e}"));
            self
        }
        pub fn temporal_frame_end_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_frame_end_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_frame_end_ms: {e}")
            });
            self
        }
        pub fn temporal_frame_start_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_frame_start_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_frame_start_ms: {e}")
            });
            self
        }
        pub fn token_span_end<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.token_span_end = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for token_span_end: {e}"));
            self
        }
        pub fn token_span_start<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.token_span_start = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for token_span_start: {e}"));
            self
        }
        pub fn visual_patch_hashes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::VisualPatchHashesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.visual_patch_hashes = value.try_into().map_err(|e| {
                format!("error converting supplied value for visual_patch_hashes: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<MultimodalTokenAnchorState> for super::MultimodalTokenAnchorState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: MultimodalTokenAnchorState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                block_class: value.block_class?,
                bounding_box: value.bounding_box?,
                temporal_frame_end_ms: value.temporal_frame_end_ms?,
                temporal_frame_start_ms: value.temporal_frame_start_ms?,
                token_span_end: value.token_span_end?,
                token_span_start: value.token_span_start?,
                visual_patch_hashes: value.visual_patch_hashes?,
            })
        }
    }
    impl ::std::convert::From<super::MultimodalTokenAnchorState> for MultimodalTokenAnchorState {
        fn from(value: super::MultimodalTokenAnchorState) -> Self {
            Self {
                block_class: Ok(value.block_class),
                bounding_box: Ok(value.bounding_box),
                temporal_frame_end_ms: Ok(value.temporal_frame_end_ms),
                temporal_frame_start_ms: Ok(value.temporal_frame_start_ms),
                token_span_end: Ok(value.token_span_end),
                token_span_start: Ok(value.token_span_start),
                visual_patch_hashes: Ok(value.visual_patch_hashes),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct MutationPolicy {
        mutation_rate: ::std::result::Result<f64, ::std::string::String>,
        temperature_shift_variance: ::std::result::Result<f64, ::std::string::String>,
        verifiable_entropy: ::std::result::Result<
            ::std::option::Option<super::VerifiableEntropyReceipt>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for MutationPolicy {
        fn default() -> Self {
            Self {
                mutation_rate: Err("no value supplied for mutation_rate".to_string()),
                temperature_shift_variance: Err(
                    "no value supplied for temperature_shift_variance".to_string()
                ),
                verifiable_entropy: Ok(Default::default()),
            }
        }
    }
    impl MutationPolicy {
        pub fn mutation_rate<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.mutation_rate = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for mutation_rate: {e}"));
            self
        }
        pub fn temperature_shift_variance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.temperature_shift_variance = value.try_into().map_err(|e| {
                format!("error converting supplied value for temperature_shift_variance: {e}")
            });
            self
        }
        pub fn verifiable_entropy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VerifiableEntropyReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.verifiable_entropy = value.try_into().map_err(|e| {
                format!("error converting supplied value for verifiable_entropy: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<MutationPolicy> for super::MutationPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: MutationPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                mutation_rate: value.mutation_rate?,
                temperature_shift_variance: value.temperature_shift_variance?,
                verifiable_entropy: value.verifiable_entropy?,
            })
        }
    }
    impl ::std::convert::From<super::MutationPolicy> for MutationPolicy {
        fn from(value: super::MutationPolicy) -> Self {
            Self {
                mutation_rate: Ok(value.mutation_rate),
                temperature_shift_variance: Ok(value.temperature_shift_variance),
                verifiable_entropy: Ok(value.verifiable_entropy),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct NDimensionalTensorManifest {
        merkle_root: ::std::result::Result<super::MerkleRoot, ::std::string::String>,
        shape: ::std::result::Result<::std::vec::Vec<i64>, ::std::string::String>,
        storage_uri: ::std::result::Result<super::StorageUri, ::std::string::String>,
        structural_format:
            ::std::result::Result<super::TensorStructuralFormatProfile, ::std::string::String>,
        vram_footprint_bytes: ::std::result::Result<u64, ::std::string::String>,
    }
    impl ::std::default::Default for NDimensionalTensorManifest {
        fn default() -> Self {
            Self {
                merkle_root: Err("no value supplied for merkle_root".to_string()),
                shape: Err("no value supplied for shape".to_string()),
                storage_uri: Err("no value supplied for storage_uri".to_string()),
                structural_format: Err("no value supplied for structural_format".to_string()),
                vram_footprint_bytes: Err("no value supplied for vram_footprint_bytes".to_string()),
            }
        }
    }
    impl NDimensionalTensorManifest {
        pub fn merkle_root<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MerkleRoot>,
            T::Error: ::std::fmt::Display,
        {
            self.merkle_root = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for merkle_root: {e}"));
            self
        }
        pub fn shape<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<i64>>,
            T::Error: ::std::fmt::Display,
        {
            self.shape = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for shape: {e}"));
            self
        }
        pub fn storage_uri<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StorageUri>,
            T::Error: ::std::fmt::Display,
        {
            self.storage_uri = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for storage_uri: {e}"));
            self
        }
        pub fn structural_format<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TensorStructuralFormatProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.structural_format = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for structural_format: {e}"));
            self
        }
        pub fn vram_footprint_bytes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.vram_footprint_bytes = value.try_into().map_err(|e| {
                format!("error converting supplied value for vram_footprint_bytes: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<NDimensionalTensorManifest> for super::NDimensionalTensorManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: NDimensionalTensorManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                merkle_root: value.merkle_root?,
                shape: value.shape?,
                storage_uri: value.storage_uri?,
                structural_format: value.structural_format?,
                vram_footprint_bytes: value.vram_footprint_bytes?,
            })
        }
    }
    impl ::std::convert::From<super::NDimensionalTensorManifest> for NDimensionalTensorManifest {
        fn from(value: super::NDimensionalTensorManifest) -> Self {
            Self {
                merkle_root: Ok(value.merkle_root),
                shape: Ok(value.shape),
                storage_uri: Ok(value.storage_uri),
                structural_format: Ok(value.structural_format),
                vram_footprint_bytes: Ok(value.vram_footprint_bytes),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct NeuralAuditAttestationReceipt {
        audit_cid: ::std::result::Result<super::AuditCid, ::std::string::String>,
        causal_scrubbing_applied:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        hook_activations: ::std::result::Result<
            ::std::collections::HashMap<
                ::std::string::String,
                ::std::vec::Vec<super::SaeFeatureActivationState>,
            >,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for NeuralAuditAttestationReceipt {
        fn default() -> Self {
            Self {
                audit_cid: Err("no value supplied for audit_cid".to_string()),
                causal_scrubbing_applied: Ok(Default::default()),
                hook_activations: Err("no value supplied for hook_activations".to_string()),
            }
        }
    }
    impl NeuralAuditAttestationReceipt {
        pub fn audit_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AuditCid>,
            T::Error: ::std::fmt::Display,
        {
            self.audit_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for audit_cid: {e}"));
            self
        }
        pub fn causal_scrubbing_applied<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_scrubbing_applied = value.try_into().map_err(|e| {
                format!("error converting supplied value for causal_scrubbing_applied: {e}")
            });
            self
        }
        pub fn hook_activations<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    ::std::vec::Vec<super::SaeFeatureActivationState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.hook_activations = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for hook_activations: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<NeuralAuditAttestationReceipt>
        for super::NeuralAuditAttestationReceipt
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: NeuralAuditAttestationReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                audit_cid: value.audit_cid?,
                causal_scrubbing_applied: value.causal_scrubbing_applied?,
                hook_activations: value.hook_activations?,
            })
        }
    }
    impl ::std::convert::From<super::NeuralAuditAttestationReceipt> for NeuralAuditAttestationReceipt {
        fn from(value: super::NeuralAuditAttestationReceipt) -> Self {
            Self {
                audit_cid: Ok(value.audit_cid),
                causal_scrubbing_applied: Ok(value.causal_scrubbing_applied),
                hook_activations: Ok(value.hook_activations),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct NeuroSymbolicHandoffContract {
        execution_substrate: ::std::result::Result<
            ::std::option::Option<super::ExecutionSubstrate>,
            ::std::string::String,
        >,
        expected_proof_receipt_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        formal_grammar_payload:
            ::std::result::Result<super::FormalGrammarPayload, ::std::string::String>,
        handoff_cid: ::std::result::Result<super::HandoffCid, ::std::string::String>,
        solver_protocol: ::std::result::Result<super::SolverProtocol, ::std::string::String>,
        timeout_ms: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for NeuroSymbolicHandoffContract {
        fn default() -> Self {
            Self {
                execution_substrate: Ok(Default::default()),
                expected_proof_receipt_cid: Ok(Default::default()),
                formal_grammar_payload: Err(
                    "no value supplied for formal_grammar_payload".to_string()
                ),
                handoff_cid: Err("no value supplied for handoff_cid".to_string()),
                solver_protocol: Err("no value supplied for solver_protocol".to_string()),
                timeout_ms: Err("no value supplied for timeout_ms".to_string()),
            }
        }
    }
    impl NeuroSymbolicHandoffContract {
        pub fn execution_substrate<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ExecutionSubstrate>>,
            T::Error: ::std::fmt::Display,
        {
            self.execution_substrate = value.try_into().map_err(|e| {
                format!("error converting supplied value for execution_substrate: {e}")
            });
            self
        }
        pub fn expected_proof_receipt_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.expected_proof_receipt_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for expected_proof_receipt_cid: {e}")
            });
            self
        }
        pub fn formal_grammar_payload<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FormalGrammarPayload>,
            T::Error: ::std::fmt::Display,
        {
            self.formal_grammar_payload = value.try_into().map_err(|e| {
                format!("error converting supplied value for formal_grammar_payload: {e}")
            });
            self
        }
        pub fn handoff_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::HandoffCid>,
            T::Error: ::std::fmt::Display,
        {
            self.handoff_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for handoff_cid: {e}"));
            self
        }
        pub fn solver_protocol<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SolverProtocol>,
            T::Error: ::std::fmt::Display,
        {
            self.solver_protocol = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for solver_protocol: {e}"));
            self
        }
        pub fn timeout_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.timeout_ms = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timeout_ms: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<NeuroSymbolicHandoffContract> for super::NeuroSymbolicHandoffContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: NeuroSymbolicHandoffContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                execution_substrate: value.execution_substrate?,
                expected_proof_receipt_cid: value.expected_proof_receipt_cid?,
                formal_grammar_payload: value.formal_grammar_payload?,
                handoff_cid: value.handoff_cid?,
                solver_protocol: value.solver_protocol?,
                timeout_ms: value.timeout_ms?,
            })
        }
    }
    impl ::std::convert::From<super::NeuroSymbolicHandoffContract> for NeuroSymbolicHandoffContract {
        fn from(value: super::NeuroSymbolicHandoffContract) -> Self {
            Self {
                execution_substrate: Ok(value.execution_substrate),
                expected_proof_receipt_cid: Ok(value.expected_proof_receipt_cid),
                formal_grammar_payload: Ok(value.formal_grammar_payload),
                handoff_cid: Ok(value.handoff_cid),
                solver_protocol: Ok(value.solver_protocol),
                timeout_ms: Ok(value.timeout_ms),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct NeurosymbolicInferenceIntent {
        fidelity_receipt:
            ::std::result::Result<super::TopologicalFidelityReceipt, ::std::string::String>,
        sla: ::std::result::Result<super::EpistemicCompressionSla, ::std::string::String>,
        source_entity:
            ::std::result::Result<super::ContextualizedSourceState, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        uncertainty_profile:
            ::std::result::Result<super::CognitiveUncertaintyProfile, ::std::string::String>,
    }
    impl ::std::default::Default for NeurosymbolicInferenceIntent {
        fn default() -> Self {
            Self {
                fidelity_receipt: Err("no value supplied for fidelity_receipt".to_string()),
                sla: Err("no value supplied for sla".to_string()),
                source_entity: Err("no value supplied for source_entity".to_string()),
                topology_class: Ok(Default::default()),
                uncertainty_profile: Err("no value supplied for uncertainty_profile".to_string()),
            }
        }
    }
    impl NeurosymbolicInferenceIntent {
        pub fn fidelity_receipt<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TopologicalFidelityReceipt>,
            T::Error: ::std::fmt::Display,
        {
            self.fidelity_receipt = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for fidelity_receipt: {e}"));
            self
        }
        pub fn sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EpistemicCompressionSla>,
            T::Error: ::std::fmt::Display,
        {
            self.sla = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for sla: {e}"));
            self
        }
        pub fn source_entity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ContextualizedSourceState>,
            T::Error: ::std::fmt::Display,
        {
            self.source_entity = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_entity: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn uncertainty_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CognitiveUncertaintyProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.uncertainty_profile = value.try_into().map_err(|e| {
                format!("error converting supplied value for uncertainty_profile: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<NeurosymbolicInferenceIntent> for super::NeurosymbolicInferenceIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: NeurosymbolicInferenceIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                fidelity_receipt: value.fidelity_receipt?,
                sla: value.sla?,
                source_entity: value.source_entity?,
                topology_class: value.topology_class?,
                uncertainty_profile: value.uncertainty_profile?,
            })
        }
    }
    impl ::std::convert::From<super::NeurosymbolicInferenceIntent> for NeurosymbolicInferenceIntent {
        fn from(value: super::NeurosymbolicInferenceIntent) -> Self {
            Self {
                fidelity_receipt: Ok(value.fidelity_receipt),
                sla: Ok(value.sla),
                source_entity: Ok(value.source_entity),
                topology_class: Ok(value.topology_class),
                uncertainty_profile: Ok(value.uncertainty_profile),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct NeurosymbolicIngestionTopologyManifest {
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        archivist_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        compiler_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        egress_format: ::std::result::Result<
            ::std::option::Option<super::EgressFormat>,
            ::std::string::String,
        >,
        epistemic_enforcement: ::std::result::Result<
            ::std::option::Option<super::TruthMaintenancePolicy>,
            ::std::string::String,
        >,
        grounding_specialist_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        lifecycle_phase: ::std::result::Result<
            ::std::option::Option<super::LifecyclePhase>,
            ::std::string::String,
        >,
        nodes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            ::std::string::String,
        >,
        observability: ::std::result::Result<
            ::std::option::Option<super::ObservabilityLodPolicy>,
            ::std::string::String,
        >,
        semantic_flow: ::std::result::Result<
            ::std::option::Option<super::SemanticFlowPolicy>,
            ::std::string::String,
        >,
        shared_state_contract: ::std::result::Result<
            ::std::option::Option<super::StateContract>,
            ::std::string::String,
        >,
        source_artifact_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        verification_oracle_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
    }
    impl ::std::default::Default for NeurosymbolicIngestionTopologyManifest {
        fn default() -> Self {
            Self {
                architectural_intent: Ok(Default::default()),
                archivist_node_cid: Err("no value supplied for archivist_node_cid".to_string()),
                compiler_node_cid: Err("no value supplied for compiler_node_cid".to_string()),
                egress_format: Ok(Default::default()),
                epistemic_enforcement: Ok(Default::default()),
                grounding_specialist_cid: Err(
                    "no value supplied for grounding_specialist_cid".to_string()
                ),
                justification: Ok(Default::default()),
                lifecycle_phase: Ok(Default::default()),
                nodes: Ok(Default::default()),
                observability: Ok(Default::default()),
                semantic_flow: Ok(Default::default()),
                shared_state_contract: Ok(Default::default()),
                source_artifact_cid: Err("no value supplied for source_artifact_cid".to_string()),
                topology_class: Ok(Default::default()),
                verification_oracle_cid: Err(
                    "no value supplied for verification_oracle_cid".to_string()
                ),
            }
        }
    }
    impl NeurosymbolicIngestionTopologyManifest {
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn archivist_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.archivist_node_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for archivist_node_cid: {e}")
            });
            self
        }
        pub fn compiler_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.compiler_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for compiler_node_cid: {e}"));
            self
        }
        pub fn egress_format<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EgressFormat>>,
            T::Error: ::std::fmt::Display,
        {
            self.egress_format = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for egress_format: {e}"));
            self
        }
        pub fn epistemic_enforcement<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TruthMaintenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_enforcement = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_enforcement: {e}")
            });
            self
        }
        pub fn grounding_specialist_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.grounding_specialist_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for grounding_specialist_cid: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn lifecycle_phase<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LifecyclePhase>>,
            T::Error: ::std::fmt::Display,
        {
            self.lifecycle_phase = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lifecycle_phase: {e}"));
            self
        }
        pub fn nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for nodes: {e}"));
            self
        }
        pub fn observability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ObservabilityLodPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.observability = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for observability: {e}"));
            self
        }
        pub fn semantic_flow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFlowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_flow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_flow: {e}"));
            self
        }
        pub fn shared_state_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.shared_state_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for shared_state_contract: {e}")
            });
            self
        }
        pub fn source_artifact_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.source_artifact_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for source_artifact_cid: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn verification_oracle_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.verification_oracle_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for verification_oracle_cid: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<NeurosymbolicIngestionTopologyManifest>
        for super::NeurosymbolicIngestionTopologyManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: NeurosymbolicIngestionTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                architectural_intent: value.architectural_intent?,
                archivist_node_cid: value.archivist_node_cid?,
                compiler_node_cid: value.compiler_node_cid?,
                egress_format: value.egress_format?,
                epistemic_enforcement: value.epistemic_enforcement?,
                grounding_specialist_cid: value.grounding_specialist_cid?,
                justification: value.justification?,
                lifecycle_phase: value.lifecycle_phase?,
                nodes: value.nodes?,
                observability: value.observability?,
                semantic_flow: value.semantic_flow?,
                shared_state_contract: value.shared_state_contract?,
                source_artifact_cid: value.source_artifact_cid?,
                topology_class: value.topology_class?,
                verification_oracle_cid: value.verification_oracle_cid?,
            })
        }
    }
    impl ::std::convert::From<super::NeurosymbolicIngestionTopologyManifest>
        for NeurosymbolicIngestionTopologyManifest
    {
        fn from(value: super::NeurosymbolicIngestionTopologyManifest) -> Self {
            Self {
                architectural_intent: Ok(value.architectural_intent),
                archivist_node_cid: Ok(value.archivist_node_cid),
                compiler_node_cid: Ok(value.compiler_node_cid),
                egress_format: Ok(value.egress_format),
                epistemic_enforcement: Ok(value.epistemic_enforcement),
                grounding_specialist_cid: Ok(value.grounding_specialist_cid),
                justification: Ok(value.justification),
                lifecycle_phase: Ok(value.lifecycle_phase),
                nodes: Ok(value.nodes),
                observability: Ok(value.observability),
                semantic_flow: Ok(value.semantic_flow),
                shared_state_contract: Ok(value.shared_state_contract),
                source_artifact_cid: Ok(value.source_artifact_cid),
                topology_class: Ok(value.topology_class),
                verification_oracle_cid: Ok(value.verification_oracle_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct NeurosymbolicVerificationTopologyManifest {
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        critique_schema_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        epistemic_enforcement: ::std::result::Result<
            ::std::option::Option<super::TruthMaintenancePolicy>,
            ::std::string::String,
        >,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        lifecycle_phase: ::std::result::Result<
            ::std::option::Option<super::LifecyclePhase>,
            ::std::string::String,
        >,
        max_revision_loops: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        nodes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            ::std::string::String,
        >,
        observability: ::std::result::Result<
            ::std::option::Option<super::ObservabilityLodPolicy>,
            ::std::string::String,
        >,
        proposer_node_cid: ::std::result::Result<super::ProposerNodeCid, ::std::string::String>,
        semantic_flow: ::std::result::Result<
            ::std::option::Option<super::SemanticFlowPolicy>,
            ::std::string::String,
        >,
        shared_state_contract: ::std::result::Result<
            ::std::option::Option<super::StateContract>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        verifier_node_cid: ::std::result::Result<super::VerifierNodeCid, ::std::string::String>,
    }
    impl ::std::default::Default for NeurosymbolicVerificationTopologyManifest {
        fn default() -> Self {
            Self {
                architectural_intent: Ok(Default::default()),
                critique_schema_cid: Ok(Default::default()),
                epistemic_enforcement: Ok(Default::default()),
                justification: Ok(Default::default()),
                lifecycle_phase: Ok(Default::default()),
                max_revision_loops: Err("no value supplied for max_revision_loops".to_string()),
                nodes: Err("no value supplied for nodes".to_string()),
                observability: Ok(Default::default()),
                proposer_node_cid: Err("no value supplied for proposer_node_cid".to_string()),
                semantic_flow: Ok(Default::default()),
                shared_state_contract: Ok(Default::default()),
                topology_class: Ok(Default::default()),
                verifier_node_cid: Err("no value supplied for verifier_node_cid".to_string()),
            }
        }
    }
    impl NeurosymbolicVerificationTopologyManifest {
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn critique_schema_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.critique_schema_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for critique_schema_cid: {e}")
            });
            self
        }
        pub fn epistemic_enforcement<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TruthMaintenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_enforcement = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_enforcement: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn lifecycle_phase<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LifecyclePhase>>,
            T::Error: ::std::fmt::Display,
        {
            self.lifecycle_phase = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lifecycle_phase: {e}"));
            self
        }
        pub fn max_revision_loops<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_revision_loops = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_revision_loops: {e}")
            });
            self
        }
        pub fn nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for nodes: {e}"));
            self
        }
        pub fn observability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ObservabilityLodPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.observability = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for observability: {e}"));
            self
        }
        pub fn proposer_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProposerNodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.proposer_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proposer_node_cid: {e}"));
            self
        }
        pub fn semantic_flow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFlowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_flow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_flow: {e}"));
            self
        }
        pub fn shared_state_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.shared_state_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for shared_state_contract: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn verifier_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VerifierNodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.verifier_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for verifier_node_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<NeurosymbolicVerificationTopologyManifest>
        for super::NeurosymbolicVerificationTopologyManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: NeurosymbolicVerificationTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                architectural_intent: value.architectural_intent?,
                critique_schema_cid: value.critique_schema_cid?,
                epistemic_enforcement: value.epistemic_enforcement?,
                justification: value.justification?,
                lifecycle_phase: value.lifecycle_phase?,
                max_revision_loops: value.max_revision_loops?,
                nodes: value.nodes?,
                observability: value.observability?,
                proposer_node_cid: value.proposer_node_cid?,
                semantic_flow: value.semantic_flow?,
                shared_state_contract: value.shared_state_contract?,
                topology_class: value.topology_class?,
                verifier_node_cid: value.verifier_node_cid?,
            })
        }
    }
    impl ::std::convert::From<super::NeurosymbolicVerificationTopologyManifest>
        for NeurosymbolicVerificationTopologyManifest
    {
        fn from(value: super::NeurosymbolicVerificationTopologyManifest) -> Self {
            Self {
                architectural_intent: Ok(value.architectural_intent),
                critique_schema_cid: Ok(value.critique_schema_cid),
                epistemic_enforcement: Ok(value.epistemic_enforcement),
                justification: Ok(value.justification),
                lifecycle_phase: Ok(value.lifecycle_phase),
                max_revision_loops: Ok(value.max_revision_loops),
                nodes: Ok(value.nodes),
                observability: Ok(value.observability),
                proposer_node_cid: Ok(value.proposer_node_cid),
                semantic_flow: Ok(value.semantic_flow),
                shared_state_contract: Ok(value.shared_state_contract),
                topology_class: Ok(value.topology_class),
                verifier_node_cid: Ok(value.verifier_node_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ObservabilityLodPolicy {
        active_spatial_subscriptions: ::std::result::Result<
            ::std::vec::Vec<super::VolumetricPartitionState>,
            ::std::string::String,
        >,
        foveated_privacy_epsilon:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        max_rendered_vertices: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        spectral_coarsening_active:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        telemetry_backpressure:
            ::std::result::Result<super::TelemetryBackpressureContract, ::std::string::String>,
    }
    impl ::std::default::Default for ObservabilityLodPolicy {
        fn default() -> Self {
            Self {
                active_spatial_subscriptions: Ok(Default::default()),
                foveated_privacy_epsilon: Ok(Default::default()),
                max_rendered_vertices: Err(
                    "no value supplied for max_rendered_vertices".to_string()
                ),
                spectral_coarsening_active: Ok(Default::default()),
                telemetry_backpressure: Err(
                    "no value supplied for telemetry_backpressure".to_string()
                ),
            }
        }
    }
    impl ObservabilityLodPolicy {
        pub fn active_spatial_subscriptions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::VolumetricPartitionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.active_spatial_subscriptions = value.try_into().map_err(|e| {
                format!("error converting supplied value for active_spatial_subscriptions: {e}")
            });
            self
        }
        pub fn foveated_privacy_epsilon<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.foveated_privacy_epsilon = value.try_into().map_err(|e| {
                format!("error converting supplied value for foveated_privacy_epsilon: {e}")
            });
            self
        }
        pub fn max_rendered_vertices<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_rendered_vertices = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_rendered_vertices: {e}")
            });
            self
        }
        pub fn spectral_coarsening_active<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.spectral_coarsening_active = value.try_into().map_err(|e| {
                format!("error converting supplied value for spectral_coarsening_active: {e}")
            });
            self
        }
        pub fn telemetry_backpressure<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TelemetryBackpressureContract>,
            T::Error: ::std::fmt::Display,
        {
            self.telemetry_backpressure = value.try_into().map_err(|e| {
                format!("error converting supplied value for telemetry_backpressure: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<ObservabilityLodPolicy> for super::ObservabilityLodPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ObservabilityLodPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                active_spatial_subscriptions: value.active_spatial_subscriptions?,
                foveated_privacy_epsilon: value.foveated_privacy_epsilon?,
                max_rendered_vertices: value.max_rendered_vertices?,
                spectral_coarsening_active: value.spectral_coarsening_active?,
                telemetry_backpressure: value.telemetry_backpressure?,
            })
        }
    }
    impl ::std::convert::From<super::ObservabilityLodPolicy> for ObservabilityLodPolicy {
        fn from(value: super::ObservabilityLodPolicy) -> Self {
            Self {
                active_spatial_subscriptions: Ok(value.active_spatial_subscriptions),
                foveated_privacy_epsilon: Ok(value.foveated_privacy_epsilon),
                max_rendered_vertices: Ok(value.max_rendered_vertices),
                spectral_coarsening_active: Ok(value.spectral_coarsening_active),
                telemetry_backpressure: Ok(value.telemetry_backpressure),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ObservationEvent {
        continuous_stream: ::std::result::Result<
            ::std::option::Option<super::ContinuousObservationState>,
            ::std::string::String,
        >,
        disfluency_rules: ::std::result::Result<
            ::std::option::Option<super::StreamingDisfluencyContract>,
            ::std::string::String,
        >,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        hardware_attestation: ::std::result::Result<
            ::std::option::Option<super::HardwareEnclaveReceipt>,
            ::std::string::String,
        >,
        neural_audit: ::std::result::Result<
            ::std::option::Option<super::NeuralAuditAttestationReceipt>,
            ::std::string::String,
        >,
        payload: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        sensory_trigger: ::std::result::Result<
            ::std::option::Option<super::EmbodiedSensoryVectorProfile>,
            ::std::string::String,
        >,
        source_node_cid: ::std::result::Result<
            ::std::option::Option<super::NodeCidState>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        toolchain_snapshot: ::std::result::Result<
            ::std::option::Option<super::AnyToolchainState>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        triggering_invocation_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        zk_proof: ::std::result::Result<
            ::std::option::Option<super::ZeroKnowledgeReceipt>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for ObservationEvent {
        fn default() -> Self {
            Self {
                continuous_stream: Ok(Default::default()),
                disfluency_rules: Ok(Default::default()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                hardware_attestation: Ok(Default::default()),
                neural_audit: Ok(Default::default()),
                payload: Err("no value supplied for payload".to_string()),
                prior_event_hash: Ok(Default::default()),
                sensory_trigger: Ok(Default::default()),
                source_node_cid: Ok(Default::default()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                toolchain_snapshot: Ok(Default::default()),
                topology_class: Ok(Default::default()),
                triggering_invocation_cid: Ok(Default::default()),
                zk_proof: Ok(Default::default()),
            }
        }
    }
    impl ObservationEvent {
        pub fn continuous_stream<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ContinuousObservationState>>,
            T::Error: ::std::fmt::Display,
        {
            self.continuous_stream = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for continuous_stream: {e}"));
            self
        }
        pub fn disfluency_rules<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StreamingDisfluencyContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.disfluency_rules = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for disfluency_rules: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn hardware_attestation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HardwareEnclaveReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.hardware_attestation = value.try_into().map_err(|e| {
                format!("error converting supplied value for hardware_attestation: {e}")
            });
            self
        }
        pub fn neural_audit<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NeuralAuditAttestationReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.neural_audit = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for neural_audit: {e}"));
            self
        }
        pub fn payload<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.payload = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for payload: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn sensory_trigger<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EmbodiedSensoryVectorProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.sensory_trigger = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for sensory_trigger: {e}"));
            self
        }
        pub fn source_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.source_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_node_cid: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn toolchain_snapshot<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AnyToolchainState>>,
            T::Error: ::std::fmt::Display,
        {
            self.toolchain_snapshot = value.try_into().map_err(|e| {
                format!("error converting supplied value for toolchain_snapshot: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn triggering_invocation_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.triggering_invocation_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for triggering_invocation_cid: {e}")
            });
            self
        }
        pub fn zk_proof<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ZeroKnowledgeReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.zk_proof = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for zk_proof: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ObservationEvent> for super::ObservationEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ObservationEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                continuous_stream: value.continuous_stream?,
                disfluency_rules: value.disfluency_rules?,
                event_cid: value.event_cid?,
                hardware_attestation: value.hardware_attestation?,
                neural_audit: value.neural_audit?,
                payload: value.payload?,
                prior_event_hash: value.prior_event_hash?,
                sensory_trigger: value.sensory_trigger?,
                source_node_cid: value.source_node_cid?,
                timestamp: value.timestamp?,
                toolchain_snapshot: value.toolchain_snapshot?,
                topology_class: value.topology_class?,
                triggering_invocation_cid: value.triggering_invocation_cid?,
                zk_proof: value.zk_proof?,
            })
        }
    }
    impl ::std::convert::From<super::ObservationEvent> for ObservationEvent {
        fn from(value: super::ObservationEvent) -> Self {
            Self {
                continuous_stream: Ok(value.continuous_stream),
                disfluency_rules: Ok(value.disfluency_rules),
                event_cid: Ok(value.event_cid),
                hardware_attestation: Ok(value.hardware_attestation),
                neural_audit: Ok(value.neural_audit),
                payload: Ok(value.payload),
                prior_event_hash: Ok(value.prior_event_hash),
                sensory_trigger: Ok(value.sensory_trigger),
                source_node_cid: Ok(value.source_node_cid),
                timestamp: Ok(value.timestamp),
                toolchain_snapshot: Ok(value.toolchain_snapshot),
                topology_class: Ok(value.topology_class),
                triggering_invocation_cid: Ok(value.triggering_invocation_cid),
                zk_proof: Ok(value.zk_proof),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct OntologicalAlignmentPolicy {
        fallback_state_contract: ::std::result::Result<
            ::std::option::Option<super::StateContract>,
            ::std::string::String,
        >,
        min_cosine_similarity: ::std::result::Result<f64, ::std::string::String>,
        require_isometry_proof: ::std::result::Result<bool, ::std::string::String>,
    }
    impl ::std::default::Default for OntologicalAlignmentPolicy {
        fn default() -> Self {
            Self {
                fallback_state_contract: Ok(Default::default()),
                min_cosine_similarity: Err(
                    "no value supplied for min_cosine_similarity".to_string()
                ),
                require_isometry_proof: Err(
                    "no value supplied for require_isometry_proof".to_string()
                ),
            }
        }
    }
    impl OntologicalAlignmentPolicy {
        pub fn fallback_state_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.fallback_state_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for fallback_state_contract: {e}")
            });
            self
        }
        pub fn min_cosine_similarity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.min_cosine_similarity = value.try_into().map_err(|e| {
                format!("error converting supplied value for min_cosine_similarity: {e}")
            });
            self
        }
        pub fn require_isometry_proof<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.require_isometry_proof = value.try_into().map_err(|e| {
                format!("error converting supplied value for require_isometry_proof: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<OntologicalAlignmentPolicy> for super::OntologicalAlignmentPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: OntologicalAlignmentPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                fallback_state_contract: value.fallback_state_contract?,
                min_cosine_similarity: value.min_cosine_similarity?,
                require_isometry_proof: value.require_isometry_proof?,
            })
        }
    }
    impl ::std::convert::From<super::OntologicalAlignmentPolicy> for OntologicalAlignmentPolicy {
        fn from(value: super::OntologicalAlignmentPolicy) -> Self {
            Self {
                fallback_state_contract: Ok(value.fallback_state_contract),
                min_cosine_similarity: Ok(value.min_cosine_similarity),
                require_isometry_proof: Ok(value.require_isometry_proof),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct OntologicalCrosswalkIntent {
        minimum_isometry_threshold: ::std::result::Result<f64, ::std::string::String>,
        source_strings:
            ::std::result::Result<::std::vec::Vec<super::SourceStringsItem>, ::std::string::String>,
        target_graph_cid: ::std::result::Result<super::TargetGraphCid, ::std::string::String>,
        target_ontology_registries: ::std::result::Result<
            ::std::vec::Vec<super::TargetOntologyRegistriesItem>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for OntologicalCrosswalkIntent {
        fn default() -> Self {
            Self {
                minimum_isometry_threshold: Err(
                    "no value supplied for minimum_isometry_threshold".to_string()
                ),
                source_strings: Err("no value supplied for source_strings".to_string()),
                target_graph_cid: Err("no value supplied for target_graph_cid".to_string()),
                target_ontology_registries: Err(
                    "no value supplied for target_ontology_registries".to_string()
                ),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl OntologicalCrosswalkIntent {
        pub fn minimum_isometry_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.minimum_isometry_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for minimum_isometry_threshold: {e}")
            });
            self
        }
        pub fn source_strings<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::SourceStringsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.source_strings = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_strings: {e}"));
            self
        }
        pub fn target_graph_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetGraphCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_graph_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_graph_cid: {e}"));
            self
        }
        pub fn target_ontology_registries<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::TargetOntologyRegistriesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.target_ontology_registries = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_ontology_registries: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<OntologicalCrosswalkIntent> for super::OntologicalCrosswalkIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: OntologicalCrosswalkIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                minimum_isometry_threshold: value.minimum_isometry_threshold?,
                source_strings: value.source_strings?,
                target_graph_cid: value.target_graph_cid?,
                target_ontology_registries: value.target_ontology_registries?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::OntologicalCrosswalkIntent> for OntologicalCrosswalkIntent {
        fn from(value: super::OntologicalCrosswalkIntent) -> Self {
            Self {
                minimum_isometry_threshold: Ok(value.minimum_isometry_threshold),
                source_strings: Ok(value.source_strings),
                target_graph_cid: Ok(value.target_graph_cid),
                target_ontology_registries: Ok(value.target_ontology_registries),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct OntologicalNormalizationIntent {
        source_artifact_cid: ::std::result::Result<super::SourceArtifactCid, ::std::string::String>,
        target_ontology_urn: ::std::result::Result<super::TargetOntologyUrn, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for OntologicalNormalizationIntent {
        fn default() -> Self {
            Self {
                source_artifact_cid: Err("no value supplied for source_artifact_cid".to_string()),
                target_ontology_urn: Err("no value supplied for target_ontology_urn".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl OntologicalNormalizationIntent {
        pub fn source_artifact_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceArtifactCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_artifact_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for source_artifact_cid: {e}")
            });
            self
        }
        pub fn target_ontology_urn<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetOntologyUrn>,
            T::Error: ::std::fmt::Display,
        {
            self.target_ontology_urn = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_ontology_urn: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<OntologicalNormalizationIntent>
        for super::OntologicalNormalizationIntent
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: OntologicalNormalizationIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                source_artifact_cid: value.source_artifact_cid?,
                target_ontology_urn: value.target_ontology_urn?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::OntologicalNormalizationIntent>
        for OntologicalNormalizationIntent
    {
        fn from(value: super::OntologicalNormalizationIntent) -> Self {
            Self {
                source_artifact_cid: Ok(value.source_artifact_cid),
                target_ontology_urn: Ok(value.target_ontology_urn),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct OntologicalReificationReceipt {
        algorithmic_mechanism:
            ::std::result::Result<super::TransformationMechanismProfile, ::std::string::String>,
        belief_vector:
            ::std::result::Result<super::DempsterShaferBeliefVector, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        is_latent_inference:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        source_data_hash: ::std::result::Result<super::SourceDataHash, ::std::string::String>,
        target_namespace: ::std::result::Result<super::TargetNamespace, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for OntologicalReificationReceipt {
        fn default() -> Self {
            Self {
                algorithmic_mechanism: Err(
                    "no value supplied for algorithmic_mechanism".to_string()
                ),
                belief_vector: Err("no value supplied for belief_vector".to_string()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                is_latent_inference: Ok(Default::default()),
                prior_event_hash: Ok(Default::default()),
                source_data_hash: Err("no value supplied for source_data_hash".to_string()),
                target_namespace: Err("no value supplied for target_namespace".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl OntologicalReificationReceipt {
        pub fn algorithmic_mechanism<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TransformationMechanismProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.algorithmic_mechanism = value.try_into().map_err(|e| {
                format!("error converting supplied value for algorithmic_mechanism: {e}")
            });
            self
        }
        pub fn belief_vector<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DempsterShaferBeliefVector>,
            T::Error: ::std::fmt::Display,
        {
            self.belief_vector = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for belief_vector: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn is_latent_inference<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.is_latent_inference = value.try_into().map_err(|e| {
                format!("error converting supplied value for is_latent_inference: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn source_data_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceDataHash>,
            T::Error: ::std::fmt::Display,
        {
            self.source_data_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_data_hash: {e}"));
            self
        }
        pub fn target_namespace<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetNamespace>,
            T::Error: ::std::fmt::Display,
        {
            self.target_namespace = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_namespace: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<OntologicalReificationReceipt>
        for super::OntologicalReificationReceipt
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: OntologicalReificationReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                algorithmic_mechanism: value.algorithmic_mechanism?,
                belief_vector: value.belief_vector?,
                event_cid: value.event_cid?,
                is_latent_inference: value.is_latent_inference?,
                prior_event_hash: value.prior_event_hash?,
                source_data_hash: value.source_data_hash?,
                target_namespace: value.target_namespace?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::OntologicalReificationReceipt> for OntologicalReificationReceipt {
        fn from(value: super::OntologicalReificationReceipt) -> Self {
            Self {
                algorithmic_mechanism: Ok(value.algorithmic_mechanism),
                belief_vector: Ok(value.belief_vector),
                event_cid: Ok(value.event_cid),
                is_latent_inference: Ok(value.is_latent_inference),
                prior_event_hash: Ok(value.prior_event_hash),
                source_data_hash: Ok(value.source_data_hash),
                target_namespace: Ok(value.target_namespace),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct OntologicalSurfaceProjectionManifest {
        action_spaces: ::std::result::Result<
            ::std::vec::Vec<super::CognitiveActionSpaceManifest>,
            ::std::string::String,
        >,
        available_procedural_manifolds: ::std::result::Result<
            ::std::vec::Vec<super::ProceduralMetadataManifest>,
            ::std::string::String,
        >,
        projection_cid: ::std::result::Result<super::ProjectionCid, ::std::string::String>,
        supported_personas:
            ::std::result::Result<::std::vec::Vec<super::ProfileCidState>, ::std::string::String>,
    }
    impl ::std::default::Default for OntologicalSurfaceProjectionManifest {
        fn default() -> Self {
            Self {
                action_spaces: Ok(Default::default()),
                available_procedural_manifolds: Ok(Default::default()),
                projection_cid: Err("no value supplied for projection_cid".to_string()),
                supported_personas: Ok(Default::default()),
            }
        }
    }
    impl OntologicalSurfaceProjectionManifest {
        pub fn action_spaces<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::CognitiveActionSpaceManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.action_spaces = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for action_spaces: {e}"));
            self
        }
        pub fn available_procedural_manifolds<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ProceduralMetadataManifest>>,
            T::Error: ::std::fmt::Display,
        {
            self.available_procedural_manifolds = value.try_into().map_err(|e| {
                format!("error converting supplied value for available_procedural_manifolds: {e}")
            });
            self
        }
        pub fn projection_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProjectionCid>,
            T::Error: ::std::fmt::Display,
        {
            self.projection_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for projection_cid: {e}"));
            self
        }
        pub fn supported_personas<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ProfileCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.supported_personas = value.try_into().map_err(|e| {
                format!("error converting supplied value for supported_personas: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<OntologicalSurfaceProjectionManifest>
        for super::OntologicalSurfaceProjectionManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: OntologicalSurfaceProjectionManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                action_spaces: value.action_spaces?,
                available_procedural_manifolds: value.available_procedural_manifolds?,
                projection_cid: value.projection_cid?,
                supported_personas: value.supported_personas?,
            })
        }
    }
    impl ::std::convert::From<super::OntologicalSurfaceProjectionManifest>
        for OntologicalSurfaceProjectionManifest
    {
        fn from(value: super::OntologicalSurfaceProjectionManifest) -> Self {
            Self {
                action_spaces: Ok(value.action_spaces),
                available_procedural_manifolds: Ok(value.available_procedural_manifolds),
                projection_cid: Ok(value.projection_cid),
                supported_personas: Ok(value.supported_personas),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct OntologyDiscoveryIntent {
        expected_response_schema: ::std::result::Result<
            ::std::option::Option<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            ::std::string::String,
        >,
        id: ::std::result::Result<::std::option::Option<super::Id>, ::std::string::String>,
        jsonrpc: ::std::result::Result<::std::string::String, ::std::string::String>,
        method: ::std::result::Result<super::Method, ::std::string::String>,
        params: ::std::result::Result<
            ::std::option::Option<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            ::std::string::String,
        >,
        query_concept_cid: ::std::result::Result<super::QueryConceptCid, ::std::string::String>,
        target_registry_uri: ::std::result::Result<::std::string::String, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for OntologyDiscoveryIntent {
        fn default() -> Self {
            Self {
                expected_response_schema: Ok(Default::default()),
                id: Ok(Default::default()),
                jsonrpc: Err("no value supplied for jsonrpc".to_string()),
                method: Err("no value supplied for method".to_string()),
                params: Ok(Default::default()),
                query_concept_cid: Err("no value supplied for query_concept_cid".to_string()),
                target_registry_uri: Err("no value supplied for target_registry_uri".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl OntologyDiscoveryIntent {
        pub fn expected_response_schema<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.expected_response_schema = value.try_into().map_err(|e| {
                format!("error converting supplied value for expected_response_schema: {e}")
            });
            self
        }
        pub fn id<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::Id>>,
            T::Error: ::std::fmt::Display,
        {
            self.id = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for id: {e}"));
            self
        }
        pub fn jsonrpc<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.jsonrpc = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for jsonrpc: {e}"));
            self
        }
        pub fn method<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Method>,
            T::Error: ::std::fmt::Display,
        {
            self.method = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for method: {e}"));
            self
        }
        pub fn params<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.params = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for params: {e}"));
            self
        }
        pub fn query_concept_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::QueryConceptCid>,
            T::Error: ::std::fmt::Display,
        {
            self.query_concept_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for query_concept_cid: {e}"));
            self
        }
        pub fn target_registry_uri<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.target_registry_uri = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_registry_uri: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<OntologyDiscoveryIntent> for super::OntologyDiscoveryIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: OntologyDiscoveryIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                expected_response_schema: value.expected_response_schema?,
                id: value.id?,
                jsonrpc: value.jsonrpc?,
                method: value.method?,
                params: value.params?,
                query_concept_cid: value.query_concept_cid?,
                target_registry_uri: value.target_registry_uri?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::OntologyDiscoveryIntent> for OntologyDiscoveryIntent {
        fn from(value: super::OntologyDiscoveryIntent) -> Self {
            Self {
                expected_response_schema: Ok(value.expected_response_schema),
                id: Ok(value.id),
                jsonrpc: Ok(value.jsonrpc),
                method: Ok(value.method),
                params: Ok(value.params),
                query_concept_cid: Ok(value.query_concept_cid),
                target_registry_uri: Ok(value.target_registry_uri),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct OpticalMappingContract {
        lens_source_pointer: ::std::result::Result<super::LensSourcePointer, ::std::string::String>,
        prism_target_pointer:
            ::std::result::Result<super::PrismTargetPointer, ::std::string::String>,
        strict_isomorphism:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
    }
    impl ::std::default::Default for OpticalMappingContract {
        fn default() -> Self {
            Self {
                lens_source_pointer: Err("no value supplied for lens_source_pointer".to_string()),
                prism_target_pointer: Err("no value supplied for prism_target_pointer".to_string()),
                strict_isomorphism: Ok(Default::default()),
            }
        }
    }
    impl OpticalMappingContract {
        pub fn lens_source_pointer<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::LensSourcePointer>,
            T::Error: ::std::fmt::Display,
        {
            self.lens_source_pointer = value.try_into().map_err(|e| {
                format!("error converting supplied value for lens_source_pointer: {e}")
            });
            self
        }
        pub fn prism_target_pointer<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PrismTargetPointer>,
            T::Error: ::std::fmt::Display,
        {
            self.prism_target_pointer = value.try_into().map_err(|e| {
                format!("error converting supplied value for prism_target_pointer: {e}")
            });
            self
        }
        pub fn strict_isomorphism<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.strict_isomorphism = value.try_into().map_err(|e| {
                format!("error converting supplied value for strict_isomorphism: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<OpticalMappingContract> for super::OpticalMappingContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: OpticalMappingContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                lens_source_pointer: value.lens_source_pointer?,
                prism_target_pointer: value.prism_target_pointer?,
                strict_isomorphism: value.strict_isomorphism?,
            })
        }
    }
    impl ::std::convert::From<super::OpticalMappingContract> for OpticalMappingContract {
        fn from(value: super::OpticalMappingContract) -> Self {
            Self {
                lens_source_pointer: Ok(value.lens_source_pointer),
                prism_target_pointer: Ok(value.prism_target_pointer),
                strict_isomorphism: Ok(value.strict_isomorphism),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct OpticalParsingSla {
        bitmap_dpi_resolution:
            ::std::result::Result<::std::option::Option<i64>, ::std::string::String>,
        force_ocr: ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        table_structure_recognition:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
    }
    impl ::std::default::Default for OpticalParsingSla {
        fn default() -> Self {
            Self {
                bitmap_dpi_resolution: Ok(Default::default()),
                force_ocr: Ok(Default::default()),
                table_structure_recognition: Ok(Default::default()),
            }
        }
    }
    impl OpticalParsingSla {
        pub fn bitmap_dpi_resolution<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<i64>>,
            T::Error: ::std::fmt::Display,
        {
            self.bitmap_dpi_resolution = value.try_into().map_err(|e| {
                format!("error converting supplied value for bitmap_dpi_resolution: {e}")
            });
            self
        }
        pub fn force_ocr<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.force_ocr = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for force_ocr: {e}"));
            self
        }
        pub fn table_structure_recognition<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.table_structure_recognition = value.try_into().map_err(|e| {
                format!("error converting supplied value for table_structure_recognition: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<OpticalParsingSla> for super::OpticalParsingSla {
        type Error = super::error::ConversionError;
        fn try_from(
            value: OpticalParsingSla,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                bitmap_dpi_resolution: value.bitmap_dpi_resolution?,
                force_ocr: value.force_ocr?,
                table_structure_recognition: value.table_structure_recognition?,
            })
        }
    }
    impl ::std::convert::From<super::OpticalParsingSla> for OpticalParsingSla {
        fn from(value: super::OpticalParsingSla) -> Self {
            Self {
                bitmap_dpi_resolution: Ok(value.bitmap_dpi_resolution),
                force_ocr: Ok(value.force_ocr),
                table_structure_recognition: Ok(value.table_structure_recognition),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct OracleExecutionReceipt {
        execution_hash: ::std::result::Result<super::ExecutionHash, ::std::string::String>,
        human_attestation_signature: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        solver_urn: ::std::result::Result<super::SolverUrn, ::std::string::String>,
        tokens_burned: ::std::result::Result<i64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for OracleExecutionReceipt {
        fn default() -> Self {
            Self {
                execution_hash: Err("no value supplied for execution_hash".to_string()),
                human_attestation_signature: Ok(Default::default()),
                solver_urn: Err("no value supplied for solver_urn".to_string()),
                tokens_burned: Err("no value supplied for tokens_burned".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl OracleExecutionReceipt {
        pub fn execution_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ExecutionHash>,
            T::Error: ::std::fmt::Display,
        {
            self.execution_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for execution_hash: {e}"));
            self
        }
        pub fn human_attestation_signature<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.human_attestation_signature = value.try_into().map_err(|e| {
                format!("error converting supplied value for human_attestation_signature: {e}")
            });
            self
        }
        pub fn solver_urn<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SolverUrn>,
            T::Error: ::std::fmt::Display,
        {
            self.solver_urn = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for solver_urn: {e}"));
            self
        }
        pub fn tokens_burned<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<i64>,
            T::Error: ::std::fmt::Display,
        {
            self.tokens_burned = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for tokens_burned: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<OracleExecutionReceipt> for super::OracleExecutionReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: OracleExecutionReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                execution_hash: value.execution_hash?,
                human_attestation_signature: value.human_attestation_signature?,
                solver_urn: value.solver_urn?,
                tokens_burned: value.tokens_burned?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::OracleExecutionReceipt> for OracleExecutionReceipt {
        fn from(value: super::OracleExecutionReceipt) -> Self {
            Self {
                execution_hash: Ok(value.execution_hash),
                human_attestation_signature: Ok(value.human_attestation_signature),
                solver_urn: Ok(value.solver_urn),
                tokens_burned: Ok(value.tokens_burned),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct OutputMappingContract {
        child_key: ::std::result::Result<super::ChildKey, ::std::string::String>,
        parent_key: ::std::result::Result<super::ParentKey, ::std::string::String>,
    }
    impl ::std::default::Default for OutputMappingContract {
        fn default() -> Self {
            Self {
                child_key: Err("no value supplied for child_key".to_string()),
                parent_key: Err("no value supplied for parent_key".to_string()),
            }
        }
    }
    impl OutputMappingContract {
        pub fn child_key<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ChildKey>,
            T::Error: ::std::fmt::Display,
        {
            self.child_key = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for child_key: {e}"));
            self
        }
        pub fn parent_key<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ParentKey>,
            T::Error: ::std::fmt::Display,
        {
            self.parent_key = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for parent_key: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<OutputMappingContract> for super::OutputMappingContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: OutputMappingContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                child_key: value.child_key?,
                parent_key: value.parent_key?,
            })
        }
    }
    impl ::std::convert::From<super::OutputMappingContract> for OutputMappingContract {
        fn from(value: super::OutputMappingContract) -> Self {
            Self {
                child_key: Ok(value.child_key),
                parent_key: Ok(value.parent_key),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct OverrideIntent {
        authorized_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        justification: ::std::result::Result<super::Justification, ::std::string::String>,
        override_action: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        target_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for OverrideIntent {
        fn default() -> Self {
            Self {
                authorized_node_cid: Err("no value supplied for authorized_node_cid".to_string()),
                justification: Err("no value supplied for justification".to_string()),
                override_action: Err("no value supplied for override_action".to_string()),
                target_node_cid: Err("no value supplied for target_node_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl OverrideIntent {
        pub fn authorized_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.authorized_node_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for authorized_node_cid: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Justification>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn override_action<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.override_action = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for override_action: {e}"));
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<OverrideIntent> for super::OverrideIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: OverrideIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                authorized_node_cid: value.authorized_node_cid?,
                justification: value.justification?,
                override_action: value.override_action?,
                target_node_cid: value.target_node_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::OverrideIntent> for OverrideIntent {
        fn from(value: super::OverrideIntent) -> Self {
            Self {
                authorized_node_cid: Ok(value.authorized_node_cid),
                justification: Ok(value.justification),
                override_action: Ok(value.override_action),
                target_node_cid: Ok(value.target_node_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct PeftAdapterContract {
        adapter_cid: ::std::result::Result<super::AdapterCid, ::std::string::String>,
        adapter_rank: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        base_model_hash: ::std::result::Result<super::BaseModelHash, ::std::string::String>,
        eviction_ttl_seconds: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
        safetensors_hash: ::std::result::Result<super::SafetensorsHash, ::std::string::String>,
        target_modules:
            ::std::result::Result<::std::vec::Vec<super::TargetModulesItem>, ::std::string::String>,
    }
    impl ::std::default::Default for PeftAdapterContract {
        fn default() -> Self {
            Self {
                adapter_cid: Err("no value supplied for adapter_cid".to_string()),
                adapter_rank: Err("no value supplied for adapter_rank".to_string()),
                base_model_hash: Err("no value supplied for base_model_hash".to_string()),
                eviction_ttl_seconds: Ok(Default::default()),
                safetensors_hash: Err("no value supplied for safetensors_hash".to_string()),
                target_modules: Err("no value supplied for target_modules".to_string()),
            }
        }
    }
    impl PeftAdapterContract {
        pub fn adapter_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AdapterCid>,
            T::Error: ::std::fmt::Display,
        {
            self.adapter_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for adapter_cid: {e}"));
            self
        }
        pub fn adapter_rank<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.adapter_rank = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for adapter_rank: {e}"));
            self
        }
        pub fn base_model_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::BaseModelHash>,
            T::Error: ::std::fmt::Display,
        {
            self.base_model_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for base_model_hash: {e}"));
            self
        }
        pub fn eviction_ttl_seconds<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.eviction_ttl_seconds = value.try_into().map_err(|e| {
                format!("error converting supplied value for eviction_ttl_seconds: {e}")
            });
            self
        }
        pub fn safetensors_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SafetensorsHash>,
            T::Error: ::std::fmt::Display,
        {
            self.safetensors_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for safetensors_hash: {e}"));
            self
        }
        pub fn target_modules<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::TargetModulesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.target_modules = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_modules: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<PeftAdapterContract> for super::PeftAdapterContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: PeftAdapterContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                adapter_cid: value.adapter_cid?,
                adapter_rank: value.adapter_rank?,
                base_model_hash: value.base_model_hash?,
                eviction_ttl_seconds: value.eviction_ttl_seconds?,
                safetensors_hash: value.safetensors_hash?,
                target_modules: value.target_modules?,
            })
        }
    }
    impl ::std::convert::From<super::PeftAdapterContract> for PeftAdapterContract {
        fn from(value: super::PeftAdapterContract) -> Self {
            Self {
                adapter_cid: Ok(value.adapter_cid),
                adapter_rank: Ok(value.adapter_rank),
                base_model_hash: Ok(value.base_model_hash),
                eviction_ttl_seconds: Ok(value.eviction_ttl_seconds),
                safetensors_hash: Ok(value.safetensors_hash),
                target_modules: Ok(value.target_modules),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct PermissionBoundaryPolicy {
        allowed_domains: ::std::result::Result<
            ::std::option::Option<
                ::std::vec::Vec<super::PermissionBoundaryPolicyAllowedDomainsItem>,
            >,
            ::std::string::String,
        >,
        auth_requirements: ::std::result::Result<
            ::std::option::Option<
                ::std::vec::Vec<super::PermissionBoundaryPolicyAuthRequirementsItem>,
            >,
            ::std::string::String,
        >,
        file_system_mutation_forbidden: ::std::result::Result<bool, ::std::string::String>,
        network_access: ::std::result::Result<bool, ::std::string::String>,
    }
    impl ::std::default::Default for PermissionBoundaryPolicy {
        fn default() -> Self {
            Self {
                allowed_domains: Ok(Default::default()),
                auth_requirements: Ok(Default::default()),
                file_system_mutation_forbidden: Err(
                    "no value supplied for file_system_mutation_forbidden".to_string(),
                ),
                network_access: Err("no value supplied for network_access".to_string()),
            }
        }
    }
    impl PermissionBoundaryPolicy {
        pub fn allowed_domains<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::vec::Vec<super::PermissionBoundaryPolicyAllowedDomainsItem>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.allowed_domains = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for allowed_domains: {e}"));
            self
        }
        pub fn auth_requirements<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::vec::Vec<super::PermissionBoundaryPolicyAuthRequirementsItem>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.auth_requirements = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for auth_requirements: {e}"));
            self
        }
        pub fn file_system_mutation_forbidden<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.file_system_mutation_forbidden = value.try_into().map_err(|e| {
                format!("error converting supplied value for file_system_mutation_forbidden: {e}")
            });
            self
        }
        pub fn network_access<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.network_access = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for network_access: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<PermissionBoundaryPolicy> for super::PermissionBoundaryPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: PermissionBoundaryPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                allowed_domains: value.allowed_domains?,
                auth_requirements: value.auth_requirements?,
                file_system_mutation_forbidden: value.file_system_mutation_forbidden?,
                network_access: value.network_access?,
            })
        }
    }
    impl ::std::convert::From<super::PermissionBoundaryPolicy> for PermissionBoundaryPolicy {
        fn from(value: super::PermissionBoundaryPolicy) -> Self {
            Self {
                allowed_domains: Ok(value.allowed_domains),
                auth_requirements: Ok(value.auth_requirements),
                file_system_mutation_forbidden: Ok(value.file_system_mutation_forbidden),
                network_access: Ok(value.network_access),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct PersistenceCommitReceipt {
        committed_temporal_crdt_cid:
            ::std::result::Result<super::CommittedTemporalCrdtCid, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        lakehouse_snapshot_cid:
            ::std::result::Result<super::LakehouseSnapshotCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        target_table_uri: ::std::result::Result<super::TargetTableUri, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for PersistenceCommitReceipt {
        fn default() -> Self {
            Self {
                committed_temporal_crdt_cid: Err(
                    "no value supplied for committed_temporal_crdt_cid".to_string(),
                ),
                event_cid: Err("no value supplied for event_cid".to_string()),
                lakehouse_snapshot_cid: Err(
                    "no value supplied for lakehouse_snapshot_cid".to_string()
                ),
                prior_event_hash: Ok(Default::default()),
                target_table_uri: Err("no value supplied for target_table_uri".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl PersistenceCommitReceipt {
        pub fn committed_temporal_crdt_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CommittedTemporalCrdtCid>,
            T::Error: ::std::fmt::Display,
        {
            self.committed_temporal_crdt_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for committed_temporal_crdt_cid: {e}")
            });
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn lakehouse_snapshot_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::LakehouseSnapshotCid>,
            T::Error: ::std::fmt::Display,
        {
            self.lakehouse_snapshot_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for lakehouse_snapshot_cid: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn target_table_uri<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetTableUri>,
            T::Error: ::std::fmt::Display,
        {
            self.target_table_uri = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_table_uri: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<PersistenceCommitReceipt> for super::PersistenceCommitReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: PersistenceCommitReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                committed_temporal_crdt_cid: value.committed_temporal_crdt_cid?,
                event_cid: value.event_cid?,
                lakehouse_snapshot_cid: value.lakehouse_snapshot_cid?,
                prior_event_hash: value.prior_event_hash?,
                target_table_uri: value.target_table_uri?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::PersistenceCommitReceipt> for PersistenceCommitReceipt {
        fn from(value: super::PersistenceCommitReceipt) -> Self {
            Self {
                committed_temporal_crdt_cid: Ok(value.committed_temporal_crdt_cid),
                event_cid: Ok(value.event_cid),
                lakehouse_snapshot_cid: Ok(value.lakehouse_snapshot_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                target_table_uri: Ok(value.target_table_uri),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct PostCoordinatedSemanticState {
        alignment_metric_used:
            ::std::result::Result<super::ManifoldAlignmentMetricProfile, ::std::string::String>,
        base_concept_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        concept_cid: ::std::result::Result<super::ConceptCid, ::std::string::String>,
        contextual_modifiers: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        isometry_score: ::std::result::Result<f64, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for PostCoordinatedSemanticState {
        fn default() -> Self {
            Self {
                alignment_metric_used: Err(
                    "no value supplied for alignment_metric_used".to_string()
                ),
                base_concept_cid: Err("no value supplied for base_concept_cid".to_string()),
                concept_cid: Err("no value supplied for concept_cid".to_string()),
                contextual_modifiers: Ok(Default::default()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                isometry_score: Err("no value supplied for isometry_score".to_string()),
                prior_event_hash: Ok(Default::default()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl PostCoordinatedSemanticState {
        pub fn alignment_metric_used<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ManifoldAlignmentMetricProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.alignment_metric_used = value.try_into().map_err(|e| {
                format!("error converting supplied value for alignment_metric_used: {e}")
            });
            self
        }
        pub fn base_concept_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.base_concept_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for base_concept_cid: {e}"));
            self
        }
        pub fn concept_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ConceptCid>,
            T::Error: ::std::fmt::Display,
        {
            self.concept_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for concept_cid: {e}"));
            self
        }
        pub fn contextual_modifiers<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.contextual_modifiers = value.try_into().map_err(|e| {
                format!("error converting supplied value for contextual_modifiers: {e}")
            });
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn isometry_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.isometry_score = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for isometry_score: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<PostCoordinatedSemanticState> for super::PostCoordinatedSemanticState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: PostCoordinatedSemanticState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                alignment_metric_used: value.alignment_metric_used?,
                base_concept_cid: value.base_concept_cid?,
                concept_cid: value.concept_cid?,
                contextual_modifiers: value.contextual_modifiers?,
                event_cid: value.event_cid?,
                isometry_score: value.isometry_score?,
                prior_event_hash: value.prior_event_hash?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::PostCoordinatedSemanticState> for PostCoordinatedSemanticState {
        fn from(value: super::PostCoordinatedSemanticState) -> Self {
            Self {
                alignment_metric_used: Ok(value.alignment_metric_used),
                base_concept_cid: Ok(value.base_concept_cid),
                concept_cid: Ok(value.concept_cid),
                contextual_modifiers: Ok(value.contextual_modifiers),
                event_cid: Ok(value.event_cid),
                isometry_score: Ok(value.isometry_score),
                prior_event_hash: Ok(value.prior_event_hash),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct PostQuantumSignatureReceipt {
        pq_algorithm: ::std::result::Result<super::PqAlgorithm, ::std::string::String>,
        pq_signature_blob: ::std::result::Result<super::PqSignatureBlob, ::std::string::String>,
        public_key_cid: ::std::result::Result<super::PublicKeyCid, ::std::string::String>,
    }
    impl ::std::default::Default for PostQuantumSignatureReceipt {
        fn default() -> Self {
            Self {
                pq_algorithm: Err("no value supplied for pq_algorithm".to_string()),
                pq_signature_blob: Err("no value supplied for pq_signature_blob".to_string()),
                public_key_cid: Err("no value supplied for public_key_cid".to_string()),
            }
        }
    }
    impl PostQuantumSignatureReceipt {
        pub fn pq_algorithm<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PqAlgorithm>,
            T::Error: ::std::fmt::Display,
        {
            self.pq_algorithm = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for pq_algorithm: {e}"));
            self
        }
        pub fn pq_signature_blob<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PqSignatureBlob>,
            T::Error: ::std::fmt::Display,
        {
            self.pq_signature_blob = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for pq_signature_blob: {e}"));
            self
        }
        pub fn public_key_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PublicKeyCid>,
            T::Error: ::std::fmt::Display,
        {
            self.public_key_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for public_key_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<PostQuantumSignatureReceipt> for super::PostQuantumSignatureReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: PostQuantumSignatureReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                pq_algorithm: value.pq_algorithm?,
                pq_signature_blob: value.pq_signature_blob?,
                public_key_cid: value.public_key_cid?,
            })
        }
    }
    impl ::std::convert::From<super::PostQuantumSignatureReceipt> for PostQuantumSignatureReceipt {
        fn from(value: super::PostQuantumSignatureReceipt) -> Self {
            Self {
                pq_algorithm: Ok(value.pq_algorithm),
                pq_signature_blob: Ok(value.pq_signature_blob),
                public_key_cid: Ok(value.public_key_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct PredictionMarketPolicy {
        convergence_delta_threshold: ::std::result::Result<f64, ::std::string::String>,
        min_liquidity_magnitude: ::std::result::Result<u64, ::std::string::String>,
        staking_function: ::std::result::Result<super::StakingFunction, ::std::string::String>,
    }
    impl ::std::default::Default for PredictionMarketPolicy {
        fn default() -> Self {
            Self {
                convergence_delta_threshold: Err(
                    "no value supplied for convergence_delta_threshold".to_string(),
                ),
                min_liquidity_magnitude: Err(
                    "no value supplied for min_liquidity_magnitude".to_string()
                ),
                staking_function: Err("no value supplied for staking_function".to_string()),
            }
        }
    }
    impl PredictionMarketPolicy {
        pub fn convergence_delta_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.convergence_delta_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for convergence_delta_threshold: {e}")
            });
            self
        }
        pub fn min_liquidity_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.min_liquidity_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for min_liquidity_magnitude: {e}")
            });
            self
        }
        pub fn staking_function<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StakingFunction>,
            T::Error: ::std::fmt::Display,
        {
            self.staking_function = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for staking_function: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<PredictionMarketPolicy> for super::PredictionMarketPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: PredictionMarketPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                convergence_delta_threshold: value.convergence_delta_threshold?,
                min_liquidity_magnitude: value.min_liquidity_magnitude?,
                staking_function: value.staking_function?,
            })
        }
    }
    impl ::std::convert::From<super::PredictionMarketPolicy> for PredictionMarketPolicy {
        fn from(value: super::PredictionMarketPolicy) -> Self {
            Self {
                convergence_delta_threshold: Ok(value.convergence_delta_threshold),
                min_liquidity_magnitude: Ok(value.min_liquidity_magnitude),
                staking_function: Ok(value.staking_function),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct PredictionMarketState {
        current_market_probabilities: ::std::result::Result<
            ::std::collections::HashMap<
                ::std::string::String,
                super::PredictionMarketStateCurrentMarketProbabilitiesValue,
            >,
            ::std::string::String,
        >,
        lmsr_b_parameter: ::std::result::Result<super::LmsrBParameter, ::std::string::String>,
        market_cid: ::std::result::Result<super::MarketCid, ::std::string::String>,
        order_book: ::std::result::Result<
            ::std::vec::Vec<super::HypothesisStakeReceipt>,
            ::std::string::String,
        >,
        resolution_oracle_condition_cid:
            ::std::result::Result<super::ResolutionOracleConditionCid, ::std::string::String>,
    }
    impl ::std::default::Default for PredictionMarketState {
        fn default() -> Self {
            Self {
                current_market_probabilities: Err(
                    "no value supplied for current_market_probabilities".to_string(),
                ),
                lmsr_b_parameter: Err("no value supplied for lmsr_b_parameter".to_string()),
                market_cid: Err("no value supplied for market_cid".to_string()),
                order_book: Err("no value supplied for order_book".to_string()),
                resolution_oracle_condition_cid: Err(
                    "no value supplied for resolution_oracle_condition_cid".to_string(),
                ),
            }
        }
    }
    impl PredictionMarketState {
        pub fn current_market_probabilities<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::PredictionMarketStateCurrentMarketProbabilitiesValue,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.current_market_probabilities = value.try_into().map_err(|e| {
                format!("error converting supplied value for current_market_probabilities: {e}")
            });
            self
        }
        pub fn lmsr_b_parameter<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::LmsrBParameter>,
            T::Error: ::std::fmt::Display,
        {
            self.lmsr_b_parameter = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lmsr_b_parameter: {e}"));
            self
        }
        pub fn market_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MarketCid>,
            T::Error: ::std::fmt::Display,
        {
            self.market_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for market_cid: {e}"));
            self
        }
        pub fn order_book<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::HypothesisStakeReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.order_book = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for order_book: {e}"));
            self
        }
        pub fn resolution_oracle_condition_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ResolutionOracleConditionCid>,
            T::Error: ::std::fmt::Display,
        {
            self.resolution_oracle_condition_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for resolution_oracle_condition_cid: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<PredictionMarketState> for super::PredictionMarketState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: PredictionMarketState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                current_market_probabilities: value.current_market_probabilities?,
                lmsr_b_parameter: value.lmsr_b_parameter?,
                market_cid: value.market_cid?,
                order_book: value.order_book?,
                resolution_oracle_condition_cid: value.resolution_oracle_condition_cid?,
            })
        }
    }
    impl ::std::convert::From<super::PredictionMarketState> for PredictionMarketState {
        fn from(value: super::PredictionMarketState) -> Self {
            Self {
                current_market_probabilities: Ok(value.current_market_probabilities),
                lmsr_b_parameter: Ok(value.lmsr_b_parameter),
                market_cid: Ok(value.market_cid),
                order_book: Ok(value.order_book),
                resolution_oracle_condition_cid: Ok(value.resolution_oracle_condition_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct PresentationManifest {
        ambient_telemetry: ::std::result::Result<
            ::std::option::Option<super::AmbientState>,
            ::std::string::String,
        >,
        focal_depth_meters:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        grid: ::std::result::Result<super::MacroGridProfile, ::std::string::String>,
        intent: ::std::result::Result<super::AnyPresentationIntent, ::std::string::String>,
    }
    impl ::std::default::Default for PresentationManifest {
        fn default() -> Self {
            Self {
                ambient_telemetry: Ok(Default::default()),
                focal_depth_meters: Ok(Default::default()),
                grid: Err("no value supplied for grid".to_string()),
                intent: Err("no value supplied for intent".to_string()),
            }
        }
    }
    impl PresentationManifest {
        pub fn ambient_telemetry<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AmbientState>>,
            T::Error: ::std::fmt::Display,
        {
            self.ambient_telemetry = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for ambient_telemetry: {e}"));
            self
        }
        pub fn focal_depth_meters<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.focal_depth_meters = value.try_into().map_err(|e| {
                format!("error converting supplied value for focal_depth_meters: {e}")
            });
            self
        }
        pub fn grid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MacroGridProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.grid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for grid: {e}"));
            self
        }
        pub fn intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AnyPresentationIntent>,
            T::Error: ::std::fmt::Display,
        {
            self.intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for intent: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<PresentationManifest> for super::PresentationManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: PresentationManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                ambient_telemetry: value.ambient_telemetry?,
                focal_depth_meters: value.focal_depth_meters?,
                grid: value.grid?,
                intent: value.intent?,
            })
        }
    }
    impl ::std::convert::From<super::PresentationManifest> for PresentationManifest {
        fn from(value: super::PresentationManifest) -> Self {
            Self {
                ambient_telemetry: Ok(value.ambient_telemetry),
                focal_depth_meters: Ok(value.focal_depth_meters),
                grid: Ok(value.grid),
                intent: Ok(value.intent),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ProceduralMetadataManifest {
        latent_vector_coordinate: ::std::result::Result<
            ::std::option::Option<super::VectorEmbeddingState>,
            ::std::string::String,
        >,
        metadata_cid: ::std::result::Result<super::MetadataCid, ::std::string::String>,
        target_sop_cid: ::std::result::Result<super::TargetSopCid, ::std::string::String>,
        trigger_description:
            ::std::result::Result<super::TriggerDescription, ::std::string::String>,
    }
    impl ::std::default::Default for ProceduralMetadataManifest {
        fn default() -> Self {
            Self {
                latent_vector_coordinate: Ok(Default::default()),
                metadata_cid: Err("no value supplied for metadata_cid".to_string()),
                target_sop_cid: Err("no value supplied for target_sop_cid".to_string()),
                trigger_description: Err("no value supplied for trigger_description".to_string()),
            }
        }
    }
    impl ProceduralMetadataManifest {
        pub fn latent_vector_coordinate<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VectorEmbeddingState>>,
            T::Error: ::std::fmt::Display,
        {
            self.latent_vector_coordinate = value.try_into().map_err(|e| {
                format!("error converting supplied value for latent_vector_coordinate: {e}")
            });
            self
        }
        pub fn metadata_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MetadataCid>,
            T::Error: ::std::fmt::Display,
        {
            self.metadata_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for metadata_cid: {e}"));
            self
        }
        pub fn target_sop_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetSopCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_sop_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_sop_cid: {e}"));
            self
        }
        pub fn trigger_description<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TriggerDescription>,
            T::Error: ::std::fmt::Display,
        {
            self.trigger_description = value.try_into().map_err(|e| {
                format!("error converting supplied value for trigger_description: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<ProceduralMetadataManifest> for super::ProceduralMetadataManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ProceduralMetadataManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                latent_vector_coordinate: value.latent_vector_coordinate?,
                metadata_cid: value.metadata_cid?,
                target_sop_cid: value.target_sop_cid?,
                trigger_description: value.trigger_description?,
            })
        }
    }
    impl ::std::convert::From<super::ProceduralMetadataManifest> for ProceduralMetadataManifest {
        fn from(value: super::ProceduralMetadataManifest) -> Self {
            Self {
                latent_vector_coordinate: Ok(value.latent_vector_coordinate),
                metadata_cid: Ok(value.metadata_cid),
                target_sop_cid: Ok(value.target_sop_cid),
                trigger_description: Ok(value.trigger_description),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ProcessRewardContract {
        convergence_sla: ::std::result::Result<
            ::std::option::Option<super::DynamicConvergenceSla>,
            ::std::string::String,
        >,
        evaluator_matrix_name: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        max_backtracks_allowed: ::std::result::Result<u64, ::std::string::String>,
        pruning_threshold: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for ProcessRewardContract {
        fn default() -> Self {
            Self {
                convergence_sla: Ok(Default::default()),
                evaluator_matrix_name: Ok(Default::default()),
                max_backtracks_allowed: Err(
                    "no value supplied for max_backtracks_allowed".to_string()
                ),
                pruning_threshold: Err("no value supplied for pruning_threshold".to_string()),
            }
        }
    }
    impl ProcessRewardContract {
        pub fn convergence_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DynamicConvergenceSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.convergence_sla = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for convergence_sla: {e}"));
            self
        }
        pub fn evaluator_matrix_name<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.evaluator_matrix_name = value.try_into().map_err(|e| {
                format!("error converting supplied value for evaluator_matrix_name: {e}")
            });
            self
        }
        pub fn max_backtracks_allowed<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_backtracks_allowed = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_backtracks_allowed: {e}")
            });
            self
        }
        pub fn pruning_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.pruning_threshold = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for pruning_threshold: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ProcessRewardContract> for super::ProcessRewardContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ProcessRewardContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                convergence_sla: value.convergence_sla?,
                evaluator_matrix_name: value.evaluator_matrix_name?,
                max_backtracks_allowed: value.max_backtracks_allowed?,
                pruning_threshold: value.pruning_threshold?,
            })
        }
    }
    impl ::std::convert::From<super::ProcessRewardContract> for ProcessRewardContract {
        fn from(value: super::ProcessRewardContract) -> Self {
            Self {
                convergence_sla: Ok(value.convergence_sla),
                evaluator_matrix_name: Ok(value.evaluator_matrix_name),
                max_backtracks_allowed: Ok(value.max_backtracks_allowed),
                pruning_threshold: Ok(value.pruning_threshold),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct QuarantineIntent {
        reason: ::std::result::Result<super::Reason, ::std::string::String>,
        target_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for QuarantineIntent {
        fn default() -> Self {
            Self {
                reason: Err("no value supplied for reason".to_string()),
                target_node_cid: Err("no value supplied for target_node_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl QuarantineIntent {
        pub fn reason<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Reason>,
            T::Error: ::std::fmt::Display,
        {
            self.reason = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for reason: {e}"));
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<QuarantineIntent> for super::QuarantineIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: QuarantineIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                reason: value.reason?,
                target_node_cid: value.target_node_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::QuarantineIntent> for QuarantineIntent {
        fn from(value: super::QuarantineIntent) -> Self {
            Self {
                reason: Ok(value.reason),
                target_node_cid: Ok(value.target_node_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct QuorumPolicy {
        byzantine_action: ::std::result::Result<super::ByzantineAction, ::std::string::String>,
        max_tolerable_faults: ::std::result::Result<u64, ::std::string::String>,
        min_quorum_size: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        state_validation_metric:
            ::std::result::Result<super::StateValidationMetric, ::std::string::String>,
    }
    impl ::std::default::Default for QuorumPolicy {
        fn default() -> Self {
            Self {
                byzantine_action: Err("no value supplied for byzantine_action".to_string()),
                max_tolerable_faults: Err("no value supplied for max_tolerable_faults".to_string()),
                min_quorum_size: Err("no value supplied for min_quorum_size".to_string()),
                state_validation_metric: Err(
                    "no value supplied for state_validation_metric".to_string()
                ),
            }
        }
    }
    impl QuorumPolicy {
        pub fn byzantine_action<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ByzantineAction>,
            T::Error: ::std::fmt::Display,
        {
            self.byzantine_action = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for byzantine_action: {e}"));
            self
        }
        pub fn max_tolerable_faults<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_tolerable_faults = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_tolerable_faults: {e}")
            });
            self
        }
        pub fn min_quorum_size<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.min_quorum_size = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for min_quorum_size: {e}"));
            self
        }
        pub fn state_validation_metric<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StateValidationMetric>,
            T::Error: ::std::fmt::Display,
        {
            self.state_validation_metric = value.try_into().map_err(|e| {
                format!("error converting supplied value for state_validation_metric: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<QuorumPolicy> for super::QuorumPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: QuorumPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                byzantine_action: value.byzantine_action?,
                max_tolerable_faults: value.max_tolerable_faults?,
                min_quorum_size: value.min_quorum_size?,
                state_validation_metric: value.state_validation_metric?,
            })
        }
    }
    impl ::std::convert::From<super::QuorumPolicy> for QuorumPolicy {
        fn from(value: super::QuorumPolicy) -> Self {
            Self {
                byzantine_action: Ok(value.byzantine_action),
                max_tolerable_faults: Ok(value.max_tolerable_faults),
                min_quorum_size: Ok(value.min_quorum_size),
                state_validation_metric: Ok(value.state_validation_metric),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct RdfExportReceipt {
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        export_cid: ::std::result::Result<super::ExportCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        rdf_triple_count: ::std::result::Result<i64, ::std::string::String>,
        serialized_payload: ::std::result::Result<::std::string::String, ::std::string::String>,
        sha256_graph_hash: ::std::result::Result<super::Sha256GraphHash, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for RdfExportReceipt {
        fn default() -> Self {
            Self {
                event_cid: Err("no value supplied for event_cid".to_string()),
                export_cid: Err("no value supplied for export_cid".to_string()),
                prior_event_hash: Ok(Default::default()),
                rdf_triple_count: Err("no value supplied for rdf_triple_count".to_string()),
                serialized_payload: Err("no value supplied for serialized_payload".to_string()),
                sha256_graph_hash: Err("no value supplied for sha256_graph_hash".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl RdfExportReceipt {
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn export_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ExportCid>,
            T::Error: ::std::fmt::Display,
        {
            self.export_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for export_cid: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn rdf_triple_count<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<i64>,
            T::Error: ::std::fmt::Display,
        {
            self.rdf_triple_count = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for rdf_triple_count: {e}"));
            self
        }
        pub fn serialized_payload<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.serialized_payload = value.try_into().map_err(|e| {
                format!("error converting supplied value for serialized_payload: {e}")
            });
            self
        }
        pub fn sha256_graph_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Sha256GraphHash>,
            T::Error: ::std::fmt::Display,
        {
            self.sha256_graph_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for sha256_graph_hash: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<RdfExportReceipt> for super::RdfExportReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: RdfExportReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                event_cid: value.event_cid?,
                export_cid: value.export_cid?,
                prior_event_hash: value.prior_event_hash?,
                rdf_triple_count: value.rdf_triple_count?,
                serialized_payload: value.serialized_payload?,
                sha256_graph_hash: value.sha256_graph_hash?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::RdfExportReceipt> for RdfExportReceipt {
        fn from(value: super::RdfExportReceipt) -> Self {
            Self {
                event_cid: Ok(value.event_cid),
                export_cid: Ok(value.export_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                rdf_triple_count: Ok(value.rdf_triple_count),
                serialized_payload: Ok(value.serialized_payload),
                sha256_graph_hash: Ok(value.sha256_graph_hash),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct RdfSerializationIntent {
        base_uri_namespace: ::std::result::Result<::std::string::String, ::std::string::String>,
        export_cid: ::std::result::Result<super::ExportCid, ::std::string::String>,
        shacl_governance: ::std::result::Result<
            ::std::option::Option<super::ShaclValidationSla>,
            ::std::string::String,
        >,
        target_format: ::std::result::Result<
            ::std::option::Option<super::TargetFormat>,
            ::std::string::String,
        >,
        target_graph_cid: ::std::result::Result<super::TargetGraphCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for RdfSerializationIntent {
        fn default() -> Self {
            Self {
                base_uri_namespace: Err("no value supplied for base_uri_namespace".to_string()),
                export_cid: Err("no value supplied for export_cid".to_string()),
                shacl_governance: Ok(Default::default()),
                target_format: Ok(Default::default()),
                target_graph_cid: Err("no value supplied for target_graph_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl RdfSerializationIntent {
        pub fn base_uri_namespace<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.base_uri_namespace = value.try_into().map_err(|e| {
                format!("error converting supplied value for base_uri_namespace: {e}")
            });
            self
        }
        pub fn export_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ExportCid>,
            T::Error: ::std::fmt::Display,
        {
            self.export_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for export_cid: {e}"));
            self
        }
        pub fn shacl_governance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ShaclValidationSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.shacl_governance = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for shacl_governance: {e}"));
            self
        }
        pub fn target_format<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TargetFormat>>,
            T::Error: ::std::fmt::Display,
        {
            self.target_format = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_format: {e}"));
            self
        }
        pub fn target_graph_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetGraphCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_graph_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_graph_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<RdfSerializationIntent> for super::RdfSerializationIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: RdfSerializationIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                base_uri_namespace: value.base_uri_namespace?,
                export_cid: value.export_cid?,
                shacl_governance: value.shacl_governance?,
                target_format: value.target_format?,
                target_graph_cid: value.target_graph_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::RdfSerializationIntent> for RdfSerializationIntent {
        fn from(value: super::RdfSerializationIntent) -> Self {
            Self {
                base_uri_namespace: Ok(value.base_uri_namespace),
                export_cid: Ok(value.export_cid),
                shacl_governance: Ok(value.shacl_governance),
                target_format: Ok(value.target_format),
                target_graph_cid: Ok(value.target_graph_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ReasoningEngineeringPolicy {
        human_override_gradient: ::std::result::Result<f64, ::std::string::String>,
        telemetry_export_frequency_hz:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for ReasoningEngineeringPolicy {
        fn default() -> Self {
            Self {
                human_override_gradient: Err(
                    "no value supplied for human_override_gradient".to_string()
                ),
                telemetry_export_frequency_hz: Err(
                    "no value supplied for telemetry_export_frequency_hz".to_string(),
                ),
            }
        }
    }
    impl ReasoningEngineeringPolicy {
        pub fn human_override_gradient<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.human_override_gradient = value.try_into().map_err(|e| {
                format!("error converting supplied value for human_override_gradient: {e}")
            });
            self
        }
        pub fn telemetry_export_frequency_hz<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.telemetry_export_frequency_hz = value.try_into().map_err(|e| {
                format!("error converting supplied value for telemetry_export_frequency_hz: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<ReasoningEngineeringPolicy> for super::ReasoningEngineeringPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ReasoningEngineeringPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                human_override_gradient: value.human_override_gradient?,
                telemetry_export_frequency_hz: value.telemetry_export_frequency_hz?,
            })
        }
    }
    impl ::std::convert::From<super::ReasoningEngineeringPolicy> for ReasoningEngineeringPolicy {
        fn from(value: super::ReasoningEngineeringPolicy) -> Self {
            Self {
                human_override_gradient: Ok(value.human_override_gradient),
                telemetry_export_frequency_hz: Ok(value.telemetry_export_frequency_hz),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct RollbackIntent {
        invalidated_node_cids: ::std::result::Result<
            ::std::vec::Vec<super::InvalidatedNodeCidsItem>,
            ::std::string::String,
        >,
        request_cid: ::std::result::Result<super::RequestCid, ::std::string::String>,
        target_event_cid: ::std::result::Result<super::TargetEventCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for RollbackIntent {
        fn default() -> Self {
            Self {
                invalidated_node_cids: Ok(Default::default()),
                request_cid: Err("no value supplied for request_cid".to_string()),
                target_event_cid: Err("no value supplied for target_event_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl RollbackIntent {
        pub fn invalidated_node_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::InvalidatedNodeCidsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.invalidated_node_cids = value.try_into().map_err(|e| {
                format!("error converting supplied value for invalidated_node_cids: {e}")
            });
            self
        }
        pub fn request_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RequestCid>,
            T::Error: ::std::fmt::Display,
        {
            self.request_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for request_cid: {e}"));
            self
        }
        pub fn target_event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetEventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_event_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<RollbackIntent> for super::RollbackIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: RollbackIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                invalidated_node_cids: value.invalidated_node_cids?,
                request_cid: value.request_cid?,
                target_event_cid: value.target_event_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::RollbackIntent> for RollbackIntent {
        fn from(value: super::RollbackIntent) -> Self {
            Self {
                invalidated_node_cids: Ok(value.invalidated_node_cids),
                request_cid: Ok(value.request_cid),
                target_event_cid: Ok(value.target_event_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct RoutingFrontierPolicy {
        max_carbon_intensity_gco2eq_kwh:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        max_cost_magnitude_per_token:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        max_latency_ms: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        min_capability_score: ::std::result::Result<f64, ::std::string::String>,
        tradeoff_preference:
            ::std::result::Result<super::TradeoffPreference, ::std::string::String>,
    }
    impl ::std::default::Default for RoutingFrontierPolicy {
        fn default() -> Self {
            Self {
                max_carbon_intensity_gco2eq_kwh: Ok(Default::default()),
                max_cost_magnitude_per_token: Err(
                    "no value supplied for max_cost_magnitude_per_token".to_string(),
                ),
                max_latency_ms: Err("no value supplied for max_latency_ms".to_string()),
                min_capability_score: Err("no value supplied for min_capability_score".to_string()),
                tradeoff_preference: Err("no value supplied for tradeoff_preference".to_string()),
            }
        }
    }
    impl RoutingFrontierPolicy {
        pub fn max_carbon_intensity_gco2eq_kwh<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_carbon_intensity_gco2eq_kwh = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_carbon_intensity_gco2eq_kwh: {e}")
            });
            self
        }
        pub fn max_cost_magnitude_per_token<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_cost_magnitude_per_token = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_cost_magnitude_per_token: {e}")
            });
            self
        }
        pub fn max_latency_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_latency_ms = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_latency_ms: {e}"));
            self
        }
        pub fn min_capability_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.min_capability_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for min_capability_score: {e}")
            });
            self
        }
        pub fn tradeoff_preference<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TradeoffPreference>,
            T::Error: ::std::fmt::Display,
        {
            self.tradeoff_preference = value.try_into().map_err(|e| {
                format!("error converting supplied value for tradeoff_preference: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<RoutingFrontierPolicy> for super::RoutingFrontierPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: RoutingFrontierPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_carbon_intensity_gco2eq_kwh: value.max_carbon_intensity_gco2eq_kwh?,
                max_cost_magnitude_per_token: value.max_cost_magnitude_per_token?,
                max_latency_ms: value.max_latency_ms?,
                min_capability_score: value.min_capability_score?,
                tradeoff_preference: value.tradeoff_preference?,
            })
        }
    }
    impl ::std::convert::From<super::RoutingFrontierPolicy> for RoutingFrontierPolicy {
        fn from(value: super::RoutingFrontierPolicy) -> Self {
            Self {
                max_carbon_intensity_gco2eq_kwh: Ok(value.max_carbon_intensity_gco2eq_kwh),
                max_cost_magnitude_per_token: Ok(value.max_cost_magnitude_per_token),
                max_latency_ms: Ok(value.max_latency_ms),
                min_capability_score: Ok(value.min_capability_score),
                tradeoff_preference: Ok(value.tradeoff_preference),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SaeFeatureActivationState {
        activation_magnitude: ::std::result::Result<f64, ::std::string::String>,
        feature_index: ::std::result::Result<u64, ::std::string::String>,
        interpretability_label: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SaeFeatureActivationState {
        fn default() -> Self {
            Self {
                activation_magnitude: Err("no value supplied for activation_magnitude".to_string()),
                feature_index: Err("no value supplied for feature_index".to_string()),
                interpretability_label: Ok(Default::default()),
            }
        }
    }
    impl SaeFeatureActivationState {
        pub fn activation_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.activation_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for activation_magnitude: {e}")
            });
            self
        }
        pub fn feature_index<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.feature_index = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for feature_index: {e}"));
            self
        }
        pub fn interpretability_label<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.interpretability_label = value.try_into().map_err(|e| {
                format!("error converting supplied value for interpretability_label: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<SaeFeatureActivationState> for super::SaeFeatureActivationState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SaeFeatureActivationState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                activation_magnitude: value.activation_magnitude?,
                feature_index: value.feature_index?,
                interpretability_label: value.interpretability_label?,
            })
        }
    }
    impl ::std::convert::From<super::SaeFeatureActivationState> for SaeFeatureActivationState {
        fn from(value: super::SaeFeatureActivationState) -> Self {
            Self {
                activation_magnitude: Ok(value.activation_magnitude),
                feature_index: Ok(value.feature_index),
                interpretability_label: Ok(value.interpretability_label),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SaeLatentPolicy {
        clamp_value: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        max_activation_threshold: ::std::result::Result<f64, ::std::string::String>,
        monitored_hook_points: ::std::result::Result<
            ::std::vec::Vec<super::MonitoredHookPointsItem>,
            ::std::string::String,
        >,
        sae_dictionary_hash: ::std::result::Result<super::SaeDictionaryHash, ::std::string::String>,
        smoothing_profile: ::std::result::Result<
            ::std::option::Option<super::LatentSmoothingProfile>,
            ::std::string::String,
        >,
        target_feature_index: ::std::result::Result<u64, ::std::string::String>,
        violation_action: ::std::result::Result<super::ViolationAction, ::std::string::String>,
    }
    impl ::std::default::Default for SaeLatentPolicy {
        fn default() -> Self {
            Self {
                clamp_value: Ok(Default::default()),
                max_activation_threshold: Err(
                    "no value supplied for max_activation_threshold".to_string()
                ),
                monitored_hook_points: Err(
                    "no value supplied for monitored_hook_points".to_string()
                ),
                sae_dictionary_hash: Err("no value supplied for sae_dictionary_hash".to_string()),
                smoothing_profile: Ok(Default::default()),
                target_feature_index: Err("no value supplied for target_feature_index".to_string()),
                violation_action: Err("no value supplied for violation_action".to_string()),
            }
        }
    }
    impl SaeLatentPolicy {
        pub fn clamp_value<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.clamp_value = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for clamp_value: {e}"));
            self
        }
        pub fn max_activation_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_activation_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_activation_threshold: {e}")
            });
            self
        }
        pub fn monitored_hook_points<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::MonitoredHookPointsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.monitored_hook_points = value.try_into().map_err(|e| {
                format!("error converting supplied value for monitored_hook_points: {e}")
            });
            self
        }
        pub fn sae_dictionary_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SaeDictionaryHash>,
            T::Error: ::std::fmt::Display,
        {
            self.sae_dictionary_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for sae_dictionary_hash: {e}")
            });
            self
        }
        pub fn smoothing_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LatentSmoothingProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.smoothing_profile = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for smoothing_profile: {e}"));
            self
        }
        pub fn target_feature_index<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.target_feature_index = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_feature_index: {e}")
            });
            self
        }
        pub fn violation_action<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ViolationAction>,
            T::Error: ::std::fmt::Display,
        {
            self.violation_action = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for violation_action: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SaeLatentPolicy> for super::SaeLatentPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SaeLatentPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                clamp_value: value.clamp_value?,
                max_activation_threshold: value.max_activation_threshold?,
                monitored_hook_points: value.monitored_hook_points?,
                sae_dictionary_hash: value.sae_dictionary_hash?,
                smoothing_profile: value.smoothing_profile?,
                target_feature_index: value.target_feature_index?,
                violation_action: value.violation_action?,
            })
        }
    }
    impl ::std::convert::From<super::SaeLatentPolicy> for SaeLatentPolicy {
        fn from(value: super::SaeLatentPolicy) -> Self {
            Self {
                clamp_value: Ok(value.clamp_value),
                max_activation_threshold: Ok(value.max_activation_threshold),
                monitored_hook_points: Ok(value.monitored_hook_points),
                sae_dictionary_hash: Ok(value.sae_dictionary_hash),
                smoothing_profile: Ok(value.smoothing_profile),
                target_feature_index: Ok(value.target_feature_index),
                violation_action: Ok(value.violation_action),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SalienceProfile {
        baseline_importance: ::std::result::Result<f64, ::std::string::String>,
        decay_rate: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for SalienceProfile {
        fn default() -> Self {
            Self {
                baseline_importance: Err("no value supplied for baseline_importance".to_string()),
                decay_rate: Err("no value supplied for decay_rate".to_string()),
            }
        }
    }
    impl SalienceProfile {
        pub fn baseline_importance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.baseline_importance = value.try_into().map_err(|e| {
                format!("error converting supplied value for baseline_importance: {e}")
            });
            self
        }
        pub fn decay_rate<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.decay_rate = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for decay_rate: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SalienceProfile> for super::SalienceProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SalienceProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                baseline_importance: value.baseline_importance?,
                decay_rate: value.decay_rate?,
            })
        }
    }
    impl ::std::convert::From<super::SalienceProfile> for SalienceProfile {
        fn from(value: super::SalienceProfile) -> Self {
            Self {
                baseline_importance: Ok(value.baseline_importance),
                decay_rate: Ok(value.decay_rate),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ScalePolicy {
        domain_max: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        domain_min: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        topology_class: ::std::result::Result<super::TopologyClass, ::std::string::String>,
    }
    impl ::std::default::Default for ScalePolicy {
        fn default() -> Self {
            Self {
                domain_max: Ok(Default::default()),
                domain_min: Ok(Default::default()),
                topology_class: Err("no value supplied for topology_class".to_string()),
            }
        }
    }
    impl ScalePolicy {
        pub fn domain_max<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.domain_max = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for domain_max: {e}"));
            self
        }
        pub fn domain_min<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.domain_min = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for domain_min: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TopologyClass>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ScalePolicy> for super::ScalePolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ScalePolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                domain_max: value.domain_max?,
                domain_min: value.domain_min?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::ScalePolicy> for ScalePolicy {
        fn from(value: super::ScalePolicy) -> Self {
            Self {
                domain_max: Ok(value.domain_max),
                domain_min: Ok(value.domain_min),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SchemaDrivenExtractionSla {
        extraction_framework:
            ::std::result::Result<super::ExtractionFramework, ::std::string::String>,
        linkml_governance: ::std::result::Result<
            ::std::option::Option<super::LinkMlValidationSla>,
            ::std::string::String,
        >,
        max_schema_retries: ::std::result::Result<u64, ::std::string::String>,
        schema_registry_uri: ::std::result::Result<::std::string::String, ::std::string::String>,
        validation_failure_action:
            ::std::result::Result<super::ValidationFailureAction, ::std::string::String>,
    }
    impl ::std::default::Default for SchemaDrivenExtractionSla {
        fn default() -> Self {
            Self {
                extraction_framework: Err("no value supplied for extraction_framework".to_string()),
                linkml_governance: Ok(Default::default()),
                max_schema_retries: Err("no value supplied for max_schema_retries".to_string()),
                schema_registry_uri: Err("no value supplied for schema_registry_uri".to_string()),
                validation_failure_action: Err(
                    "no value supplied for validation_failure_action".to_string()
                ),
            }
        }
    }
    impl SchemaDrivenExtractionSla {
        pub fn extraction_framework<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ExtractionFramework>,
            T::Error: ::std::fmt::Display,
        {
            self.extraction_framework = value.try_into().map_err(|e| {
                format!("error converting supplied value for extraction_framework: {e}")
            });
            self
        }
        pub fn linkml_governance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LinkMlValidationSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.linkml_governance = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for linkml_governance: {e}"));
            self
        }
        pub fn max_schema_retries<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_schema_retries = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_schema_retries: {e}")
            });
            self
        }
        pub fn schema_registry_uri<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.schema_registry_uri = value.try_into().map_err(|e| {
                format!("error converting supplied value for schema_registry_uri: {e}")
            });
            self
        }
        pub fn validation_failure_action<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ValidationFailureAction>,
            T::Error: ::std::fmt::Display,
        {
            self.validation_failure_action = value.try_into().map_err(|e| {
                format!("error converting supplied value for validation_failure_action: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<SchemaDrivenExtractionSla> for super::SchemaDrivenExtractionSla {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SchemaDrivenExtractionSla,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                extraction_framework: value.extraction_framework?,
                linkml_governance: value.linkml_governance?,
                max_schema_retries: value.max_schema_retries?,
                schema_registry_uri: value.schema_registry_uri?,
                validation_failure_action: value.validation_failure_action?,
            })
        }
    }
    impl ::std::convert::From<super::SchemaDrivenExtractionSla> for SchemaDrivenExtractionSla {
        fn from(value: super::SchemaDrivenExtractionSla) -> Self {
            Self {
                extraction_framework: Ok(value.extraction_framework),
                linkml_governance: Ok(value.linkml_governance),
                max_schema_retries: Ok(value.max_schema_retries),
                schema_registry_uri: Ok(value.schema_registry_uri),
                validation_failure_action: Ok(value.validation_failure_action),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct Se3TransformProfile {
        dual_quaternion_motor: ::std::result::Result<
            ::std::option::Option<[::serde_json::Value; 8usize]>,
            ::std::string::String,
        >,
        kinematic_derivatives: ::std::result::Result<
            ::std::option::Option<super::KinematicDerivativeProfile>,
            ::std::string::String,
        >,
        qw: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        qx: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        qy: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        qz: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        reference_frame_cid: ::std::result::Result<super::ReferenceFrameCid, ::std::string::String>,
        scale: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        x: ::std::result::Result<f64, ::std::string::String>,
        y: ::std::result::Result<f64, ::std::string::String>,
        z: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for Se3TransformProfile {
        fn default() -> Self {
            Self {
                dual_quaternion_motor: Ok(Default::default()),
                kinematic_derivatives: Ok(Default::default()),
                qw: Ok(Default::default()),
                qx: Ok(Default::default()),
                qy: Ok(Default::default()),
                qz: Ok(Default::default()),
                reference_frame_cid: Err("no value supplied for reference_frame_cid".to_string()),
                scale: Ok(Default::default()),
                x: Err("no value supplied for x".to_string()),
                y: Err("no value supplied for y".to_string()),
                z: Err("no value supplied for z".to_string()),
            }
        }
    }
    impl Se3TransformProfile {
        pub fn dual_quaternion_motor<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<[::serde_json::Value; 8usize]>>,
            T::Error: ::std::fmt::Display,
        {
            self.dual_quaternion_motor = value.try_into().map_err(|e| {
                format!("error converting supplied value for dual_quaternion_motor: {e}")
            });
            self
        }
        pub fn kinematic_derivatives<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::KinematicDerivativeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.kinematic_derivatives = value.try_into().map_err(|e| {
                format!("error converting supplied value for kinematic_derivatives: {e}")
            });
            self
        }
        pub fn qw<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.qw = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for qw: {e}"));
            self
        }
        pub fn qx<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.qx = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for qx: {e}"));
            self
        }
        pub fn qy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.qy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for qy: {e}"));
            self
        }
        pub fn qz<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.qz = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for qz: {e}"));
            self
        }
        pub fn reference_frame_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ReferenceFrameCid>,
            T::Error: ::std::fmt::Display,
        {
            self.reference_frame_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for reference_frame_cid: {e}")
            });
            self
        }
        pub fn scale<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.scale = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for scale: {e}"));
            self
        }
        pub fn x<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.x = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for x: {e}"));
            self
        }
        pub fn y<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.y = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for y: {e}"));
            self
        }
        pub fn z<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.z = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for z: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<Se3TransformProfile> for super::Se3TransformProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: Se3TransformProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                dual_quaternion_motor: value.dual_quaternion_motor?,
                kinematic_derivatives: value.kinematic_derivatives?,
                qw: value.qw?,
                qx: value.qx?,
                qy: value.qy?,
                qz: value.qz?,
                reference_frame_cid: value.reference_frame_cid?,
                scale: value.scale?,
                x: value.x?,
                y: value.y?,
                z: value.z?,
            })
        }
    }
    impl ::std::convert::From<super::Se3TransformProfile> for Se3TransformProfile {
        fn from(value: super::Se3TransformProfile) -> Self {
            Self {
                dual_quaternion_motor: Ok(value.dual_quaternion_motor),
                kinematic_derivatives: Ok(value.kinematic_derivatives),
                qw: Ok(value.qw),
                qx: Ok(value.qx),
                qy: Ok(value.qy),
                qz: Ok(value.qz),
                reference_frame_cid: Ok(value.reference_frame_cid),
                scale: Ok(value.scale),
                x: Ok(value.x),
                y: Ok(value.y),
                z: Ok(value.z),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SecureSubSessionState {
        allowed_vault_keys: ::std::result::Result<
            ::std::vec::Vec<super::AllowedVaultKeysItem>,
            ::std::string::String,
        >,
        description: ::std::result::Result<super::Description, ::std::string::String>,
        max_ttl_seconds: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        session_cid: ::std::result::Result<super::SessionCid, ::std::string::String>,
    }
    impl ::std::default::Default for SecureSubSessionState {
        fn default() -> Self {
            Self {
                allowed_vault_keys: Err("no value supplied for allowed_vault_keys".to_string()),
                description: Err("no value supplied for description".to_string()),
                max_ttl_seconds: Err("no value supplied for max_ttl_seconds".to_string()),
                session_cid: Err("no value supplied for session_cid".to_string()),
            }
        }
    }
    impl SecureSubSessionState {
        pub fn allowed_vault_keys<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AllowedVaultKeysItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.allowed_vault_keys = value.try_into().map_err(|e| {
                format!("error converting supplied value for allowed_vault_keys: {e}")
            });
            self
        }
        pub fn description<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Description>,
            T::Error: ::std::fmt::Display,
        {
            self.description = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for description: {e}"));
            self
        }
        pub fn max_ttl_seconds<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_ttl_seconds = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_ttl_seconds: {e}"));
            self
        }
        pub fn session_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SessionCid>,
            T::Error: ::std::fmt::Display,
        {
            self.session_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for session_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SecureSubSessionState> for super::SecureSubSessionState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SecureSubSessionState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                allowed_vault_keys: value.allowed_vault_keys?,
                description: value.description?,
                max_ttl_seconds: value.max_ttl_seconds?,
                session_cid: value.session_cid?,
            })
        }
    }
    impl ::std::convert::From<super::SecureSubSessionState> for SecureSubSessionState {
        fn from(value: super::SecureSubSessionState) -> Self {
            Self {
                allowed_vault_keys: Ok(value.allowed_vault_keys),
                description: Ok(value.description),
                max_ttl_seconds: Ok(value.max_ttl_seconds),
                session_cid: Ok(value.session_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SelfCorrectionPolicy {
        max_loops: ::std::result::Result<u64, ::std::string::String>,
        rollback_on_failure: ::std::result::Result<bool, ::std::string::String>,
    }
    impl ::std::default::Default for SelfCorrectionPolicy {
        fn default() -> Self {
            Self {
                max_loops: Err("no value supplied for max_loops".to_string()),
                rollback_on_failure: Err("no value supplied for rollback_on_failure".to_string()),
            }
        }
    }
    impl SelfCorrectionPolicy {
        pub fn max_loops<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_loops = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_loops: {e}"));
            self
        }
        pub fn rollback_on_failure<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.rollback_on_failure = value.try_into().map_err(|e| {
                format!("error converting supplied value for rollback_on_failure: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<SelfCorrectionPolicy> for super::SelfCorrectionPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SelfCorrectionPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_loops: value.max_loops?,
                rollback_on_failure: value.rollback_on_failure?,
            })
        }
    }
    impl ::std::convert::From<super::SelfCorrectionPolicy> for SelfCorrectionPolicy {
        fn from(value: super::SelfCorrectionPolicy) -> Self {
            Self {
                max_loops: Ok(value.max_loops),
                rollback_on_failure: Ok(value.rollback_on_failure),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SemanticDiscoveryIntent {
        min_isometry_score: ::std::result::Result<f64, ::std::string::String>,
        query_vector: ::std::result::Result<super::VectorEmbeddingState, ::std::string::String>,
        required_structural_types: ::std::result::Result<
            ::std::vec::Vec<super::RequiredStructuralTypesItem>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SemanticDiscoveryIntent {
        fn default() -> Self {
            Self {
                min_isometry_score: Err("no value supplied for min_isometry_score".to_string()),
                query_vector: Err("no value supplied for query_vector".to_string()),
                required_structural_types: Err(
                    "no value supplied for required_structural_types".to_string()
                ),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl SemanticDiscoveryIntent {
        pub fn min_isometry_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.min_isometry_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for min_isometry_score: {e}")
            });
            self
        }
        pub fn query_vector<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VectorEmbeddingState>,
            T::Error: ::std::fmt::Display,
        {
            self.query_vector = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for query_vector: {e}"));
            self
        }
        pub fn required_structural_types<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::RequiredStructuralTypesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.required_structural_types = value.try_into().map_err(|e| {
                format!("error converting supplied value for required_structural_types: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SemanticDiscoveryIntent> for super::SemanticDiscoveryIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SemanticDiscoveryIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                min_isometry_score: value.min_isometry_score?,
                query_vector: value.query_vector?,
                required_structural_types: value.required_structural_types?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::SemanticDiscoveryIntent> for SemanticDiscoveryIntent {
        fn from(value: super::SemanticDiscoveryIntent) -> Self {
            Self {
                min_isometry_score: Ok(value.min_isometry_score),
                query_vector: Ok(value.query_vector),
                required_structural_types: Ok(value.required_structural_types),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SemanticEdgeState {
        belief_vector: ::std::result::Result<
            ::std::option::Option<super::DempsterShaferBeliefVector>,
            ::std::string::String,
        >,
        causal_relationship: ::std::result::Result<
            ::std::option::Option<super::CausalRelationship>,
            ::std::string::String,
        >,
        edge_cid: ::std::result::Result<super::EdgeCid, ::std::string::String>,
        embedding: ::std::result::Result<
            ::std::option::Option<super::VectorEmbeddingState>,
            ::std::string::String,
        >,
        grounding_sla: ::std::result::Result<
            ::std::option::Option<super::EvidentiaryGroundingSla>,
            ::std::string::String,
        >,
        object_node_cid: ::std::result::Result<super::ObjectNodeCid, ::std::string::String>,
        predicate_curie: ::std::result::Result<super::PredicateCurie, ::std::string::String>,
        provenance: ::std::result::Result<
            ::std::option::Option<super::EpistemicProvenanceReceipt>,
            ::std::string::String,
        >,
        subject_node_cid: ::std::result::Result<super::SubjectNodeCid, ::std::string::String>,
        temporal_bounds: ::std::result::Result<super::TemporalBoundsProfile, ::std::string::String>,
        volumetric_geometry: ::std::result::Result<
            ::std::option::Option<super::VolumetricEdgeProfile>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SemanticEdgeState {
        fn default() -> Self {
            Self {
                belief_vector: Ok(Default::default()),
                causal_relationship: Ok(Default::default()),
                edge_cid: Err("no value supplied for edge_cid".to_string()),
                embedding: Ok(Default::default()),
                grounding_sla: Ok(Default::default()),
                object_node_cid: Err("no value supplied for object_node_cid".to_string()),
                predicate_curie: Err("no value supplied for predicate_curie".to_string()),
                provenance: Ok(Default::default()),
                subject_node_cid: Err("no value supplied for subject_node_cid".to_string()),
                temporal_bounds: Err("no value supplied for temporal_bounds".to_string()),
                volumetric_geometry: Ok(Default::default()),
            }
        }
    }
    impl SemanticEdgeState {
        pub fn belief_vector<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::DempsterShaferBeliefVector>>,
            T::Error: ::std::fmt::Display,
        {
            self.belief_vector = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for belief_vector: {e}"));
            self
        }
        pub fn causal_relationship<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CausalRelationship>>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_relationship = value.try_into().map_err(|e| {
                format!("error converting supplied value for causal_relationship: {e}")
            });
            self
        }
        pub fn edge_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EdgeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.edge_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for edge_cid: {e}"));
            self
        }
        pub fn embedding<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VectorEmbeddingState>>,
            T::Error: ::std::fmt::Display,
        {
            self.embedding = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for embedding: {e}"));
            self
        }
        pub fn grounding_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EvidentiaryGroundingSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.grounding_sla = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for grounding_sla: {e}"));
            self
        }
        pub fn object_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ObjectNodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.object_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for object_node_cid: {e}"));
            self
        }
        pub fn predicate_curie<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PredicateCurie>,
            T::Error: ::std::fmt::Display,
        {
            self.predicate_curie = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for predicate_curie: {e}"));
            self
        }
        pub fn provenance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicProvenanceReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.provenance = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for provenance: {e}"));
            self
        }
        pub fn subject_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SubjectNodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.subject_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for subject_node_cid: {e}"));
            self
        }
        pub fn temporal_bounds<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TemporalBoundsProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_bounds = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for temporal_bounds: {e}"));
            self
        }
        pub fn volumetric_geometry<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VolumetricEdgeProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.volumetric_geometry = value.try_into().map_err(|e| {
                format!("error converting supplied value for volumetric_geometry: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<SemanticEdgeState> for super::SemanticEdgeState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SemanticEdgeState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                belief_vector: value.belief_vector?,
                causal_relationship: value.causal_relationship?,
                edge_cid: value.edge_cid?,
                embedding: value.embedding?,
                grounding_sla: value.grounding_sla?,
                object_node_cid: value.object_node_cid?,
                predicate_curie: value.predicate_curie?,
                provenance: value.provenance?,
                subject_node_cid: value.subject_node_cid?,
                temporal_bounds: value.temporal_bounds?,
                volumetric_geometry: value.volumetric_geometry?,
            })
        }
    }
    impl ::std::convert::From<super::SemanticEdgeState> for SemanticEdgeState {
        fn from(value: super::SemanticEdgeState) -> Self {
            Self {
                belief_vector: Ok(value.belief_vector),
                causal_relationship: Ok(value.causal_relationship),
                edge_cid: Ok(value.edge_cid),
                embedding: Ok(value.embedding),
                grounding_sla: Ok(value.grounding_sla),
                object_node_cid: Ok(value.object_node_cid),
                predicate_curie: Ok(value.predicate_curie),
                provenance: Ok(value.provenance),
                subject_node_cid: Ok(value.subject_node_cid),
                temporal_bounds: Ok(value.temporal_bounds),
                volumetric_geometry: Ok(value.volumetric_geometry),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SemanticFirewallPolicy {
        action_on_violation: ::std::result::Result<super::ActionOnViolation, ::std::string::String>,
        forbidden_intents: ::std::result::Result<
            ::std::vec::Vec<super::ForbiddenIntentsItem>,
            ::std::string::String,
        >,
        max_input_tokens: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for SemanticFirewallPolicy {
        fn default() -> Self {
            Self {
                action_on_violation: Err("no value supplied for action_on_violation".to_string()),
                forbidden_intents: Ok(Default::default()),
                max_input_tokens: Err("no value supplied for max_input_tokens".to_string()),
            }
        }
    }
    impl SemanticFirewallPolicy {
        pub fn action_on_violation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ActionOnViolation>,
            T::Error: ::std::fmt::Display,
        {
            self.action_on_violation = value.try_into().map_err(|e| {
                format!("error converting supplied value for action_on_violation: {e}")
            });
            self
        }
        pub fn forbidden_intents<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ForbiddenIntentsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.forbidden_intents = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for forbidden_intents: {e}"));
            self
        }
        pub fn max_input_tokens<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_input_tokens = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_input_tokens: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SemanticFirewallPolicy> for super::SemanticFirewallPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SemanticFirewallPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                action_on_violation: value.action_on_violation?,
                forbidden_intents: value.forbidden_intents?,
                max_input_tokens: value.max_input_tokens?,
            })
        }
    }
    impl ::std::convert::From<super::SemanticFirewallPolicy> for SemanticFirewallPolicy {
        fn from(value: super::SemanticFirewallPolicy) -> Self {
            Self {
                action_on_violation: Ok(value.action_on_violation),
                forbidden_intents: Ok(value.forbidden_intents),
                max_input_tokens: Ok(value.max_input_tokens),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SemanticFlowPolicy {
        active: ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        latent_firewalls:
            ::std::result::Result<::std::vec::Vec<super::SaeLatentPolicy>, ::std::string::String>,
        policy_cid: ::std::result::Result<super::PolicyCid, ::std::string::String>,
        semantic_firewall: ::std::result::Result<
            ::std::option::Option<super::SemanticFirewallPolicy>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SemanticFlowPolicy {
        fn default() -> Self {
            Self {
                active: Ok(Default::default()),
                latent_firewalls: Ok(Default::default()),
                policy_cid: Err("no value supplied for policy_cid".to_string()),
                semantic_firewall: Ok(Default::default()),
            }
        }
    }
    impl SemanticFlowPolicy {
        pub fn active<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.active = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for active: {e}"));
            self
        }
        pub fn latent_firewalls<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::SaeLatentPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.latent_firewalls = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for latent_firewalls: {e}"));
            self
        }
        pub fn policy_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PolicyCid>,
            T::Error: ::std::fmt::Display,
        {
            self.policy_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for policy_cid: {e}"));
            self
        }
        pub fn semantic_firewall<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFirewallPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_firewall = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_firewall: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SemanticFlowPolicy> for super::SemanticFlowPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SemanticFlowPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                active: value.active?,
                latent_firewalls: value.latent_firewalls?,
                policy_cid: value.policy_cid?,
                semantic_firewall: value.semantic_firewall?,
            })
        }
    }
    impl ::std::convert::From<super::SemanticFlowPolicy> for SemanticFlowPolicy {
        fn from(value: super::SemanticFlowPolicy) -> Self {
            Self {
                active: Ok(value.active),
                latent_firewalls: Ok(value.latent_firewalls),
                policy_cid: Ok(value.policy_cid),
                semantic_firewall: Ok(value.semantic_firewall),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SemanticIntent {
        message: ::std::result::Result<super::Message, ::std::string::String>,
        timeout_action: ::std::result::Result<super::TimeoutAction, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SemanticIntent {
        fn default() -> Self {
            Self {
                message: Err("no value supplied for message".to_string()),
                timeout_action: Err("no value supplied for timeout_action".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl SemanticIntent {
        pub fn message<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Message>,
            T::Error: ::std::fmt::Display,
        {
            self.message = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for message: {e}"));
            self
        }
        pub fn timeout_action<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TimeoutAction>,
            T::Error: ::std::fmt::Display,
        {
            self.timeout_action = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timeout_action: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SemanticIntent> for super::SemanticIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SemanticIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                message: value.message?,
                timeout_action: value.timeout_action?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::SemanticIntent> for SemanticIntent {
        fn from(value: super::SemanticIntent) -> Self {
            Self {
                message: Ok(value.message),
                timeout_action: Ok(value.timeout_action),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SemanticMappingHeuristicIntent {
        formal_logic_clauses:
            ::std::result::Result<super::FormalLogicClauses, ::std::string::String>,
        justification_evidence_cids:
            ::std::result::Result<::std::vec::Vec<super::NodeCidState>, ::std::string::String>,
        proposal_cid: ::std::result::Result<super::ProposalCid, ::std::string::String>,
        source_ontology_namespace:
            ::std::result::Result<super::SourceOntologyNamespace, ::std::string::String>,
        target_ontology_namespace:
            ::std::result::Result<super::TargetOntologyNamespace, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SemanticMappingHeuristicIntent {
        fn default() -> Self {
            Self {
                formal_logic_clauses: Err("no value supplied for formal_logic_clauses".to_string()),
                justification_evidence_cids: Err(
                    "no value supplied for justification_evidence_cids".to_string(),
                ),
                proposal_cid: Err("no value supplied for proposal_cid".to_string()),
                source_ontology_namespace: Err(
                    "no value supplied for source_ontology_namespace".to_string()
                ),
                target_ontology_namespace: Err(
                    "no value supplied for target_ontology_namespace".to_string()
                ),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl SemanticMappingHeuristicIntent {
        pub fn formal_logic_clauses<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FormalLogicClauses>,
            T::Error: ::std::fmt::Display,
        {
            self.formal_logic_clauses = value.try_into().map_err(|e| {
                format!("error converting supplied value for formal_logic_clauses: {e}")
            });
            self
        }
        pub fn justification_evidence_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification_evidence_cids = value.try_into().map_err(|e| {
                format!("error converting supplied value for justification_evidence_cids: {e}")
            });
            self
        }
        pub fn proposal_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProposalCid>,
            T::Error: ::std::fmt::Display,
        {
            self.proposal_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proposal_cid: {e}"));
            self
        }
        pub fn source_ontology_namespace<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceOntologyNamespace>,
            T::Error: ::std::fmt::Display,
        {
            self.source_ontology_namespace = value.try_into().map_err(|e| {
                format!("error converting supplied value for source_ontology_namespace: {e}")
            });
            self
        }
        pub fn target_ontology_namespace<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetOntologyNamespace>,
            T::Error: ::std::fmt::Display,
        {
            self.target_ontology_namespace = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_ontology_namespace: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SemanticMappingHeuristicIntent>
        for super::SemanticMappingHeuristicIntent
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SemanticMappingHeuristicIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                formal_logic_clauses: value.formal_logic_clauses?,
                justification_evidence_cids: value.justification_evidence_cids?,
                proposal_cid: value.proposal_cid?,
                source_ontology_namespace: value.source_ontology_namespace?,
                target_ontology_namespace: value.target_ontology_namespace?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::SemanticMappingHeuristicIntent>
        for SemanticMappingHeuristicIntent
    {
        fn from(value: super::SemanticMappingHeuristicIntent) -> Self {
            Self {
                formal_logic_clauses: Ok(value.formal_logic_clauses),
                justification_evidence_cids: Ok(value.justification_evidence_cids),
                proposal_cid: Ok(value.proposal_cid),
                source_ontology_namespace: Ok(value.source_ontology_namespace),
                target_ontology_namespace: Ok(value.target_ontology_namespace),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SemanticNodeState {
        canonical_uri: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        embedding: ::std::result::Result<
            ::std::option::Option<super::VectorEmbeddingState>,
            ::std::string::String,
        >,
        fhe_profile: ::std::result::Result<
            ::std::option::Option<super::HomomorphicEncryptionProfile>,
            ::std::string::String,
        >,
        label: ::std::result::Result<super::Label, ::std::string::String>,
        node_cid: ::std::result::Result<super::NodeCid, ::std::string::String>,
        provenance: ::std::result::Result<super::EpistemicProvenanceReceipt, ::std::string::String>,
        salience: ::std::result::Result<
            ::std::option::Option<super::SalienceProfile>,
            ::std::string::String,
        >,
        scope: ::std::result::Result<::std::option::Option<super::Scope>, ::std::string::String>,
        spatial_manifold_mappings: ::std::result::Result<
            ::std::vec::Vec<super::ContinuousManifoldMappingContract>,
            ::std::string::String,
        >,
        temporal_bounds: ::std::result::Result<super::TemporalBoundsProfile, ::std::string::String>,
        text_chunk: ::std::result::Result<super::TextChunk, ::std::string::String>,
        tier: ::std::result::Result<
            ::std::option::Option<super::CognitiveTierProfile>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SemanticNodeState {
        fn default() -> Self {
            Self {
                canonical_uri: Ok(Default::default()),
                embedding: Ok(Default::default()),
                fhe_profile: Ok(Default::default()),
                label: Err("no value supplied for label".to_string()),
                node_cid: Err("no value supplied for node_cid".to_string()),
                provenance: Err("no value supplied for provenance".to_string()),
                salience: Ok(Default::default()),
                scope: Ok(Default::default()),
                spatial_manifold_mappings: Ok(Default::default()),
                temporal_bounds: Err("no value supplied for temporal_bounds".to_string()),
                text_chunk: Err("no value supplied for text_chunk".to_string()),
                tier: Ok(Default::default()),
            }
        }
    }
    impl SemanticNodeState {
        pub fn canonical_uri<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.canonical_uri = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for canonical_uri: {e}"));
            self
        }
        pub fn embedding<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VectorEmbeddingState>>,
            T::Error: ::std::fmt::Display,
        {
            self.embedding = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for embedding: {e}"));
            self
        }
        pub fn fhe_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HomomorphicEncryptionProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.fhe_profile = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for fhe_profile: {e}"));
            self
        }
        pub fn label<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Label>,
            T::Error: ::std::fmt::Display,
        {
            self.label = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for label: {e}"));
            self
        }
        pub fn node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for node_cid: {e}"));
            self
        }
        pub fn provenance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EpistemicProvenanceReceipt>,
            T::Error: ::std::fmt::Display,
        {
            self.provenance = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for provenance: {e}"));
            self
        }
        pub fn salience<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SalienceProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.salience = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for salience: {e}"));
            self
        }
        pub fn scope<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::Scope>>,
            T::Error: ::std::fmt::Display,
        {
            self.scope = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for scope: {e}"));
            self
        }
        pub fn spatial_manifold_mappings<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ContinuousManifoldMappingContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.spatial_manifold_mappings = value.try_into().map_err(|e| {
                format!("error converting supplied value for spatial_manifold_mappings: {e}")
            });
            self
        }
        pub fn temporal_bounds<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TemporalBoundsProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_bounds = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for temporal_bounds: {e}"));
            self
        }
        pub fn text_chunk<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TextChunk>,
            T::Error: ::std::fmt::Display,
        {
            self.text_chunk = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for text_chunk: {e}"));
            self
        }
        pub fn tier<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CognitiveTierProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.tier = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for tier: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SemanticNodeState> for super::SemanticNodeState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SemanticNodeState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                canonical_uri: value.canonical_uri?,
                embedding: value.embedding?,
                fhe_profile: value.fhe_profile?,
                label: value.label?,
                node_cid: value.node_cid?,
                provenance: value.provenance?,
                salience: value.salience?,
                scope: value.scope?,
                spatial_manifold_mappings: value.spatial_manifold_mappings?,
                temporal_bounds: value.temporal_bounds?,
                text_chunk: value.text_chunk?,
                tier: value.tier?,
            })
        }
    }
    impl ::std::convert::From<super::SemanticNodeState> for SemanticNodeState {
        fn from(value: super::SemanticNodeState) -> Self {
            Self {
                canonical_uri: Ok(value.canonical_uri),
                embedding: Ok(value.embedding),
                fhe_profile: Ok(value.fhe_profile),
                label: Ok(value.label),
                node_cid: Ok(value.node_cid),
                provenance: Ok(value.provenance),
                salience: Ok(value.salience),
                scope: Ok(value.scope),
                spatial_manifold_mappings: Ok(value.spatial_manifold_mappings),
                temporal_bounds: Ok(value.temporal_bounds),
                text_chunk: Ok(value.text_chunk),
                tier: Ok(value.tier),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SemanticRelationalVectorState {
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        formal_schema_urn: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        multivariate_latent_projection: ::std::result::Result<
            ::std::option::Option<super::VectorEmbeddingState>,
            ::std::string::String,
        >,
        ontology_class:
            ::std::result::Result<super::UpperOntologyClassProfile, ::std::string::String>,
        payload_injection_zone: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        temporal_bounds: ::std::result::Result<super::TemporalBoundsProfile, ::std::string::String>,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SemanticRelationalVectorState {
        fn default() -> Self {
            Self {
                event_cid: Err("no value supplied for event_cid".to_string()),
                formal_schema_urn: Ok(Default::default()),
                multivariate_latent_projection: Ok(Default::default()),
                ontology_class: Err("no value supplied for ontology_class".to_string()),
                payload_injection_zone: Err(
                    "no value supplied for payload_injection_zone".to_string()
                ),
                prior_event_hash: Ok(Default::default()),
                temporal_bounds: Err("no value supplied for temporal_bounds".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl SemanticRelationalVectorState {
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn formal_schema_urn<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.formal_schema_urn = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for formal_schema_urn: {e}"));
            self
        }
        pub fn multivariate_latent_projection<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::VectorEmbeddingState>>,
            T::Error: ::std::fmt::Display,
        {
            self.multivariate_latent_projection = value.try_into().map_err(|e| {
                format!("error converting supplied value for multivariate_latent_projection: {e}")
            });
            self
        }
        pub fn ontology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::UpperOntologyClassProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.ontology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for ontology_class: {e}"));
            self
        }
        pub fn payload_injection_zone<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.payload_injection_zone = value.try_into().map_err(|e| {
                format!("error converting supplied value for payload_injection_zone: {e}")
            });
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn temporal_bounds<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TemporalBoundsProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_bounds = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for temporal_bounds: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SemanticRelationalVectorState>
        for super::SemanticRelationalVectorState
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SemanticRelationalVectorState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                event_cid: value.event_cid?,
                formal_schema_urn: value.formal_schema_urn?,
                multivariate_latent_projection: value.multivariate_latent_projection?,
                ontology_class: value.ontology_class?,
                payload_injection_zone: value.payload_injection_zone?,
                prior_event_hash: value.prior_event_hash?,
                temporal_bounds: value.temporal_bounds?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::SemanticRelationalVectorState> for SemanticRelationalVectorState {
        fn from(value: super::SemanticRelationalVectorState) -> Self {
            Self {
                event_cid: Ok(value.event_cid),
                formal_schema_urn: Ok(value.formal_schema_urn),
                multivariate_latent_projection: Ok(value.multivariate_latent_projection),
                ontology_class: Ok(value.ontology_class),
                payload_injection_zone: Ok(value.payload_injection_zone),
                prior_event_hash: Ok(value.prior_event_hash),
                temporal_bounds: Ok(value.temporal_bounds),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SemanticSlicingPolicy {
        context_window_token_ceiling:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        permitted_classification_tiers: ::std::result::Result<
            ::std::vec::Vec<super::PermittedClassificationTiersItem>,
            ::std::string::String,
        >,
        required_semantic_labels: ::std::result::Result<
            ::std::option::Option<
                ::std::vec::Vec<super::SemanticSlicingPolicyRequiredSemanticLabelsItem>,
            >,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SemanticSlicingPolicy {
        fn default() -> Self {
            Self {
                context_window_token_ceiling: Err(
                    "no value supplied for context_window_token_ceiling".to_string(),
                ),
                permitted_classification_tiers: Err(
                    "no value supplied for permitted_classification_tiers".to_string(),
                ),
                required_semantic_labels: Ok(Default::default()),
            }
        }
    }
    impl SemanticSlicingPolicy {
        pub fn context_window_token_ceiling<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.context_window_token_ceiling = value.try_into().map_err(|e| {
                format!("error converting supplied value for context_window_token_ceiling: {e}")
            });
            self
        }
        pub fn permitted_classification_tiers<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::PermittedClassificationTiersItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.permitted_classification_tiers = value.try_into().map_err(|e| {
                format!("error converting supplied value for permitted_classification_tiers: {e}")
            });
            self
        }
        pub fn required_semantic_labels<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::vec::Vec<super::SemanticSlicingPolicyRequiredSemanticLabelsItem>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.required_semantic_labels = value.try_into().map_err(|e| {
                format!("error converting supplied value for required_semantic_labels: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<SemanticSlicingPolicy> for super::SemanticSlicingPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SemanticSlicingPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                context_window_token_ceiling: value.context_window_token_ceiling?,
                permitted_classification_tiers: value.permitted_classification_tiers?,
                required_semantic_labels: value.required_semantic_labels?,
            })
        }
    }
    impl ::std::convert::From<super::SemanticSlicingPolicy> for SemanticSlicingPolicy {
        fn from(value: super::SemanticSlicingPolicy) -> Self {
            Self {
                context_window_token_ceiling: Ok(value.context_window_token_ceiling),
                permitted_classification_tiers: Ok(value.permitted_classification_tiers),
                required_semantic_labels: Ok(value.required_semantic_labels),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SemanticZoomProfile {
        macro_distance_threshold: ::std::result::Result<f64, ::std::string::String>,
        meso_distance_threshold: ::std::result::Result<f64, ::std::string::String>,
        micro_distance_threshold: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for SemanticZoomProfile {
        fn default() -> Self {
            Self {
                macro_distance_threshold: Err(
                    "no value supplied for macro_distance_threshold".to_string()
                ),
                meso_distance_threshold: Err(
                    "no value supplied for meso_distance_threshold".to_string()
                ),
                micro_distance_threshold: Err(
                    "no value supplied for micro_distance_threshold".to_string()
                ),
            }
        }
    }
    impl SemanticZoomProfile {
        pub fn macro_distance_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.macro_distance_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for macro_distance_threshold: {e}")
            });
            self
        }
        pub fn meso_distance_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.meso_distance_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for meso_distance_threshold: {e}")
            });
            self
        }
        pub fn micro_distance_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.micro_distance_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for micro_distance_threshold: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<SemanticZoomProfile> for super::SemanticZoomProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SemanticZoomProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                macro_distance_threshold: value.macro_distance_threshold?,
                meso_distance_threshold: value.meso_distance_threshold?,
                micro_distance_threshold: value.micro_distance_threshold?,
            })
        }
    }
    impl ::std::convert::From<super::SemanticZoomProfile> for SemanticZoomProfile {
        fn from(value: super::SemanticZoomProfile) -> Self {
            Self {
                macro_distance_threshold: Ok(value.macro_distance_threshold),
                meso_distance_threshold: Ok(value.meso_distance_threshold),
                micro_distance_threshold: Ok(value.micro_distance_threshold),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ShaclValidationSla {
        shacl_shape_graph_uri: ::std::result::Result<::std::string::String, ::std::string::String>,
        violation_action: ::std::result::Result<super::ViolationAction, ::std::string::String>,
    }
    impl ::std::default::Default for ShaclValidationSla {
        fn default() -> Self {
            Self {
                shacl_shape_graph_uri: Err(
                    "no value supplied for shacl_shape_graph_uri".to_string()
                ),
                violation_action: Err("no value supplied for violation_action".to_string()),
            }
        }
    }
    impl ShaclValidationSla {
        pub fn shacl_shape_graph_uri<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.shacl_shape_graph_uri = value.try_into().map_err(|e| {
                format!("error converting supplied value for shacl_shape_graph_uri: {e}")
            });
            self
        }
        pub fn violation_action<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ViolationAction>,
            T::Error: ::std::fmt::Display,
        {
            self.violation_action = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for violation_action: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ShaclValidationSla> for super::ShaclValidationSla {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ShaclValidationSla,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                shacl_shape_graph_uri: value.shacl_shape_graph_uri?,
                violation_action: value.violation_action?,
            })
        }
    }
    impl ::std::convert::From<super::ShaclValidationSla> for ShaclValidationSla {
        fn from(value: super::ShaclValidationSla) -> Self {
            Self {
                shacl_shape_graph_uri: Ok(value.shacl_shape_graph_uri),
                violation_action: Ok(value.violation_action),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ShapleyAttributionReceipt {
        causal_attribution_score: ::std::result::Result<f64, ::std::string::String>,
        confidence_interval_lower: ::std::result::Result<f64, ::std::string::String>,
        confidence_interval_upper: ::std::result::Result<f64, ::std::string::String>,
        normalized_contribution_percentage: ::std::result::Result<f64, ::std::string::String>,
        target_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
    }
    impl ::std::default::Default for ShapleyAttributionReceipt {
        fn default() -> Self {
            Self {
                causal_attribution_score: Err(
                    "no value supplied for causal_attribution_score".to_string()
                ),
                confidence_interval_lower: Err(
                    "no value supplied for confidence_interval_lower".to_string()
                ),
                confidence_interval_upper: Err(
                    "no value supplied for confidence_interval_upper".to_string()
                ),
                normalized_contribution_percentage: Err(
                    "no value supplied for normalized_contribution_percentage".to_string(),
                ),
                target_node_cid: Err("no value supplied for target_node_cid".to_string()),
            }
        }
    }
    impl ShapleyAttributionReceipt {
        pub fn causal_attribution_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_attribution_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for causal_attribution_score: {e}")
            });
            self
        }
        pub fn confidence_interval_lower<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.confidence_interval_lower = value.try_into().map_err(|e| {
                format!("error converting supplied value for confidence_interval_lower: {e}")
            });
            self
        }
        pub fn confidence_interval_upper<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.confidence_interval_upper = value.try_into().map_err(|e| {
                format!("error converting supplied value for confidence_interval_upper: {e}")
            });
            self
        }
        pub fn normalized_contribution_percentage<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.normalized_contribution_percentage = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for normalized_contribution_percentage: {e}"
                )
            });
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ShapleyAttributionReceipt> for super::ShapleyAttributionReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ShapleyAttributionReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                causal_attribution_score: value.causal_attribution_score?,
                confidence_interval_lower: value.confidence_interval_lower?,
                confidence_interval_upper: value.confidence_interval_upper?,
                normalized_contribution_percentage: value.normalized_contribution_percentage?,
                target_node_cid: value.target_node_cid?,
            })
        }
    }
    impl ::std::convert::From<super::ShapleyAttributionReceipt> for ShapleyAttributionReceipt {
        fn from(value: super::ShapleyAttributionReceipt) -> Self {
            Self {
                causal_attribution_score: Ok(value.causal_attribution_score),
                confidence_interval_lower: Ok(value.confidence_interval_lower),
                confidence_interval_upper: Ok(value.confidence_interval_upper),
                normalized_contribution_percentage: Ok(value.normalized_contribution_percentage),
                target_node_cid: Ok(value.target_node_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SideEffectProfile {
        is_idempotent: ::std::result::Result<bool, ::std::string::String>,
        mutates_state: ::std::result::Result<bool, ::std::string::String>,
    }
    impl ::std::default::Default for SideEffectProfile {
        fn default() -> Self {
            Self {
                is_idempotent: Err("no value supplied for is_idempotent".to_string()),
                mutates_state: Err("no value supplied for mutates_state".to_string()),
            }
        }
    }
    impl SideEffectProfile {
        pub fn is_idempotent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.is_idempotent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for is_idempotent: {e}"));
            self
        }
        pub fn mutates_state<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.mutates_state = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for mutates_state: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SideEffectProfile> for super::SideEffectProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SideEffectProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                is_idempotent: value.is_idempotent?,
                mutates_state: value.mutates_state?,
            })
        }
    }
    impl ::std::convert::From<super::SideEffectProfile> for SideEffectProfile {
        fn from(value: super::SideEffectProfile) -> Self {
            Self {
                is_idempotent: Ok(value.is_idempotent),
                mutates_state: Ok(value.mutates_state),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SimulationConvergenceSla {
        max_monte_carlo_rollouts:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        variance_tolerance: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for SimulationConvergenceSla {
        fn default() -> Self {
            Self {
                max_monte_carlo_rollouts: Err(
                    "no value supplied for max_monte_carlo_rollouts".to_string()
                ),
                variance_tolerance: Err("no value supplied for variance_tolerance".to_string()),
            }
        }
    }
    impl SimulationConvergenceSla {
        pub fn max_monte_carlo_rollouts<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_monte_carlo_rollouts = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_monte_carlo_rollouts: {e}")
            });
            self
        }
        pub fn variance_tolerance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.variance_tolerance = value.try_into().map_err(|e| {
                format!("error converting supplied value for variance_tolerance: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<SimulationConvergenceSla> for super::SimulationConvergenceSla {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SimulationConvergenceSla,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_monte_carlo_rollouts: value.max_monte_carlo_rollouts?,
                variance_tolerance: value.variance_tolerance?,
            })
        }
    }
    impl ::std::convert::From<super::SimulationConvergenceSla> for SimulationConvergenceSla {
        fn from(value: super::SimulationConvergenceSla) -> Self {
            Self {
                max_monte_carlo_rollouts: Ok(value.max_monte_carlo_rollouts),
                variance_tolerance: Ok(value.variance_tolerance),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SimulationEscrowContract {
        locked_magnitude: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for SimulationEscrowContract {
        fn default() -> Self {
            Self {
                locked_magnitude: Err("no value supplied for locked_magnitude".to_string()),
            }
        }
    }
    impl SimulationEscrowContract {
        pub fn locked_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.locked_magnitude = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for locked_magnitude: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SimulationEscrowContract> for super::SimulationEscrowContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SimulationEscrowContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                locked_magnitude: value.locked_magnitude?,
            })
        }
    }
    impl ::std::convert::From<super::SimulationEscrowContract> for SimulationEscrowContract {
        fn from(value: super::SimulationEscrowContract) -> Self {
            Self {
                locked_magnitude: Ok(value.locked_magnitude),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SmpcTopologyManifest {
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        epistemic_enforcement: ::std::result::Result<
            ::std::option::Option<super::TruthMaintenancePolicy>,
            ::std::string::String,
        >,
        joint_function_uri: ::std::result::Result<super::JointFunctionUri, ::std::string::String>,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        lifecycle_phase: ::std::result::Result<
            ::std::option::Option<super::LifecyclePhase>,
            ::std::string::String,
        >,
        nodes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            ::std::string::String,
        >,
        observability: ::std::result::Result<
            ::std::option::Option<super::ObservabilityLodPolicy>,
            ::std::string::String,
        >,
        ontological_alignment: ::std::result::Result<
            ::std::option::Option<super::OntologicalAlignmentPolicy>,
            ::std::string::String,
        >,
        participant_node_cids: ::std::result::Result<
            ::std::vec::Vec<super::ParticipantNodeCidsItem>,
            ::std::string::String,
        >,
        semantic_flow: ::std::result::Result<
            ::std::option::Option<super::SemanticFlowPolicy>,
            ::std::string::String,
        >,
        shared_state_contract: ::std::result::Result<
            ::std::option::Option<super::StateContract>,
            ::std::string::String,
        >,
        smpc_protocol: ::std::result::Result<super::SmpcProtocol, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SmpcTopologyManifest {
        fn default() -> Self {
            Self {
                architectural_intent: Ok(Default::default()),
                epistemic_enforcement: Ok(Default::default()),
                joint_function_uri: Err("no value supplied for joint_function_uri".to_string()),
                justification: Ok(Default::default()),
                lifecycle_phase: Ok(Default::default()),
                nodes: Err("no value supplied for nodes".to_string()),
                observability: Ok(Default::default()),
                ontological_alignment: Ok(Default::default()),
                participant_node_cids: Err(
                    "no value supplied for participant_node_cids".to_string()
                ),
                semantic_flow: Ok(Default::default()),
                shared_state_contract: Ok(Default::default()),
                smpc_protocol: Err("no value supplied for smpc_protocol".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl SmpcTopologyManifest {
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn epistemic_enforcement<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TruthMaintenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_enforcement = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_enforcement: {e}")
            });
            self
        }
        pub fn joint_function_uri<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::JointFunctionUri>,
            T::Error: ::std::fmt::Display,
        {
            self.joint_function_uri = value.try_into().map_err(|e| {
                format!("error converting supplied value for joint_function_uri: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn lifecycle_phase<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LifecyclePhase>>,
            T::Error: ::std::fmt::Display,
        {
            self.lifecycle_phase = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lifecycle_phase: {e}"));
            self
        }
        pub fn nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for nodes: {e}"));
            self
        }
        pub fn observability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ObservabilityLodPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.observability = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for observability: {e}"));
            self
        }
        pub fn ontological_alignment<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::OntologicalAlignmentPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.ontological_alignment = value.try_into().map_err(|e| {
                format!("error converting supplied value for ontological_alignment: {e}")
            });
            self
        }
        pub fn participant_node_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ParticipantNodeCidsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.participant_node_cids = value.try_into().map_err(|e| {
                format!("error converting supplied value for participant_node_cids: {e}")
            });
            self
        }
        pub fn semantic_flow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFlowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_flow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_flow: {e}"));
            self
        }
        pub fn shared_state_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.shared_state_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for shared_state_contract: {e}")
            });
            self
        }
        pub fn smpc_protocol<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SmpcProtocol>,
            T::Error: ::std::fmt::Display,
        {
            self.smpc_protocol = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for smpc_protocol: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SmpcTopologyManifest> for super::SmpcTopologyManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SmpcTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                architectural_intent: value.architectural_intent?,
                epistemic_enforcement: value.epistemic_enforcement?,
                joint_function_uri: value.joint_function_uri?,
                justification: value.justification?,
                lifecycle_phase: value.lifecycle_phase?,
                nodes: value.nodes?,
                observability: value.observability?,
                ontological_alignment: value.ontological_alignment?,
                participant_node_cids: value.participant_node_cids?,
                semantic_flow: value.semantic_flow?,
                shared_state_contract: value.shared_state_contract?,
                smpc_protocol: value.smpc_protocol?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::SmpcTopologyManifest> for SmpcTopologyManifest {
        fn from(value: super::SmpcTopologyManifest) -> Self {
            Self {
                architectural_intent: Ok(value.architectural_intent),
                epistemic_enforcement: Ok(value.epistemic_enforcement),
                joint_function_uri: Ok(value.joint_function_uri),
                justification: Ok(value.justification),
                lifecycle_phase: Ok(value.lifecycle_phase),
                nodes: Ok(value.nodes),
                observability: Ok(value.observability),
                ontological_alignment: Ok(value.ontological_alignment),
                participant_node_cids: Ok(value.participant_node_cids),
                semantic_flow: Ok(value.semantic_flow),
                shared_state_contract: Ok(value.shared_state_contract),
                smpc_protocol: Ok(value.smpc_protocol),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SparqlQueryIntent {
        query_string: ::std::result::Result<::std::string::String, ::std::string::String>,
        target_endpoint: ::std::result::Result<::std::string::String, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SparqlQueryIntent {
        fn default() -> Self {
            Self {
                query_string: Err("no value supplied for query_string".to_string()),
                target_endpoint: Err("no value supplied for target_endpoint".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl SparqlQueryIntent {
        pub fn query_string<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.query_string = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for query_string: {e}"));
            self
        }
        pub fn target_endpoint<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.target_endpoint = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_endpoint: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SparqlQueryIntent> for super::SparqlQueryIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SparqlQueryIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                query_string: value.query_string?,
                target_endpoint: value.target_endpoint?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::SparqlQueryIntent> for SparqlQueryIntent {
        fn from(value: super::SparqlQueryIntent) -> Self {
            Self {
                query_string: Ok(value.query_string),
                target_endpoint: Ok(value.target_endpoint),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SparqlQueryResultReceipt {
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        execution_time_ms: ::std::result::Result<u64, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        query_intent_cid: ::std::result::Result<super::QueryIntentCid, ::std::string::String>,
        returned_bindings: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SparqlQueryResultReceipt {
        fn default() -> Self {
            Self {
                event_cid: Err("no value supplied for event_cid".to_string()),
                execution_time_ms: Err("no value supplied for execution_time_ms".to_string()),
                prior_event_hash: Ok(Default::default()),
                query_intent_cid: Err("no value supplied for query_intent_cid".to_string()),
                returned_bindings: Err("no value supplied for returned_bindings".to_string()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl SparqlQueryResultReceipt {
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn execution_time_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.execution_time_ms = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for execution_time_ms: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn query_intent_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::QueryIntentCid>,
            T::Error: ::std::fmt::Display,
        {
            self.query_intent_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for query_intent_cid: {e}"));
            self
        }
        pub fn returned_bindings<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.returned_bindings = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for returned_bindings: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SparqlQueryResultReceipt> for super::SparqlQueryResultReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SparqlQueryResultReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                event_cid: value.event_cid?,
                execution_time_ms: value.execution_time_ms?,
                prior_event_hash: value.prior_event_hash?,
                query_intent_cid: value.query_intent_cid?,
                returned_bindings: value.returned_bindings?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::SparqlQueryResultReceipt> for SparqlQueryResultReceipt {
        fn from(value: super::SparqlQueryResultReceipt) -> Self {
            Self {
                event_cid: Ok(value.event_cid),
                execution_time_ms: Ok(value.execution_time_ms),
                prior_event_hash: Ok(value.prior_event_hash),
                query_intent_cid: Ok(value.query_intent_cid),
                returned_bindings: Ok(value.returned_bindings),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SpatialBillboardContract {
        always_face_camera:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        anchoring_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        distance_scaling_factor:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        occlude_behind_meshes:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        spherical_cylindrical_lock: ::std::result::Result<
            ::std::option::Option<super::SphericalCylindricalLock>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SpatialBillboardContract {
        fn default() -> Self {
            Self {
                always_face_camera: Ok(Default::default()),
                anchoring_node_cid: Err("no value supplied for anchoring_node_cid".to_string()),
                distance_scaling_factor: Ok(Default::default()),
                occlude_behind_meshes: Ok(Default::default()),
                spherical_cylindrical_lock: Ok(Default::default()),
            }
        }
    }
    impl SpatialBillboardContract {
        pub fn always_face_camera<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.always_face_camera = value.try_into().map_err(|e| {
                format!("error converting supplied value for always_face_camera: {e}")
            });
            self
        }
        pub fn anchoring_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.anchoring_node_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for anchoring_node_cid: {e}")
            });
            self
        }
        pub fn distance_scaling_factor<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.distance_scaling_factor = value.try_into().map_err(|e| {
                format!("error converting supplied value for distance_scaling_factor: {e}")
            });
            self
        }
        pub fn occlude_behind_meshes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.occlude_behind_meshes = value.try_into().map_err(|e| {
                format!("error converting supplied value for occlude_behind_meshes: {e}")
            });
            self
        }
        pub fn spherical_cylindrical_lock<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SphericalCylindricalLock>>,
            T::Error: ::std::fmt::Display,
        {
            self.spherical_cylindrical_lock = value.try_into().map_err(|e| {
                format!("error converting supplied value for spherical_cylindrical_lock: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<SpatialBillboardContract> for super::SpatialBillboardContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SpatialBillboardContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                always_face_camera: value.always_face_camera?,
                anchoring_node_cid: value.anchoring_node_cid?,
                distance_scaling_factor: value.distance_scaling_factor?,
                occlude_behind_meshes: value.occlude_behind_meshes?,
                spherical_cylindrical_lock: value.spherical_cylindrical_lock?,
            })
        }
    }
    impl ::std::convert::From<super::SpatialBillboardContract> for SpatialBillboardContract {
        fn from(value: super::SpatialBillboardContract) -> Self {
            Self {
                always_face_camera: Ok(value.always_face_camera),
                anchoring_node_cid: Ok(value.anchoring_node_cid),
                distance_scaling_factor: Ok(value.distance_scaling_factor),
                occlude_behind_meshes: Ok(value.occlude_behind_meshes),
                spherical_cylindrical_lock: Ok(value.spherical_cylindrical_lock),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SpatialHardwareProfile {
        accelerator_type: ::std::result::Result<
            ::std::option::Option<super::AcceleratorType>,
            ::std::string::String,
        >,
        compute_tier:
            ::std::result::Result<::std::option::Option<super::ComputeTier>, ::std::string::String>,
        coreason_network_mode: ::std::result::Result<
            ::std::option::Option<super::CoreasonNetworkMode>,
            ::std::string::String,
        >,
        min_vram_gb: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        provider_whitelist: ::std::result::Result<
            ::std::vec::Vec<super::ProviderWhitelistItem>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SpatialHardwareProfile {
        fn default() -> Self {
            Self {
                accelerator_type: Ok(Default::default()),
                compute_tier: Ok(Default::default()),
                coreason_network_mode: Ok(Default::default()),
                min_vram_gb: Ok(Default::default()),
                provider_whitelist: Ok(Default::default()),
            }
        }
    }
    impl SpatialHardwareProfile {
        pub fn accelerator_type<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AcceleratorType>>,
            T::Error: ::std::fmt::Display,
        {
            self.accelerator_type = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for accelerator_type: {e}"));
            self
        }
        pub fn compute_tier<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ComputeTier>>,
            T::Error: ::std::fmt::Display,
        {
            self.compute_tier = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for compute_tier: {e}"));
            self
        }
        pub fn coreason_network_mode<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CoreasonNetworkMode>>,
            T::Error: ::std::fmt::Display,
        {
            self.coreason_network_mode = value.try_into().map_err(|e| {
                format!("error converting supplied value for coreason_network_mode: {e}")
            });
            self
        }
        pub fn min_vram_gb<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.min_vram_gb = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for min_vram_gb: {e}"));
            self
        }
        pub fn provider_whitelist<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ProviderWhitelistItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.provider_whitelist = value.try_into().map_err(|e| {
                format!("error converting supplied value for provider_whitelist: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<SpatialHardwareProfile> for super::SpatialHardwareProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SpatialHardwareProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                accelerator_type: value.accelerator_type?,
                compute_tier: value.compute_tier?,
                coreason_network_mode: value.coreason_network_mode?,
                min_vram_gb: value.min_vram_gb?,
                provider_whitelist: value.provider_whitelist?,
            })
        }
    }
    impl ::std::convert::From<super::SpatialHardwareProfile> for SpatialHardwareProfile {
        fn from(value: super::SpatialHardwareProfile) -> Self {
            Self {
                accelerator_type: Ok(value.accelerator_type),
                compute_tier: Ok(value.compute_tier),
                coreason_network_mode: Ok(value.coreason_network_mode),
                min_vram_gb: Ok(value.min_vram_gb),
                provider_whitelist: Ok(value.provider_whitelist),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SpatialKinematicActionIntent {
        action_class: ::std::result::Result<super::ActionClass, ::std::string::String>,
        bezier_control_points: ::std::result::Result<
            ::std::vec::Vec<super::Se3TransformProfile>,
            ::std::string::String,
        >,
        expected_visual_concept: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        target_coordinate: ::std::result::Result<
            ::std::option::Option<super::Se3TransformProfile>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        trajectory_duration_ms: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SpatialKinematicActionIntent {
        fn default() -> Self {
            Self {
                action_class: Err("no value supplied for action_class".to_string()),
                bezier_control_points: Ok(Default::default()),
                expected_visual_concept: Ok(Default::default()),
                target_coordinate: Ok(Default::default()),
                topology_class: Ok(Default::default()),
                trajectory_duration_ms: Ok(Default::default()),
            }
        }
    }
    impl SpatialKinematicActionIntent {
        pub fn action_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ActionClass>,
            T::Error: ::std::fmt::Display,
        {
            self.action_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for action_class: {e}"));
            self
        }
        pub fn bezier_control_points<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::Se3TransformProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.bezier_control_points = value.try_into().map_err(|e| {
                format!("error converting supplied value for bezier_control_points: {e}")
            });
            self
        }
        pub fn expected_visual_concept<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.expected_visual_concept = value.try_into().map_err(|e| {
                format!("error converting supplied value for expected_visual_concept: {e}")
            });
            self
        }
        pub fn target_coordinate<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::Se3TransformProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.target_coordinate = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_coordinate: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn trajectory_duration_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.trajectory_duration_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for trajectory_duration_ms: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<SpatialKinematicActionIntent> for super::SpatialKinematicActionIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SpatialKinematicActionIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                action_class: value.action_class?,
                bezier_control_points: value.bezier_control_points?,
                expected_visual_concept: value.expected_visual_concept?,
                target_coordinate: value.target_coordinate?,
                topology_class: value.topology_class?,
                trajectory_duration_ms: value.trajectory_duration_ms?,
            })
        }
    }
    impl ::std::convert::From<super::SpatialKinematicActionIntent> for SpatialKinematicActionIntent {
        fn from(value: super::SpatialKinematicActionIntent) -> Self {
            Self {
                action_class: Ok(value.action_class),
                bezier_control_points: Ok(value.bezier_control_points),
                expected_visual_concept: Ok(value.expected_visual_concept),
                target_coordinate: Ok(value.target_coordinate),
                topology_class: Ok(value.topology_class),
                trajectory_duration_ms: Ok(value.trajectory_duration_ms),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SpatialReferenceFrameManifest {
        anchor_protocol: ::std::result::Result<super::AnchorProtocol, ::std::string::String>,
        frame_cid: ::std::result::Result<super::FrameCid, ::std::string::String>,
        physical_room_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SpatialReferenceFrameManifest {
        fn default() -> Self {
            Self {
                anchor_protocol: Err("no value supplied for anchor_protocol".to_string()),
                frame_cid: Err("no value supplied for frame_cid".to_string()),
                physical_room_hash: Ok(Default::default()),
            }
        }
    }
    impl SpatialReferenceFrameManifest {
        pub fn anchor_protocol<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AnchorProtocol>,
            T::Error: ::std::fmt::Display,
        {
            self.anchor_protocol = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for anchor_protocol: {e}"));
            self
        }
        pub fn frame_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FrameCid>,
            T::Error: ::std::fmt::Display,
        {
            self.frame_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for frame_cid: {e}"));
            self
        }
        pub fn physical_room_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.physical_room_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for physical_room_hash: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<SpatialReferenceFrameManifest>
        for super::SpatialReferenceFrameManifest
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SpatialReferenceFrameManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                anchor_protocol: value.anchor_protocol?,
                frame_cid: value.frame_cid?,
                physical_room_hash: value.physical_room_hash?,
            })
        }
    }
    impl ::std::convert::From<super::SpatialReferenceFrameManifest> for SpatialReferenceFrameManifest {
        fn from(value: super::SpatialReferenceFrameManifest) -> Self {
            Self {
                anchor_protocol: Ok(value.anchor_protocol),
                frame_cid: Ok(value.frame_cid),
                physical_room_hash: Ok(value.physical_room_hash),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SpatialRenderMaterial {
        compiled_shader_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        material_urn: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SpatialRenderMaterial {
        fn default() -> Self {
            Self {
                compiled_shader_cid: Ok(Default::default()),
                material_urn: Ok(Default::default()),
            }
        }
    }
    impl SpatialRenderMaterial {
        pub fn compiled_shader_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.compiled_shader_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for compiled_shader_cid: {e}")
            });
            self
        }
        pub fn material_urn<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.material_urn = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for material_urn: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SpatialRenderMaterial> for super::SpatialRenderMaterial {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SpatialRenderMaterial,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                compiled_shader_cid: value.compiled_shader_cid?,
                material_urn: value.material_urn?,
            })
        }
    }
    impl ::std::convert::From<super::SpatialRenderMaterial> for SpatialRenderMaterial {
        fn from(value: super::SpatialRenderMaterial) -> Self {
            Self {
                compiled_shader_cid: Ok(value.compiled_shader_cid),
                material_urn: Ok(value.material_urn),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SpatialToolManifest {
        asymptotic_complexity: ::std::result::Result<
            ::std::option::Option<super::AsymptoticComplexityReceipt>,
            ::std::string::String,
        >,
        description: ::std::result::Result<super::Description, ::std::string::String>,
        hoare_proof: ::std::result::Result<
            ::std::option::Option<super::HoareLogicProofReceipt>,
            ::std::string::String,
        >,
        input_schema: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        is_preemptible: ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        output_schema: ::std::result::Result<
            ::std::option::Option<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            ::std::string::String,
        >,
        permissions: ::std::result::Result<super::PermissionBoundaryPolicy, ::std::string::String>,
        side_effects: ::std::result::Result<super::SideEffectProfile, ::std::string::String>,
        sla: ::std::result::Result<
            ::std::option::Option<super::ExecutionSla>,
            ::std::string::String,
        >,
        tool_name: ::std::result::Result<super::ToolName, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SpatialToolManifest {
        fn default() -> Self {
            Self {
                asymptotic_complexity: Ok(Default::default()),
                description: Err("no value supplied for description".to_string()),
                hoare_proof: Ok(Default::default()),
                input_schema: Err("no value supplied for input_schema".to_string()),
                is_preemptible: Ok(Default::default()),
                output_schema: Ok(Default::default()),
                permissions: Err("no value supplied for permissions".to_string()),
                side_effects: Err("no value supplied for side_effects".to_string()),
                sla: Ok(Default::default()),
                tool_name: Err("no value supplied for tool_name".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl SpatialToolManifest {
        pub fn asymptotic_complexity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AsymptoticComplexityReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.asymptotic_complexity = value.try_into().map_err(|e| {
                format!("error converting supplied value for asymptotic_complexity: {e}")
            });
            self
        }
        pub fn description<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Description>,
            T::Error: ::std::fmt::Display,
        {
            self.description = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for description: {e}"));
            self
        }
        pub fn hoare_proof<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HoareLogicProofReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.hoare_proof = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for hoare_proof: {e}"));
            self
        }
        pub fn input_schema<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.input_schema = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for input_schema: {e}"));
            self
        }
        pub fn is_preemptible<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.is_preemptible = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for is_preemptible: {e}"));
            self
        }
        pub fn output_schema<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.output_schema = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for output_schema: {e}"));
            self
        }
        pub fn permissions<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PermissionBoundaryPolicy>,
            T::Error: ::std::fmt::Display,
        {
            self.permissions = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for permissions: {e}"));
            self
        }
        pub fn side_effects<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SideEffectProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.side_effects = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for side_effects: {e}"));
            self
        }
        pub fn sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ExecutionSla>>,
            T::Error: ::std::fmt::Display,
        {
            self.sla = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for sla: {e}"));
            self
        }
        pub fn tool_name<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ToolName>,
            T::Error: ::std::fmt::Display,
        {
            self.tool_name = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for tool_name: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SpatialToolManifest> for super::SpatialToolManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SpatialToolManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                asymptotic_complexity: value.asymptotic_complexity?,
                description: value.description?,
                hoare_proof: value.hoare_proof?,
                input_schema: value.input_schema?,
                is_preemptible: value.is_preemptible?,
                output_schema: value.output_schema?,
                permissions: value.permissions?,
                side_effects: value.side_effects?,
                sla: value.sla?,
                tool_name: value.tool_name?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::SpatialToolManifest> for SpatialToolManifest {
        fn from(value: super::SpatialToolManifest) -> Self {
            Self {
                asymptotic_complexity: Ok(value.asymptotic_complexity),
                description: Ok(value.description),
                hoare_proof: Ok(value.hoare_proof),
                input_schema: Ok(value.input_schema),
                is_preemptible: Ok(value.is_preemptible),
                output_schema: Ok(value.output_schema),
                permissions: Ok(value.permissions),
                side_effects: Ok(value.side_effects),
                sla: Ok(value.sla),
                tool_name: Ok(value.tool_name),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SpeculativeExecutionPolicy {
        boundary_cid: ::std::result::Result<super::BoundaryCid, ::std::string::String>,
        commit_probability: ::std::result::Result<f64, ::std::string::String>,
        competing_hypotheses: ::std::result::Result<
            ::std::vec::Vec<super::CompetingHypothesesItem>,
            ::std::string::String,
        >,
        is_speculative: ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        rollback_pointers: ::std::result::Result<
            ::std::vec::Vec<super::RollbackPointersItem>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SpeculativeExecutionPolicy {
        fn default() -> Self {
            Self {
                boundary_cid: Err("no value supplied for boundary_cid".to_string()),
                commit_probability: Err("no value supplied for commit_probability".to_string()),
                competing_hypotheses: Ok(Default::default()),
                is_speculative: Ok(Default::default()),
                rollback_pointers: Ok(Default::default()),
            }
        }
    }
    impl SpeculativeExecutionPolicy {
        pub fn boundary_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::BoundaryCid>,
            T::Error: ::std::fmt::Display,
        {
            self.boundary_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for boundary_cid: {e}"));
            self
        }
        pub fn commit_probability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.commit_probability = value.try_into().map_err(|e| {
                format!("error converting supplied value for commit_probability: {e}")
            });
            self
        }
        pub fn competing_hypotheses<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::CompetingHypothesesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.competing_hypotheses = value.try_into().map_err(|e| {
                format!("error converting supplied value for competing_hypotheses: {e}")
            });
            self
        }
        pub fn is_speculative<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.is_speculative = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for is_speculative: {e}"));
            self
        }
        pub fn rollback_pointers<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::RollbackPointersItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.rollback_pointers = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for rollback_pointers: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SpeculativeExecutionPolicy> for super::SpeculativeExecutionPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SpeculativeExecutionPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                boundary_cid: value.boundary_cid?,
                commit_probability: value.commit_probability?,
                competing_hypotheses: value.competing_hypotheses?,
                is_speculative: value.is_speculative?,
                rollback_pointers: value.rollback_pointers?,
            })
        }
    }
    impl ::std::convert::From<super::SpeculativeExecutionPolicy> for SpeculativeExecutionPolicy {
        fn from(value: super::SpeculativeExecutionPolicy) -> Self {
            Self {
                boundary_cid: Ok(value.boundary_cid),
                commit_probability: Ok(value.commit_probability),
                competing_hypotheses: Ok(value.competing_hypotheses),
                is_speculative: Ok(value.is_speculative),
                rollback_pointers: Ok(value.rollback_pointers),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SseTransportProfile {
        headers: ::std::result::Result<
            ::std::collections::HashMap<
                ::std::string::String,
                super::SseTransportProfileHeadersValue,
            >,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        uri: ::std::result::Result<::std::string::String, ::std::string::String>,
    }
    impl ::std::default::Default for SseTransportProfile {
        fn default() -> Self {
            Self {
                headers: Ok(Default::default()),
                topology_class: Ok(Default::default()),
                uri: Err("no value supplied for uri".to_string()),
            }
        }
    }
    impl SseTransportProfile {
        pub fn headers<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::SseTransportProfileHeadersValue,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.headers = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for headers: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn uri<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::string::String>,
            T::Error: ::std::fmt::Display,
        {
            self.uri = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for uri: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SseTransportProfile> for super::SseTransportProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SseTransportProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                headers: value.headers?,
                topology_class: value.topology_class?,
                uri: value.uri?,
            })
        }
    }
    impl ::std::convert::From<super::SseTransportProfile> for SseTransportProfile {
        fn from(value: super::SseTransportProfile) -> Self {
            Self {
                headers: Ok(value.headers),
                topology_class: Ok(value.topology_class),
                uri: Ok(value.uri),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct StateContract {
        decoding_policy: ::std::result::Result<
            ::std::option::Option<super::ConstrainedDecodingPolicy>,
            ::std::string::String,
        >,
        formal_schema_urn: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        schema_definition: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        strict_validation:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
    }
    impl ::std::default::Default for StateContract {
        fn default() -> Self {
            Self {
                decoding_policy: Ok(Default::default()),
                formal_schema_urn: Ok(Default::default()),
                schema_definition: Err("no value supplied for schema_definition".to_string()),
                strict_validation: Ok(Default::default()),
            }
        }
    }
    impl StateContract {
        pub fn decoding_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ConstrainedDecodingPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.decoding_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for decoding_policy: {e}"));
            self
        }
        pub fn formal_schema_urn<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.formal_schema_urn = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for formal_schema_urn: {e}"));
            self
        }
        pub fn schema_definition<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.schema_definition = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for schema_definition: {e}"));
            self
        }
        pub fn strict_validation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.strict_validation = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for strict_validation: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<StateContract> for super::StateContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: StateContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                decoding_policy: value.decoding_policy?,
                formal_schema_urn: value.formal_schema_urn?,
                schema_definition: value.schema_definition?,
                strict_validation: value.strict_validation?,
            })
        }
    }
    impl ::std::convert::From<super::StateContract> for StateContract {
        fn from(value: super::StateContract) -> Self {
            Self {
                decoding_policy: Ok(value.decoding_policy),
                formal_schema_urn: Ok(value.formal_schema_urn),
                schema_definition: Ok(value.schema_definition),
                strict_validation: Ok(value.strict_validation),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct StateDifferentialManifest {
        author_node_cid: ::std::result::Result<super::AuthorNodeCid, ::std::string::String>,
        diff_cid: ::std::result::Result<super::DiffCid, ::std::string::String>,
        lamport_timestamp: ::std::result::Result<u64, ::std::string::String>,
        patches: ::std::result::Result<
            ::std::vec::Vec<super::StateMutationIntent>,
            ::std::string::String,
        >,
        vector_clock: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, u64>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for StateDifferentialManifest {
        fn default() -> Self {
            Self {
                author_node_cid: Err("no value supplied for author_node_cid".to_string()),
                diff_cid: Err("no value supplied for diff_cid".to_string()),
                lamport_timestamp: Err("no value supplied for lamport_timestamp".to_string()),
                patches: Ok(Default::default()),
                vector_clock: Err("no value supplied for vector_clock".to_string()),
            }
        }
    }
    impl StateDifferentialManifest {
        pub fn author_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AuthorNodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.author_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for author_node_cid: {e}"));
            self
        }
        pub fn diff_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DiffCid>,
            T::Error: ::std::fmt::Display,
        {
            self.diff_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for diff_cid: {e}"));
            self
        }
        pub fn lamport_timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.lamport_timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lamport_timestamp: {e}"));
            self
        }
        pub fn patches<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::StateMutationIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.patches = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for patches: {e}"));
            self
        }
        pub fn vector_clock<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::collections::HashMap<::std::string::String, u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.vector_clock = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for vector_clock: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<StateDifferentialManifest> for super::StateDifferentialManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: StateDifferentialManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                author_node_cid: value.author_node_cid?,
                diff_cid: value.diff_cid?,
                lamport_timestamp: value.lamport_timestamp?,
                patches: value.patches?,
                vector_clock: value.vector_clock?,
            })
        }
    }
    impl ::std::convert::From<super::StateDifferentialManifest> for StateDifferentialManifest {
        fn from(value: super::StateDifferentialManifest) -> Self {
            Self {
                author_node_cid: Ok(value.author_node_cid),
                diff_cid: Ok(value.diff_cid),
                lamport_timestamp: Ok(value.lamport_timestamp),
                patches: Ok(value.patches),
                vector_clock: Ok(value.vector_clock),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct StateHydrationManifest {
        crystallized_ledger_cids: ::std::result::Result<
            ::std::vec::Vec<super::CrystallizedLedgerCidsItem>,
            ::std::string::String,
        >,
        epistemic_coordinate:
            ::std::result::Result<super::EpistemicCoordinate, ::std::string::String>,
        max_retained_tokens: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        unfolding_policy: ::std::result::Result<
            ::std::option::Option<super::EpistemicHydrationPolicy>,
            ::std::string::String,
        >,
        working_context_variables: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for StateHydrationManifest {
        fn default() -> Self {
            Self {
                crystallized_ledger_cids: Err(
                    "no value supplied for crystallized_ledger_cids".to_string()
                ),
                epistemic_coordinate: Err("no value supplied for epistemic_coordinate".to_string()),
                max_retained_tokens: Err("no value supplied for max_retained_tokens".to_string()),
                unfolding_policy: Ok(Default::default()),
                working_context_variables: Err(
                    "no value supplied for working_context_variables".to_string()
                ),
            }
        }
    }
    impl StateHydrationManifest {
        pub fn crystallized_ledger_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::CrystallizedLedgerCidsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.crystallized_ledger_cids = value.try_into().map_err(|e| {
                format!("error converting supplied value for crystallized_ledger_cids: {e}")
            });
            self
        }
        pub fn epistemic_coordinate<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EpistemicCoordinate>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_coordinate = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_coordinate: {e}")
            });
            self
        }
        pub fn max_retained_tokens<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_retained_tokens = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_retained_tokens: {e}")
            });
            self
        }
        pub fn unfolding_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EpistemicHydrationPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.unfolding_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for unfolding_policy: {e}"));
            self
        }
        pub fn working_context_variables<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.working_context_variables = value.try_into().map_err(|e| {
                format!("error converting supplied value for working_context_variables: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<StateHydrationManifest> for super::StateHydrationManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: StateHydrationManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                crystallized_ledger_cids: value.crystallized_ledger_cids?,
                epistemic_coordinate: value.epistemic_coordinate?,
                max_retained_tokens: value.max_retained_tokens?,
                unfolding_policy: value.unfolding_policy?,
                working_context_variables: value.working_context_variables?,
            })
        }
    }
    impl ::std::convert::From<super::StateHydrationManifest> for StateHydrationManifest {
        fn from(value: super::StateHydrationManifest) -> Self {
            Self {
                crystallized_ledger_cids: Ok(value.crystallized_ledger_cids),
                epistemic_coordinate: Ok(value.epistemic_coordinate),
                max_retained_tokens: Ok(value.max_retained_tokens),
                unfolding_policy: Ok(value.unfolding_policy),
                working_context_variables: Ok(value.working_context_variables),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct StateMutationIntent {
        from: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        op: ::std::result::Result<super::PatchOperationProfile, ::std::string::String>,
        path: ::std::result::Result<super::Path, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        value: ::std::result::Result<
            ::std::option::Option<super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        zero_trust_receipt_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for StateMutationIntent {
        fn default() -> Self {
            Self {
                from: Ok(Default::default()),
                op: Err("no value supplied for op".to_string()),
                path: Err("no value supplied for path".to_string()),
                topology_class: Ok(Default::default()),
                value: Ok(Default::default()),
                zero_trust_receipt_cid: Ok(Default::default()),
            }
        }
    }
    impl StateMutationIntent {
        pub fn from<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.from = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for from: {e}"));
            self
        }
        pub fn op<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PatchOperationProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.op = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for op: {e}"));
            self
        }
        pub fn path<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Path>,
            T::Error: ::std::fmt::Display,
        {
            self.path = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for path: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn value<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::JsonPrimitiveState>>,
            T::Error: ::std::fmt::Display,
        {
            self.value = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for value: {e}"));
            self
        }
        pub fn zero_trust_receipt_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.zero_trust_receipt_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for zero_trust_receipt_cid: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<StateMutationIntent> for super::StateMutationIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: StateMutationIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                from: value.from?,
                op: value.op?,
                path: value.path?,
                topology_class: value.topology_class?,
                value: value.value?,
                zero_trust_receipt_cid: value.zero_trust_receipt_cid?,
            })
        }
    }
    impl ::std::convert::From<super::StateMutationIntent> for StateMutationIntent {
        fn from(value: super::StateMutationIntent) -> Self {
            Self {
                from: Ok(value.from),
                op: Ok(value.op),
                path: Ok(value.path),
                topology_class: Ok(value.topology_class),
                value: Ok(value.value),
                zero_trust_receipt_cid: Ok(value.zero_trust_receipt_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct StateVectorProfile {
        immutable_matrix: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        is_delta: ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        mutable_matrix: ::std::result::Result<
            ::std::option::Option<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for StateVectorProfile {
        fn default() -> Self {
            Self {
                immutable_matrix: Ok(Default::default()),
                is_delta: Ok(Default::default()),
                mutable_matrix: Ok(Default::default()),
            }
        }
    }
    impl StateVectorProfile {
        pub fn immutable_matrix<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.immutable_matrix = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for immutable_matrix: {e}"));
            self
        }
        pub fn is_delta<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.is_delta = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for is_delta: {e}"));
            self
        }
        pub fn mutable_matrix<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::option::Option<
                    ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.mutable_matrix = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for mutable_matrix: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<StateVectorProfile> for super::StateVectorProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: StateVectorProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                immutable_matrix: value.immutable_matrix?,
                is_delta: value.is_delta?,
                mutable_matrix: value.mutable_matrix?,
            })
        }
    }
    impl ::std::convert::From<super::StateVectorProfile> for StateVectorProfile {
        fn from(value: super::StateVectorProfile) -> Self {
            Self {
                immutable_matrix: Ok(value.immutable_matrix),
                is_delta: Ok(value.is_delta),
                mutable_matrix: Ok(value.mutable_matrix),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct StdioTransportProfile {
        args: ::std::result::Result<::std::vec::Vec<super::ArgsItem>, ::std::string::String>,
        command: ::std::result::Result<super::Command, ::std::string::String>,
        env_vars: ::std::result::Result<
            ::std::collections::HashMap<
                ::std::string::String,
                super::StdioTransportProfileEnvVarsValue,
            >,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for StdioTransportProfile {
        fn default() -> Self {
            Self {
                args: Ok(Default::default()),
                command: Err("no value supplied for command".to_string()),
                env_vars: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl StdioTransportProfile {
        pub fn args<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ArgsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.args = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for args: {e}"));
            self
        }
        pub fn command<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Command>,
            T::Error: ::std::fmt::Display,
        {
            self.command = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for command: {e}"));
            self
        }
        pub fn env_vars<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::StdioTransportProfileEnvVarsValue,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.env_vars = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for env_vars: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<StdioTransportProfile> for super::StdioTransportProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: StdioTransportProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                args: value.args?,
                command: value.command?,
                env_vars: value.env_vars?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::StdioTransportProfile> for StdioTransportProfile {
        fn from(value: super::StdioTransportProfile) -> Self {
            Self {
                args: Ok(value.args),
                command: Ok(value.command),
                env_vars: Ok(value.env_vars),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct StochasticNodeState {
        agent_role: ::std::result::Result<super::AgentRole, ::std::string::String>,
        epistemic_entropy: ::std::result::Result<f64, ::std::string::String>,
        node_cid: ::std::result::Result<super::NodeCid, ::std::string::String>,
        parent_node_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        stochastic_tensor: ::std::result::Result<super::StochasticTensor, ::std::string::String>,
    }
    impl ::std::default::Default for StochasticNodeState {
        fn default() -> Self {
            Self {
                agent_role: Err("no value supplied for agent_role".to_string()),
                epistemic_entropy: Err("no value supplied for epistemic_entropy".to_string()),
                node_cid: Err("no value supplied for node_cid".to_string()),
                parent_node_cid: Ok(Default::default()),
                stochastic_tensor: Err("no value supplied for stochastic_tensor".to_string()),
            }
        }
    }
    impl StochasticNodeState {
        pub fn agent_role<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AgentRole>,
            T::Error: ::std::fmt::Display,
        {
            self.agent_role = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for agent_role: {e}"));
            self
        }
        pub fn epistemic_entropy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_entropy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for epistemic_entropy: {e}"));
            self
        }
        pub fn node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for node_cid: {e}"));
            self
        }
        pub fn parent_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.parent_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for parent_node_cid: {e}"));
            self
        }
        pub fn stochastic_tensor<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StochasticTensor>,
            T::Error: ::std::fmt::Display,
        {
            self.stochastic_tensor = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for stochastic_tensor: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<StochasticNodeState> for super::StochasticNodeState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: StochasticNodeState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                agent_role: value.agent_role?,
                epistemic_entropy: value.epistemic_entropy?,
                node_cid: value.node_cid?,
                parent_node_cid: value.parent_node_cid?,
                stochastic_tensor: value.stochastic_tensor?,
            })
        }
    }
    impl ::std::convert::From<super::StochasticNodeState> for StochasticNodeState {
        fn from(value: super::StochasticNodeState) -> Self {
            Self {
                agent_role: Ok(value.agent_role),
                epistemic_entropy: Ok(value.epistemic_entropy),
                node_cid: Ok(value.node_cid),
                parent_node_cid: Ok(value.parent_node_cid),
                stochastic_tensor: Ok(value.stochastic_tensor),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct StochasticTopologyManifest {
        epistemic_status: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        phase: ::std::result::Result<super::IdeationPhaseProfile, ::std::string::String>,
        stochastic_graph: ::std::result::Result<
            ::std::vec::Vec<super::StochasticNodeState>,
            ::std::string::String,
        >,
        superposition: ::std::result::Result<
            ::std::option::Option<super::HypothesisSuperpositionState>,
            ::std::string::String,
        >,
        topology_cid: ::std::result::Result<super::TopologyCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for StochasticTopologyManifest {
        fn default() -> Self {
            Self {
                epistemic_status: Ok(Default::default()),
                phase: Err("no value supplied for phase".to_string()),
                stochastic_graph: Err("no value supplied for stochastic_graph".to_string()),
                superposition: Ok(Default::default()),
                topology_cid: Err("no value supplied for topology_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl StochasticTopologyManifest {
        pub fn epistemic_status<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_status = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for epistemic_status: {e}"));
            self
        }
        pub fn phase<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::IdeationPhaseProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.phase = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for phase: {e}"));
            self
        }
        pub fn stochastic_graph<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::StochasticNodeState>>,
            T::Error: ::std::fmt::Display,
        {
            self.stochastic_graph = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for stochastic_graph: {e}"));
            self
        }
        pub fn superposition<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::HypothesisSuperpositionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.superposition = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for superposition: {e}"));
            self
        }
        pub fn topology_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TopologyCid>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<StochasticTopologyManifest> for super::StochasticTopologyManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: StochasticTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                epistemic_status: value.epistemic_status?,
                phase: value.phase?,
                stochastic_graph: value.stochastic_graph?,
                superposition: value.superposition?,
                topology_cid: value.topology_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::StochasticTopologyManifest> for StochasticTopologyManifest {
        fn from(value: super::StochasticTopologyManifest) -> Self {
            Self {
                epistemic_status: Ok(value.epistemic_status),
                phase: Ok(value.phase),
                stochastic_graph: Ok(value.stochastic_graph),
                superposition: Ok(value.superposition),
                topology_cid: Ok(value.topology_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct StrategicThoughtNodeIntent {
        heuristic_confidence: ::std::result::Result<f64, ::std::string::String>,
        parent_node_hash: ::std::result::Result<super::ParentNodeHash, ::std::string::String>,
        proposed_action: ::std::result::Result<super::ProposedAction, ::std::string::String>,
        rationale: ::std::result::Result<super::Rationale, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for StrategicThoughtNodeIntent {
        fn default() -> Self {
            Self {
                heuristic_confidence: Err("no value supplied for heuristic_confidence".to_string()),
                parent_node_hash: Err("no value supplied for parent_node_hash".to_string()),
                proposed_action: Err("no value supplied for proposed_action".to_string()),
                rationale: Err("no value supplied for rationale".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl StrategicThoughtNodeIntent {
        pub fn heuristic_confidence<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.heuristic_confidence = value.try_into().map_err(|e| {
                format!("error converting supplied value for heuristic_confidence: {e}")
            });
            self
        }
        pub fn parent_node_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ParentNodeHash>,
            T::Error: ::std::fmt::Display,
        {
            self.parent_node_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for parent_node_hash: {e}"));
            self
        }
        pub fn proposed_action<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProposedAction>,
            T::Error: ::std::fmt::Display,
        {
            self.proposed_action = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proposed_action: {e}"));
            self
        }
        pub fn rationale<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Rationale>,
            T::Error: ::std::fmt::Display,
        {
            self.rationale = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for rationale: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<StrategicThoughtNodeIntent> for super::StrategicThoughtNodeIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: StrategicThoughtNodeIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                heuristic_confidence: value.heuristic_confidence?,
                parent_node_hash: value.parent_node_hash?,
                proposed_action: value.proposed_action?,
                rationale: value.rationale?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::StrategicThoughtNodeIntent> for StrategicThoughtNodeIntent {
        fn from(value: super::StrategicThoughtNodeIntent) -> Self {
            Self {
                heuristic_confidence: Ok(value.heuristic_confidence),
                parent_node_hash: Ok(value.parent_node_hash),
                proposed_action: Ok(value.proposed_action),
                rationale: Ok(value.rationale),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct StreamingDisfluencyContract {
        decay_threshold: ::std::result::Result<f64, ::std::string::String>,
        max_lookback_window: ::std::result::Result<u64, ::std::string::String>,
        repair_marker_regex: ::std::result::Result<super::RepairMarkerRegex, ::std::string::String>,
    }
    impl ::std::default::Default for StreamingDisfluencyContract {
        fn default() -> Self {
            Self {
                decay_threshold: Err("no value supplied for decay_threshold".to_string()),
                max_lookback_window: Err("no value supplied for max_lookback_window".to_string()),
                repair_marker_regex: Err("no value supplied for repair_marker_regex".to_string()),
            }
        }
    }
    impl StreamingDisfluencyContract {
        pub fn decay_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.decay_threshold = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for decay_threshold: {e}"));
            self
        }
        pub fn max_lookback_window<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_lookback_window = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_lookback_window: {e}")
            });
            self
        }
        pub fn repair_marker_regex<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RepairMarkerRegex>,
            T::Error: ::std::fmt::Display,
        {
            self.repair_marker_regex = value.try_into().map_err(|e| {
                format!("error converting supplied value for repair_marker_regex: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<StreamingDisfluencyContract> for super::StreamingDisfluencyContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: StreamingDisfluencyContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                decay_threshold: value.decay_threshold?,
                max_lookback_window: value.max_lookback_window?,
                repair_marker_regex: value.repair_marker_regex?,
            })
        }
    }
    impl ::std::convert::From<super::StreamingDisfluencyContract> for StreamingDisfluencyContract {
        fn from(value: super::StreamingDisfluencyContract) -> Self {
            Self {
                decay_threshold: Ok(value.decay_threshold),
                max_lookback_window: Ok(value.max_lookback_window),
                repair_marker_regex: Ok(value.repair_marker_regex),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct StructuralCausalGraphProfile {
        causal_edges: ::std::result::Result<
            ::std::vec::Vec<super::CausalDirectedEdgeState>,
            ::std::string::String,
        >,
        latent_variables: ::std::result::Result<
            ::std::vec::Vec<super::LatentVariablesItem>,
            ::std::string::String,
        >,
        observed_variables: ::std::result::Result<
            ::std::vec::Vec<super::ObservedVariablesItem>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for StructuralCausalGraphProfile {
        fn default() -> Self {
            Self {
                causal_edges: Err("no value supplied for causal_edges".to_string()),
                latent_variables: Err("no value supplied for latent_variables".to_string()),
                observed_variables: Err("no value supplied for observed_variables".to_string()),
            }
        }
    }
    impl StructuralCausalGraphProfile {
        pub fn causal_edges<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::CausalDirectedEdgeState>>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_edges = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for causal_edges: {e}"));
            self
        }
        pub fn latent_variables<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::LatentVariablesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.latent_variables = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for latent_variables: {e}"));
            self
        }
        pub fn observed_variables<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ObservedVariablesItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.observed_variables = value.try_into().map_err(|e| {
                format!("error converting supplied value for observed_variables: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<StructuralCausalGraphProfile> for super::StructuralCausalGraphProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: StructuralCausalGraphProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                causal_edges: value.causal_edges?,
                latent_variables: value.latent_variables?,
                observed_variables: value.observed_variables?,
            })
        }
    }
    impl ::std::convert::From<super::StructuralCausalGraphProfile> for StructuralCausalGraphProfile {
        fn from(value: super::StructuralCausalGraphProfile) -> Self {
            Self {
                causal_edges: Ok(value.causal_edges),
                latent_variables: Ok(value.latent_variables),
                observed_variables: Ok(value.observed_variables),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SubstrateHydrationManifest {
        cryptographic_checksums: ::std::result::Result<
            ::std::collections::HashMap<
                ::std::string::String,
                super::SubstrateHydrationManifestCryptographicChecksumsValue,
            >,
            ::std::string::String,
        >,
        substrate_profile:
            ::std::result::Result<super::ExecutionSubstrateProfile, ::std::string::String>,
        target_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SubstrateHydrationManifest {
        fn default() -> Self {
            Self {
                cryptographic_checksums: Ok(Default::default()),
                substrate_profile: Err("no value supplied for substrate_profile".to_string()),
                target_node_cid: Err("no value supplied for target_node_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl SubstrateHydrationManifest {
        pub fn cryptographic_checksums<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::SubstrateHydrationManifestCryptographicChecksumsValue,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.cryptographic_checksums = value.try_into().map_err(|e| {
                format!("error converting supplied value for cryptographic_checksums: {e}")
            });
            self
        }
        pub fn substrate_profile<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ExecutionSubstrateProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.substrate_profile = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for substrate_profile: {e}"));
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SubstrateHydrationManifest> for super::SubstrateHydrationManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SubstrateHydrationManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                cryptographic_checksums: value.cryptographic_checksums?,
                substrate_profile: value.substrate_profile?,
                target_node_cid: value.target_node_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::SubstrateHydrationManifest> for SubstrateHydrationManifest {
        fn from(value: super::SubstrateHydrationManifest) -> Self {
            Self {
                cryptographic_checksums: Ok(value.cryptographic_checksums),
                substrate_profile: Ok(value.substrate_profile),
                target_node_cid: Ok(value.target_node_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SwarmTopologyManifest {
        active_prediction_markets: ::std::result::Result<
            ::std::vec::Vec<super::PredictionMarketState>,
            ::std::string::String,
        >,
        architectural_intent: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        auction_policy: ::std::result::Result<
            ::std::option::Option<super::AuctionPolicy>,
            ::std::string::String,
        >,
        epistemic_enforcement: ::std::result::Result<
            ::std::option::Option<super::TruthMaintenancePolicy>,
            ::std::string::String,
        >,
        justification: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        lifecycle_phase: ::std::result::Result<
            ::std::option::Option<super::LifecyclePhase>,
            ::std::string::String,
        >,
        max_concurrent_agents:
            ::std::result::Result<::std::option::Option<i64>, ::std::string::String>,
        nodes: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            ::std::string::String,
        >,
        observability: ::std::result::Result<
            ::std::option::Option<super::ObservabilityLodPolicy>,
            ::std::string::String,
        >,
        resolved_markets: ::std::result::Result<
            ::std::vec::Vec<super::MarketResolutionState>,
            ::std::string::String,
        >,
        semantic_flow: ::std::result::Result<
            ::std::option::Option<super::SemanticFlowPolicy>,
            ::std::string::String,
        >,
        shared_state_contract: ::std::result::Result<
            ::std::option::Option<super::StateContract>,
            ::std::string::String,
        >,
        spawning_threshold: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SwarmTopologyManifest {
        fn default() -> Self {
            Self {
                active_prediction_markets: Ok(Default::default()),
                architectural_intent: Ok(Default::default()),
                auction_policy: Ok(Default::default()),
                epistemic_enforcement: Ok(Default::default()),
                justification: Ok(Default::default()),
                lifecycle_phase: Ok(Default::default()),
                max_concurrent_agents: Ok(Default::default()),
                nodes: Err("no value supplied for nodes".to_string()),
                observability: Ok(Default::default()),
                resolved_markets: Ok(Default::default()),
                semantic_flow: Ok(Default::default()),
                shared_state_contract: Ok(Default::default()),
                spawning_threshold: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl SwarmTopologyManifest {
        pub fn active_prediction_markets<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::PredictionMarketState>>,
            T::Error: ::std::fmt::Display,
        {
            self.active_prediction_markets = value.try_into().map_err(|e| {
                format!("error converting supplied value for active_prediction_markets: {e}")
            });
            self
        }
        pub fn architectural_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.architectural_intent = value.try_into().map_err(|e| {
                format!("error converting supplied value for architectural_intent: {e}")
            });
            self
        }
        pub fn auction_policy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AuctionPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.auction_policy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for auction_policy: {e}"));
            self
        }
        pub fn epistemic_enforcement<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TruthMaintenancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_enforcement = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_enforcement: {e}")
            });
            self
        }
        pub fn justification<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.justification = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for justification: {e}"));
            self
        }
        pub fn lifecycle_phase<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::LifecyclePhase>>,
            T::Error: ::std::fmt::Display,
        {
            self.lifecycle_phase = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lifecycle_phase: {e}"));
            self
        }
        pub fn max_concurrent_agents<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<i64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_concurrent_agents = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_concurrent_agents: {e}")
            });
            self
        }
        pub fn nodes<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::AnyNodeProfile>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.nodes = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for nodes: {e}"));
            self
        }
        pub fn observability<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ObservabilityLodPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.observability = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for observability: {e}"));
            self
        }
        pub fn resolved_markets<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::MarketResolutionState>>,
            T::Error: ::std::fmt::Display,
        {
            self.resolved_markets = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for resolved_markets: {e}"));
            self
        }
        pub fn semantic_flow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticFlowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_flow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_flow: {e}"));
            self
        }
        pub fn shared_state_contract<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::StateContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.shared_state_contract = value.try_into().map_err(|e| {
                format!("error converting supplied value for shared_state_contract: {e}")
            });
            self
        }
        pub fn spawning_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.spawning_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for spawning_threshold: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SwarmTopologyManifest> for super::SwarmTopologyManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SwarmTopologyManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                active_prediction_markets: value.active_prediction_markets?,
                architectural_intent: value.architectural_intent?,
                auction_policy: value.auction_policy?,
                epistemic_enforcement: value.epistemic_enforcement?,
                justification: value.justification?,
                lifecycle_phase: value.lifecycle_phase?,
                max_concurrent_agents: value.max_concurrent_agents?,
                nodes: value.nodes?,
                observability: value.observability?,
                resolved_markets: value.resolved_markets?,
                semantic_flow: value.semantic_flow?,
                shared_state_contract: value.shared_state_contract?,
                spawning_threshold: value.spawning_threshold?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::SwarmTopologyManifest> for SwarmTopologyManifest {
        fn from(value: super::SwarmTopologyManifest) -> Self {
            Self {
                active_prediction_markets: Ok(value.active_prediction_markets),
                architectural_intent: Ok(value.architectural_intent),
                auction_policy: Ok(value.auction_policy),
                epistemic_enforcement: Ok(value.epistemic_enforcement),
                justification: Ok(value.justification),
                lifecycle_phase: Ok(value.lifecycle_phase),
                max_concurrent_agents: Ok(value.max_concurrent_agents),
                nodes: Ok(value.nodes),
                observability: Ok(value.observability),
                resolved_markets: Ok(value.resolved_markets),
                semantic_flow: Ok(value.semantic_flow),
                shared_state_contract: Ok(value.shared_state_contract),
                spawning_threshold: Ok(value.spawning_threshold),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SyntheticGenerationProfile {
        manifold_sla: ::std::result::Result<super::GenerativeManifoldSla, ::std::string::String>,
        profile_cid: ::std::result::Result<super::ProfileCid, ::std::string::String>,
        target_schema_ref: ::std::result::Result<super::TargetSchemaRef, ::std::string::String>,
    }
    impl ::std::default::Default for SyntheticGenerationProfile {
        fn default() -> Self {
            Self {
                manifold_sla: Err("no value supplied for manifold_sla".to_string()),
                profile_cid: Err("no value supplied for profile_cid".to_string()),
                target_schema_ref: Err("no value supplied for target_schema_ref".to_string()),
            }
        }
    }
    impl SyntheticGenerationProfile {
        pub fn manifold_sla<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::GenerativeManifoldSla>,
            T::Error: ::std::fmt::Display,
        {
            self.manifold_sla = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for manifold_sla: {e}"));
            self
        }
        pub fn profile_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProfileCid>,
            T::Error: ::std::fmt::Display,
        {
            self.profile_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for profile_cid: {e}"));
            self
        }
        pub fn target_schema_ref<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetSchemaRef>,
            T::Error: ::std::fmt::Display,
        {
            self.target_schema_ref = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_schema_ref: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SyntheticGenerationProfile> for super::SyntheticGenerationProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SyntheticGenerationProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                manifold_sla: value.manifold_sla?,
                profile_cid: value.profile_cid?,
                target_schema_ref: value.target_schema_ref?,
            })
        }
    }
    impl ::std::convert::From<super::SyntheticGenerationProfile> for SyntheticGenerationProfile {
        fn from(value: super::SyntheticGenerationProfile) -> Self {
            Self {
                manifold_sla: Ok(value.manifold_sla),
                profile_cid: Ok(value.profile_cid),
                target_schema_ref: Ok(value.target_schema_ref),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct System1ReflexPolicy {
        allowed_passive_tools: ::std::result::Result<
            ::std::vec::Vec<super::AllowedPassiveToolsItem>,
            ::std::string::String,
        >,
        confidence_threshold: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for System1ReflexPolicy {
        fn default() -> Self {
            Self {
                allowed_passive_tools: Err(
                    "no value supplied for allowed_passive_tools".to_string()
                ),
                confidence_threshold: Err("no value supplied for confidence_threshold".to_string()),
            }
        }
    }
    impl System1ReflexPolicy {
        pub fn allowed_passive_tools<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AllowedPassiveToolsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.allowed_passive_tools = value.try_into().map_err(|e| {
                format!("error converting supplied value for allowed_passive_tools: {e}")
            });
            self
        }
        pub fn confidence_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.confidence_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for confidence_threshold: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<System1ReflexPolicy> for super::System1ReflexPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: System1ReflexPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                allowed_passive_tools: value.allowed_passive_tools?,
                confidence_threshold: value.confidence_threshold?,
            })
        }
    }
    impl ::std::convert::From<super::System1ReflexPolicy> for System1ReflexPolicy {
        fn from(value: super::System1ReflexPolicy) -> Self {
            Self {
                allowed_passive_tools: Ok(value.allowed_passive_tools),
                confidence_threshold: Ok(value.confidence_threshold),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct System2RemediationIntent {
        ast_gradient: ::std::result::Result<
            ::std::option::Option<super::AstGradientReceipt>,
            ::std::string::String,
        >,
        fault_cid: ::std::result::Result<super::FaultCid, ::std::string::String>,
        target_node_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        violation_receipts: ::std::result::Result<
            ::std::vec::Vec<super::ManifestViolationReceipt>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for System2RemediationIntent {
        fn default() -> Self {
            Self {
                ast_gradient: Ok(Default::default()),
                fault_cid: Err("no value supplied for fault_cid".to_string()),
                target_node_cid: Err("no value supplied for target_node_cid".to_string()),
                topology_class: Ok(Default::default()),
                violation_receipts: Err("no value supplied for violation_receipts".to_string()),
            }
        }
    }
    impl System2RemediationIntent {
        pub fn ast_gradient<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::AstGradientReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.ast_gradient = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for ast_gradient: {e}"));
            self
        }
        pub fn fault_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FaultCid>,
            T::Error: ::std::fmt::Display,
        {
            self.fault_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for fault_cid: {e}"));
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn violation_receipts<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ManifestViolationReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.violation_receipts = value.try_into().map_err(|e| {
                format!("error converting supplied value for violation_receipts: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<System2RemediationIntent> for super::System2RemediationIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: System2RemediationIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                ast_gradient: value.ast_gradient?,
                fault_cid: value.fault_cid?,
                target_node_cid: value.target_node_cid?,
                topology_class: value.topology_class?,
                violation_receipts: value.violation_receipts?,
            })
        }
    }
    impl ::std::convert::From<super::System2RemediationIntent> for System2RemediationIntent {
        fn from(value: super::System2RemediationIntent) -> Self {
            Self {
                ast_gradient: Ok(value.ast_gradient),
                fault_cid: Ok(value.fault_cid),
                target_node_cid: Ok(value.target_node_cid),
                topology_class: Ok(value.topology_class),
                violation_receipts: Ok(value.violation_receipts),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct SystemFaultEvent {
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for SystemFaultEvent {
        fn default() -> Self {
            Self {
                event_cid: Err("no value supplied for event_cid".to_string()),
                prior_event_hash: Ok(Default::default()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl SystemFaultEvent {
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<SystemFaultEvent> for super::SystemFaultEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: SystemFaultEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                event_cid: value.event_cid?,
                prior_event_hash: value.prior_event_hash?,
                timestamp: value.timestamp?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::SystemFaultEvent> for SystemFaultEvent {
        fn from(value: super::SystemFaultEvent) -> Self {
            Self {
                event_cid: Ok(value.event_cid),
                prior_event_hash: Ok(value.prior_event_hash),
                timestamp: Ok(value.timestamp),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TabularCellState {
        cell_cid: ::std::result::Result<super::CellCid, ::std::string::String>,
        column_index: ::std::result::Result<u64, ::std::string::String>,
        column_span: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
        row_index: ::std::result::Result<u64, ::std::string::String>,
        row_span: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
        text_payload: ::std::result::Result<super::TextPayload, ::std::string::String>,
    }
    impl ::std::default::Default for TabularCellState {
        fn default() -> Self {
            Self {
                cell_cid: Err("no value supplied for cell_cid".to_string()),
                column_index: Err("no value supplied for column_index".to_string()),
                column_span: Ok(Default::default()),
                row_index: Err("no value supplied for row_index".to_string()),
                row_span: Ok(Default::default()),
                text_payload: Err("no value supplied for text_payload".to_string()),
            }
        }
    }
    impl TabularCellState {
        pub fn cell_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CellCid>,
            T::Error: ::std::fmt::Display,
        {
            self.cell_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for cell_cid: {e}"));
            self
        }
        pub fn column_index<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.column_index = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for column_index: {e}"));
            self
        }
        pub fn column_span<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.column_span = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for column_span: {e}"));
            self
        }
        pub fn row_index<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.row_index = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for row_index: {e}"));
            self
        }
        pub fn row_span<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.row_span = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for row_span: {e}"));
            self
        }
        pub fn text_payload<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TextPayload>,
            T::Error: ::std::fmt::Display,
        {
            self.text_payload = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for text_payload: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TabularCellState> for super::TabularCellState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TabularCellState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                cell_cid: value.cell_cid?,
                column_index: value.column_index?,
                column_span: value.column_span?,
                row_index: value.row_index?,
                row_span: value.row_span?,
                text_payload: value.text_payload?,
            })
        }
    }
    impl ::std::convert::From<super::TabularCellState> for TabularCellState {
        fn from(value: super::TabularCellState) -> Self {
            Self {
                cell_cid: Ok(value.cell_cid),
                column_index: Ok(value.column_index),
                column_span: Ok(value.column_span),
                row_index: Ok(value.row_index),
                row_span: Ok(value.row_span),
                text_payload: Ok(value.text_payload),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TabularMatrixProfile {
        cells:
            ::std::result::Result<::std::vec::Vec<super::TabularCellState>, ::std::string::String>,
        matrix_cid: ::std::result::Result<super::MatrixCid, ::std::string::String>,
        total_columns: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        total_rows: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for TabularMatrixProfile {
        fn default() -> Self {
            Self {
                cells: Err("no value supplied for cells".to_string()),
                matrix_cid: Err("no value supplied for matrix_cid".to_string()),
                total_columns: Err("no value supplied for total_columns".to_string()),
                total_rows: Err("no value supplied for total_rows".to_string()),
            }
        }
    }
    impl TabularMatrixProfile {
        pub fn cells<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::TabularCellState>>,
            T::Error: ::std::fmt::Display,
        {
            self.cells = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for cells: {e}"));
            self
        }
        pub fn matrix_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MatrixCid>,
            T::Error: ::std::fmt::Display,
        {
            self.matrix_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for matrix_cid: {e}"));
            self
        }
        pub fn total_columns<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.total_columns = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for total_columns: {e}"));
            self
        }
        pub fn total_rows<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.total_rows = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for total_rows: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TabularMatrixProfile> for super::TabularMatrixProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TabularMatrixProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                cells: value.cells?,
                matrix_cid: value.matrix_cid?,
                total_columns: value.total_columns?,
                total_rows: value.total_rows?,
            })
        }
    }
    impl ::std::convert::From<super::TabularMatrixProfile> for TabularMatrixProfile {
        fn from(value: super::TabularMatrixProfile) -> Self {
            Self {
                cells: Ok(value.cells),
                matrix_cid: Ok(value.matrix_cid),
                total_columns: Ok(value.total_columns),
                total_rows: Ok(value.total_rows),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TaskAnnouncementIntent {
        max_budget_magnitude: ::std::result::Result<u64, ::std::string::String>,
        required_action_space_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        task_cid: ::std::result::Result<super::TaskCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for TaskAnnouncementIntent {
        fn default() -> Self {
            Self {
                max_budget_magnitude: Err("no value supplied for max_budget_magnitude".to_string()),
                required_action_space_cid: Ok(Default::default()),
                task_cid: Err("no value supplied for task_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl TaskAnnouncementIntent {
        pub fn max_budget_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_budget_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_budget_magnitude: {e}")
            });
            self
        }
        pub fn required_action_space_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.required_action_space_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for required_action_space_cid: {e}")
            });
            self
        }
        pub fn task_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TaskCid>,
            T::Error: ::std::fmt::Display,
        {
            self.task_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for task_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TaskAnnouncementIntent> for super::TaskAnnouncementIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TaskAnnouncementIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_budget_magnitude: value.max_budget_magnitude?,
                required_action_space_cid: value.required_action_space_cid?,
                task_cid: value.task_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::TaskAnnouncementIntent> for TaskAnnouncementIntent {
        fn from(value: super::TaskAnnouncementIntent) -> Self {
            Self {
                max_budget_magnitude: Ok(value.max_budget_magnitude),
                required_action_space_cid: Ok(value.required_action_space_cid),
                task_cid: Ok(value.task_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TaskAwardReceipt {
        awarded_syndicate: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, u64>,
            ::std::string::String,
        >,
        cleared_price_magnitude: ::std::result::Result<u64, ::std::string::String>,
        escrow: ::std::result::Result<
            ::std::option::Option<super::EscrowPolicy>,
            ::std::string::String,
        >,
        task_cid: ::std::result::Result<super::TaskCid, ::std::string::String>,
    }
    impl ::std::default::Default for TaskAwardReceipt {
        fn default() -> Self {
            Self {
                awarded_syndicate: Err("no value supplied for awarded_syndicate".to_string()),
                cleared_price_magnitude: Err(
                    "no value supplied for cleared_price_magnitude".to_string()
                ),
                escrow: Ok(Default::default()),
                task_cid: Err("no value supplied for task_cid".to_string()),
            }
        }
    }
    impl TaskAwardReceipt {
        pub fn awarded_syndicate<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::collections::HashMap<::std::string::String, u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.awarded_syndicate = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for awarded_syndicate: {e}"));
            self
        }
        pub fn cleared_price_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.cleared_price_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for cleared_price_magnitude: {e}")
            });
            self
        }
        pub fn escrow<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EscrowPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.escrow = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for escrow: {e}"));
            self
        }
        pub fn task_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TaskCid>,
            T::Error: ::std::fmt::Display,
        {
            self.task_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for task_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TaskAwardReceipt> for super::TaskAwardReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TaskAwardReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                awarded_syndicate: value.awarded_syndicate?,
                cleared_price_magnitude: value.cleared_price_magnitude?,
                escrow: value.escrow?,
                task_cid: value.task_cid?,
            })
        }
    }
    impl ::std::convert::From<super::TaskAwardReceipt> for TaskAwardReceipt {
        fn from(value: super::TaskAwardReceipt) -> Self {
            Self {
                awarded_syndicate: Ok(value.awarded_syndicate),
                cleared_price_magnitude: Ok(value.cleared_price_magnitude),
                escrow: Ok(value.escrow),
                task_cid: Ok(value.task_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TaxonomicNodeState {
        children_node_cids: ::std::result::Result<
            ::std::vec::Vec<super::ChildrenNodeCidsItem>,
            ::std::string::String,
        >,
        leaf_provenance: ::std::result::Result<
            ::std::vec::Vec<super::EpistemicProvenanceReceipt>,
            ::std::string::String,
        >,
        node_cid: ::std::result::Result<super::NodeCid, ::std::string::String>,
        render_material: ::std::result::Result<
            ::std::option::Option<super::SpatialRenderMaterial>,
            ::std::string::String,
        >,
        semantic_label: ::std::result::Result<super::SemanticLabel, ::std::string::String>,
    }
    impl ::std::default::Default for TaxonomicNodeState {
        fn default() -> Self {
            Self {
                children_node_cids: Ok(Default::default()),
                leaf_provenance: Ok(Default::default()),
                node_cid: Err("no value supplied for node_cid".to_string()),
                render_material: Ok(Default::default()),
                semantic_label: Err("no value supplied for semantic_label".to_string()),
            }
        }
    }
    impl TaxonomicNodeState {
        pub fn children_node_cids<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::ChildrenNodeCidsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.children_node_cids = value.try_into().map_err(|e| {
                format!("error converting supplied value for children_node_cids: {e}")
            });
            self
        }
        pub fn leaf_provenance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EpistemicProvenanceReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.leaf_provenance = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for leaf_provenance: {e}"));
            self
        }
        pub fn node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for node_cid: {e}"));
            self
        }
        pub fn render_material<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SpatialRenderMaterial>>,
            T::Error: ::std::fmt::Display,
        {
            self.render_material = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for render_material: {e}"));
            self
        }
        pub fn semantic_label<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SemanticLabel>,
            T::Error: ::std::fmt::Display,
        {
            self.semantic_label = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for semantic_label: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TaxonomicNodeState> for super::TaxonomicNodeState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TaxonomicNodeState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                children_node_cids: value.children_node_cids?,
                leaf_provenance: value.leaf_provenance?,
                node_cid: value.node_cid?,
                render_material: value.render_material?,
                semantic_label: value.semantic_label?,
            })
        }
    }
    impl ::std::convert::From<super::TaxonomicNodeState> for TaxonomicNodeState {
        fn from(value: super::TaxonomicNodeState) -> Self {
            Self {
                children_node_cids: Ok(value.children_node_cids),
                leaf_provenance: Ok(value.leaf_provenance),
                node_cid: Ok(value.node_cid),
                render_material: Ok(value.render_material),
                semantic_label: Ok(value.semantic_label),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TaxonomicRestructureIntent {
        restructure_heuristic:
            ::std::result::Result<super::RestructureHeuristic, ::std::string::String>,
        target_taxonomy:
            ::std::result::Result<super::GenerativeTaxonomyManifest, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for TaxonomicRestructureIntent {
        fn default() -> Self {
            Self {
                restructure_heuristic: Err(
                    "no value supplied for restructure_heuristic".to_string()
                ),
                target_taxonomy: Err("no value supplied for target_taxonomy".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl TaxonomicRestructureIntent {
        pub fn restructure_heuristic<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::RestructureHeuristic>,
            T::Error: ::std::fmt::Display,
        {
            self.restructure_heuristic = value.try_into().map_err(|e| {
                format!("error converting supplied value for restructure_heuristic: {e}")
            });
            self
        }
        pub fn target_taxonomy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::GenerativeTaxonomyManifest>,
            T::Error: ::std::fmt::Display,
        {
            self.target_taxonomy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_taxonomy: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TaxonomicRestructureIntent> for super::TaxonomicRestructureIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TaxonomicRestructureIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                restructure_heuristic: value.restructure_heuristic?,
                target_taxonomy: value.target_taxonomy?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::TaxonomicRestructureIntent> for TaxonomicRestructureIntent {
        fn from(value: super::TaxonomicRestructureIntent) -> Self {
            Self {
                restructure_heuristic: Ok(value.restructure_heuristic),
                target_taxonomy: Ok(value.target_taxonomy),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TaxonomicRoutingPolicy {
        fallback_heuristic: ::std::result::Result<super::FallbackHeuristic, ::std::string::String>,
        intent_to_heuristic_matrix: ::std::result::Result<
            ::std::collections::HashMap<
                ::std::string::String,
                super::TaxonomicRoutingPolicyIntentToHeuristicMatrixValue,
            >,
            ::std::string::String,
        >,
        policy_cid: ::std::result::Result<super::PolicyCid, ::std::string::String>,
    }
    impl ::std::default::Default for TaxonomicRoutingPolicy {
        fn default() -> Self {
            Self {
                fallback_heuristic: Err("no value supplied for fallback_heuristic".to_string()),
                intent_to_heuristic_matrix: Err(
                    "no value supplied for intent_to_heuristic_matrix".to_string()
                ),
                policy_cid: Err("no value supplied for policy_cid".to_string()),
            }
        }
    }
    impl TaxonomicRoutingPolicy {
        pub fn fallback_heuristic<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FallbackHeuristic>,
            T::Error: ::std::fmt::Display,
        {
            self.fallback_heuristic = value.try_into().map_err(|e| {
                format!("error converting supplied value for fallback_heuristic: {e}")
            });
            self
        }
        pub fn intent_to_heuristic_matrix<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::TaxonomicRoutingPolicyIntentToHeuristicMatrixValue,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.intent_to_heuristic_matrix = value.try_into().map_err(|e| {
                format!("error converting supplied value for intent_to_heuristic_matrix: {e}")
            });
            self
        }
        pub fn policy_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PolicyCid>,
            T::Error: ::std::fmt::Display,
        {
            self.policy_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for policy_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TaxonomicRoutingPolicy> for super::TaxonomicRoutingPolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TaxonomicRoutingPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                fallback_heuristic: value.fallback_heuristic?,
                intent_to_heuristic_matrix: value.intent_to_heuristic_matrix?,
                policy_cid: value.policy_cid?,
            })
        }
    }
    impl ::std::convert::From<super::TaxonomicRoutingPolicy> for TaxonomicRoutingPolicy {
        fn from(value: super::TaxonomicRoutingPolicy) -> Self {
            Self {
                fallback_heuristic: Ok(value.fallback_heuristic),
                intent_to_heuristic_matrix: Ok(value.intent_to_heuristic_matrix),
                policy_cid: Ok(value.policy_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TelemetryBackpressureContract {
        epsilon_derivative_threshold:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        focal_refresh_rate_hz: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        occluded_refresh_rate_hz:
            ::std::result::Result<::std::option::Option<i64>, ::std::string::String>,
        peripheral_refresh_rate_hz:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for TelemetryBackpressureContract {
        fn default() -> Self {
            Self {
                epsilon_derivative_threshold: Ok(Default::default()),
                focal_refresh_rate_hz: Err(
                    "no value supplied for focal_refresh_rate_hz".to_string()
                ),
                occluded_refresh_rate_hz: Ok(Default::default()),
                peripheral_refresh_rate_hz: Err(
                    "no value supplied for peripheral_refresh_rate_hz".to_string()
                ),
            }
        }
    }
    impl TelemetryBackpressureContract {
        pub fn epsilon_derivative_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.epsilon_derivative_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for epsilon_derivative_threshold: {e}")
            });
            self
        }
        pub fn focal_refresh_rate_hz<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.focal_refresh_rate_hz = value.try_into().map_err(|e| {
                format!("error converting supplied value for focal_refresh_rate_hz: {e}")
            });
            self
        }
        pub fn occluded_refresh_rate_hz<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<i64>>,
            T::Error: ::std::fmt::Display,
        {
            self.occluded_refresh_rate_hz = value.try_into().map_err(|e| {
                format!("error converting supplied value for occluded_refresh_rate_hz: {e}")
            });
            self
        }
        pub fn peripheral_refresh_rate_hz<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.peripheral_refresh_rate_hz = value.try_into().map_err(|e| {
                format!("error converting supplied value for peripheral_refresh_rate_hz: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<TelemetryBackpressureContract>
        for super::TelemetryBackpressureContract
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TelemetryBackpressureContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                epsilon_derivative_threshold: value.epsilon_derivative_threshold?,
                focal_refresh_rate_hz: value.focal_refresh_rate_hz?,
                occluded_refresh_rate_hz: value.occluded_refresh_rate_hz?,
                peripheral_refresh_rate_hz: value.peripheral_refresh_rate_hz?,
            })
        }
    }
    impl ::std::convert::From<super::TelemetryBackpressureContract> for TelemetryBackpressureContract {
        fn from(value: super::TelemetryBackpressureContract) -> Self {
            Self {
                epsilon_derivative_threshold: Ok(value.epsilon_derivative_threshold),
                focal_refresh_rate_hz: Ok(value.focal_refresh_rate_hz),
                occluded_refresh_rate_hz: Ok(value.occluded_refresh_rate_hz),
                peripheral_refresh_rate_hz: Ok(value.peripheral_refresh_rate_hz),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TeleologicalIsometryReceipt {
        alignment_threshold_passed: ::std::result::Result<bool, ::std::string::String>,
        forged_output_vector:
            ::std::result::Result<super::VectorEmbeddingState, ::std::string::String>,
        measured_cosine_similarity: ::std::result::Result<f64, ::std::string::String>,
        source_intent_cid: ::std::result::Result<super::SourceIntentCid, ::std::string::String>,
        target_intent_vector:
            ::std::result::Result<super::VectorEmbeddingState, ::std::string::String>,
    }
    impl ::std::default::Default for TeleologicalIsometryReceipt {
        fn default() -> Self {
            Self {
                alignment_threshold_passed: Err(
                    "no value supplied for alignment_threshold_passed".to_string()
                ),
                forged_output_vector: Err("no value supplied for forged_output_vector".to_string()),
                measured_cosine_similarity: Err(
                    "no value supplied for measured_cosine_similarity".to_string()
                ),
                source_intent_cid: Err("no value supplied for source_intent_cid".to_string()),
                target_intent_vector: Err("no value supplied for target_intent_vector".to_string()),
            }
        }
    }
    impl TeleologicalIsometryReceipt {
        pub fn alignment_threshold_passed<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<bool>,
            T::Error: ::std::fmt::Display,
        {
            self.alignment_threshold_passed = value.try_into().map_err(|e| {
                format!("error converting supplied value for alignment_threshold_passed: {e}")
            });
            self
        }
        pub fn forged_output_vector<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VectorEmbeddingState>,
            T::Error: ::std::fmt::Display,
        {
            self.forged_output_vector = value.try_into().map_err(|e| {
                format!("error converting supplied value for forged_output_vector: {e}")
            });
            self
        }
        pub fn measured_cosine_similarity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.measured_cosine_similarity = value.try_into().map_err(|e| {
                format!("error converting supplied value for measured_cosine_similarity: {e}")
            });
            self
        }
        pub fn source_intent_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceIntentCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_intent_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_intent_cid: {e}"));
            self
        }
        pub fn target_intent_vector<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VectorEmbeddingState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_intent_vector = value.try_into().map_err(|e| {
                format!("error converting supplied value for target_intent_vector: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<TeleologicalIsometryReceipt> for super::TeleologicalIsometryReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TeleologicalIsometryReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                alignment_threshold_passed: value.alignment_threshold_passed?,
                forged_output_vector: value.forged_output_vector?,
                measured_cosine_similarity: value.measured_cosine_similarity?,
                source_intent_cid: value.source_intent_cid?,
                target_intent_vector: value.target_intent_vector?,
            })
        }
    }
    impl ::std::convert::From<super::TeleologicalIsometryReceipt> for TeleologicalIsometryReceipt {
        fn from(value: super::TeleologicalIsometryReceipt) -> Self {
            Self {
                alignment_threshold_passed: Ok(value.alignment_threshold_passed),
                forged_output_vector: Ok(value.forged_output_vector),
                measured_cosine_similarity: Ok(value.measured_cosine_similarity),
                source_intent_cid: Ok(value.source_intent_cid),
                target_intent_vector: Ok(value.target_intent_vector),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TemporalBoundsProfile {
        interval_class: ::std::result::Result<
            ::std::option::Option<super::CausalIntervalProfile>,
            ::std::string::String,
        >,
        probabilistic_end_interval: ::std::result::Result<
            ::std::option::Option<[::serde_json::Value; 2usize]>,
            ::std::string::String,
        >,
        probabilistic_start_interval: ::std::result::Result<
            ::std::option::Option<[::serde_json::Value; 2usize]>,
            ::std::string::String,
        >,
        temporal_certainty_score:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        valid_from: ::std::result::Result<f64, ::std::string::String>,
        valid_to: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
    }
    impl ::std::default::Default for TemporalBoundsProfile {
        fn default() -> Self {
            Self {
                interval_class: Ok(Default::default()),
                probabilistic_end_interval: Ok(Default::default()),
                probabilistic_start_interval: Ok(Default::default()),
                temporal_certainty_score: Ok(Default::default()),
                valid_from: Err("no value supplied for valid_from".to_string()),
                valid_to: Ok(Default::default()),
            }
        }
    }
    impl TemporalBoundsProfile {
        pub fn interval_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::CausalIntervalProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.interval_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for interval_class: {e}"));
            self
        }
        pub fn probabilistic_end_interval<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<[::serde_json::Value; 2usize]>>,
            T::Error: ::std::fmt::Display,
        {
            self.probabilistic_end_interval = value.try_into().map_err(|e| {
                format!("error converting supplied value for probabilistic_end_interval: {e}")
            });
            self
        }
        pub fn probabilistic_start_interval<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<[::serde_json::Value; 2usize]>>,
            T::Error: ::std::fmt::Display,
        {
            self.probabilistic_start_interval = value.try_into().map_err(|e| {
                format!("error converting supplied value for probabilistic_start_interval: {e}")
            });
            self
        }
        pub fn temporal_certainty_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_certainty_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_certainty_score: {e}")
            });
            self
        }
        pub fn valid_from<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.valid_from = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for valid_from: {e}"));
            self
        }
        pub fn valid_to<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.valid_to = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for valid_to: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TemporalBoundsProfile> for super::TemporalBoundsProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TemporalBoundsProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                interval_class: value.interval_class?,
                probabilistic_end_interval: value.probabilistic_end_interval?,
                probabilistic_start_interval: value.probabilistic_start_interval?,
                temporal_certainty_score: value.temporal_certainty_score?,
                valid_from: value.valid_from?,
                valid_to: value.valid_to?,
            })
        }
    }
    impl ::std::convert::From<super::TemporalBoundsProfile> for TemporalBoundsProfile {
        fn from(value: super::TemporalBoundsProfile) -> Self {
            Self {
                interval_class: Ok(value.interval_class),
                probabilistic_end_interval: Ok(value.probabilistic_end_interval),
                probabilistic_start_interval: Ok(value.probabilistic_start_interval),
                temporal_certainty_score: Ok(value.temporal_certainty_score),
                valid_from: Ok(value.valid_from),
                valid_to: Ok(value.valid_to),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TemporalCheckpointState {
        checkpoint_cid: ::std::result::Result<super::CheckpointCid, ::std::string::String>,
        ledger_index: ::std::result::Result<u64, ::std::string::String>,
        state_hash: ::std::result::Result<super::StateHash, ::std::string::String>,
    }
    impl ::std::default::Default for TemporalCheckpointState {
        fn default() -> Self {
            Self {
                checkpoint_cid: Err("no value supplied for checkpoint_cid".to_string()),
                ledger_index: Err("no value supplied for ledger_index".to_string()),
                state_hash: Err("no value supplied for state_hash".to_string()),
            }
        }
    }
    impl TemporalCheckpointState {
        pub fn checkpoint_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CheckpointCid>,
            T::Error: ::std::fmt::Display,
        {
            self.checkpoint_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for checkpoint_cid: {e}"));
            self
        }
        pub fn ledger_index<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.ledger_index = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for ledger_index: {e}"));
            self
        }
        pub fn state_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StateHash>,
            T::Error: ::std::fmt::Display,
        {
            self.state_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for state_hash: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TemporalCheckpointState> for super::TemporalCheckpointState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TemporalCheckpointState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                checkpoint_cid: value.checkpoint_cid?,
                ledger_index: value.ledger_index?,
                state_hash: value.state_hash?,
            })
        }
    }
    impl ::std::convert::From<super::TemporalCheckpointState> for TemporalCheckpointState {
        fn from(value: super::TemporalCheckpointState) -> Self {
            Self {
                checkpoint_cid: Ok(value.checkpoint_cid),
                ledger_index: Ok(value.ledger_index),
                state_hash: Ok(value.state_hash),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TemporalConflictResolutionPolicy {
        enforce_idempotence:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        merge_algebra: ::std::result::Result<super::MergeAlgebra, ::std::string::String>,
    }
    impl ::std::default::Default for TemporalConflictResolutionPolicy {
        fn default() -> Self {
            Self {
                enforce_idempotence: Ok(Default::default()),
                merge_algebra: Err("no value supplied for merge_algebra".to_string()),
            }
        }
    }
    impl TemporalConflictResolutionPolicy {
        pub fn enforce_idempotence<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.enforce_idempotence = value.try_into().map_err(|e| {
                format!("error converting supplied value for enforce_idempotence: {e}")
            });
            self
        }
        pub fn merge_algebra<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::MergeAlgebra>,
            T::Error: ::std::fmt::Display,
        {
            self.merge_algebra = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for merge_algebra: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TemporalConflictResolutionPolicy>
        for super::TemporalConflictResolutionPolicy
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TemporalConflictResolutionPolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                enforce_idempotence: value.enforce_idempotence?,
                merge_algebra: value.merge_algebra?,
            })
        }
    }
    impl ::std::convert::From<super::TemporalConflictResolutionPolicy>
        for TemporalConflictResolutionPolicy
    {
        fn from(value: super::TemporalConflictResolutionPolicy) -> Self {
            Self {
                enforce_idempotence: Ok(value.enforce_idempotence),
                merge_algebra: Ok(value.merge_algebra),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TemporalEdgeInvalidationIntent {
        causal_justification_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        invalidation_timestamp: ::std::result::Result<f64, ::std::string::String>,
        target_edge_cid: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for TemporalEdgeInvalidationIntent {
        fn default() -> Self {
            Self {
                causal_justification_cid: Err(
                    "no value supplied for causal_justification_cid".to_string()
                ),
                invalidation_timestamp: Err(
                    "no value supplied for invalidation_timestamp".to_string()
                ),
                target_edge_cid: Err("no value supplied for target_edge_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl TemporalEdgeInvalidationIntent {
        pub fn causal_justification_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_justification_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for causal_justification_cid: {e}")
            });
            self
        }
        pub fn invalidation_timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.invalidation_timestamp = value.try_into().map_err(|e| {
                format!("error converting supplied value for invalidation_timestamp: {e}")
            });
            self
        }
        pub fn target_edge_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.target_edge_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_edge_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TemporalEdgeInvalidationIntent>
        for super::TemporalEdgeInvalidationIntent
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TemporalEdgeInvalidationIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                causal_justification_cid: value.causal_justification_cid?,
                invalidation_timestamp: value.invalidation_timestamp?,
                target_edge_cid: value.target_edge_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::TemporalEdgeInvalidationIntent>
        for TemporalEdgeInvalidationIntent
    {
        fn from(value: super::TemporalEdgeInvalidationIntent) -> Self {
            Self {
                causal_justification_cid: Ok(value.causal_justification_cid),
                invalidation_timestamp: Ok(value.invalidation_timestamp),
                target_edge_cid: Ok(value.target_edge_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TemporalGraphCrdtManifest {
        add_set: ::std::result::Result<::std::vec::Vec<super::NodeCidState>, ::std::string::String>,
        author_node_cid: ::std::result::Result<super::AuthorNodeCid, ::std::string::String>,
        diff_cid: ::std::result::Result<super::DiffCid, ::std::string::String>,
        lamport_timestamp: ::std::result::Result<u64, ::std::string::String>,
        terminate_set: ::std::result::Result<
            ::std::vec::Vec<super::TemporalEdgeInvalidationIntent>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        vector_clock: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, u64>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for TemporalGraphCrdtManifest {
        fn default() -> Self {
            Self {
                add_set: Ok(Default::default()),
                author_node_cid: Err("no value supplied for author_node_cid".to_string()),
                diff_cid: Err("no value supplied for diff_cid".to_string()),
                lamport_timestamp: Err("no value supplied for lamport_timestamp".to_string()),
                terminate_set: Ok(Default::default()),
                topology_class: Ok(Default::default()),
                vector_clock: Err("no value supplied for vector_clock".to_string()),
            }
        }
    }
    impl TemporalGraphCrdtManifest {
        pub fn add_set<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::NodeCidState>>,
            T::Error: ::std::fmt::Display,
        {
            self.add_set = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for add_set: {e}"));
            self
        }
        pub fn author_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AuthorNodeCid>,
            T::Error: ::std::fmt::Display,
        {
            self.author_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for author_node_cid: {e}"));
            self
        }
        pub fn diff_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DiffCid>,
            T::Error: ::std::fmt::Display,
        {
            self.diff_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for diff_cid: {e}"));
            self
        }
        pub fn lamport_timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.lamport_timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for lamport_timestamp: {e}"));
            self
        }
        pub fn terminate_set<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::TemporalEdgeInvalidationIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.terminate_set = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for terminate_set: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn vector_clock<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::collections::HashMap<::std::string::String, u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.vector_clock = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for vector_clock: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TemporalGraphCrdtManifest> for super::TemporalGraphCrdtManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TemporalGraphCrdtManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                add_set: value.add_set?,
                author_node_cid: value.author_node_cid?,
                diff_cid: value.diff_cid?,
                lamport_timestamp: value.lamport_timestamp?,
                terminate_set: value.terminate_set?,
                topology_class: value.topology_class?,
                vector_clock: value.vector_clock?,
            })
        }
    }
    impl ::std::convert::From<super::TemporalGraphCrdtManifest> for TemporalGraphCrdtManifest {
        fn from(value: super::TemporalGraphCrdtManifest) -> Self {
            Self {
                add_set: Ok(value.add_set),
                author_node_cid: Ok(value.author_node_cid),
                diff_cid: Ok(value.diff_cid),
                lamport_timestamp: Ok(value.lamport_timestamp),
                terminate_set: Ok(value.terminate_set),
                topology_class: Ok(value.topology_class),
                vector_clock: Ok(value.vector_clock),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TerminalBufferState {
        env_variables_hash: ::std::result::Result<super::EnvVariablesHash, ::std::string::String>,
        stderr_hash: ::std::result::Result<super::StderrHash, ::std::string::String>,
        stdout_hash: ::std::result::Result<super::StdoutHash, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        working_directory: ::std::result::Result<super::WorkingDirectory, ::std::string::String>,
    }
    impl ::std::default::Default for TerminalBufferState {
        fn default() -> Self {
            Self {
                env_variables_hash: Err("no value supplied for env_variables_hash".to_string()),
                stderr_hash: Err("no value supplied for stderr_hash".to_string()),
                stdout_hash: Err("no value supplied for stdout_hash".to_string()),
                topology_class: Ok(Default::default()),
                working_directory: Err("no value supplied for working_directory".to_string()),
            }
        }
    }
    impl TerminalBufferState {
        pub fn env_variables_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EnvVariablesHash>,
            T::Error: ::std::fmt::Display,
        {
            self.env_variables_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for env_variables_hash: {e}")
            });
            self
        }
        pub fn stderr_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StderrHash>,
            T::Error: ::std::fmt::Display,
        {
            self.stderr_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for stderr_hash: {e}"));
            self
        }
        pub fn stdout_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::StdoutHash>,
            T::Error: ::std::fmt::Display,
        {
            self.stdout_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for stdout_hash: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn working_directory<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::WorkingDirectory>,
            T::Error: ::std::fmt::Display,
        {
            self.working_directory = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for working_directory: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TerminalBufferState> for super::TerminalBufferState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TerminalBufferState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                env_variables_hash: value.env_variables_hash?,
                stderr_hash: value.stderr_hash?,
                stdout_hash: value.stdout_hash?,
                topology_class: value.topology_class?,
                working_directory: value.working_directory?,
            })
        }
    }
    impl ::std::convert::From<super::TerminalBufferState> for TerminalBufferState {
        fn from(value: super::TerminalBufferState) -> Self {
            Self {
                env_variables_hash: Ok(value.env_variables_hash),
                stderr_hash: Ok(value.stderr_hash),
                stdout_hash: Ok(value.stdout_hash),
                topology_class: Ok(value.topology_class),
                working_directory: Ok(value.working_directory),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TerminalCognitiveEvent {
        final_critique_schema:
            ::std::result::Result<super::CognitiveCritiqueProfile, ::std::string::String>,
        last_rejected_hypothesis_hash:
            ::std::result::Result<super::LastRejectedHypothesisHash, ::std::string::String>,
        loops_exhausted: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        source_entity:
            ::std::result::Result<super::ContextualizedSourceState, ::std::string::String>,
    }
    impl ::std::default::Default for TerminalCognitiveEvent {
        fn default() -> Self {
            Self {
                final_critique_schema: Err(
                    "no value supplied for final_critique_schema".to_string()
                ),
                last_rejected_hypothesis_hash: Err(
                    "no value supplied for last_rejected_hypothesis_hash".to_string(),
                ),
                loops_exhausted: Err("no value supplied for loops_exhausted".to_string()),
                source_entity: Err("no value supplied for source_entity".to_string()),
            }
        }
    }
    impl TerminalCognitiveEvent {
        pub fn final_critique_schema<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CognitiveCritiqueProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.final_critique_schema = value.try_into().map_err(|e| {
                format!("error converting supplied value for final_critique_schema: {e}")
            });
            self
        }
        pub fn last_rejected_hypothesis_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::LastRejectedHypothesisHash>,
            T::Error: ::std::fmt::Display,
        {
            self.last_rejected_hypothesis_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for last_rejected_hypothesis_hash: {e}")
            });
            self
        }
        pub fn loops_exhausted<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.loops_exhausted = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for loops_exhausted: {e}"));
            self
        }
        pub fn source_entity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ContextualizedSourceState>,
            T::Error: ::std::fmt::Display,
        {
            self.source_entity = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for source_entity: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TerminalCognitiveEvent> for super::TerminalCognitiveEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TerminalCognitiveEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                final_critique_schema: value.final_critique_schema?,
                last_rejected_hypothesis_hash: value.last_rejected_hypothesis_hash?,
                loops_exhausted: value.loops_exhausted?,
                source_entity: value.source_entity?,
            })
        }
    }
    impl ::std::convert::From<super::TerminalCognitiveEvent> for TerminalCognitiveEvent {
        fn from(value: super::TerminalCognitiveEvent) -> Self {
            Self {
                final_critique_schema: Ok(value.final_critique_schema),
                last_rejected_hypothesis_hash: Ok(value.last_rejected_hypothesis_hash),
                loops_exhausted: Ok(value.loops_exhausted),
                source_entity: Ok(value.source_entity),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TerminalConditionContract {
        max_causal_depth: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
        minimum_budget_magnitude: ::std::result::Result<
            ::std::option::Option<::std::num::NonZeroU64>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for TerminalConditionContract {
        fn default() -> Self {
            Self {
                max_causal_depth: Ok(Default::default()),
                minimum_budget_magnitude: Ok(Default::default()),
            }
        }
    }
    impl TerminalConditionContract {
        pub fn max_causal_depth<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_causal_depth = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_causal_depth: {e}"));
            self
        }
        pub fn minimum_budget_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::num::NonZeroU64>>,
            T::Error: ::std::fmt::Display,
        {
            self.minimum_budget_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for minimum_budget_magnitude: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<TerminalConditionContract> for super::TerminalConditionContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TerminalConditionContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                max_causal_depth: value.max_causal_depth?,
                minimum_budget_magnitude: value.minimum_budget_magnitude?,
            })
        }
    }
    impl ::std::convert::From<super::TerminalConditionContract> for TerminalConditionContract {
        fn from(value: super::TerminalConditionContract) -> Self {
            Self {
                max_causal_depth: Ok(value.max_causal_depth),
                minimum_budget_magnitude: Ok(value.minimum_budget_magnitude),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TheoryOfMindSnapshot {
        assumed_shared_beliefs: ::std::result::Result<
            ::std::vec::Vec<super::AssumedSharedBeliefsItem>,
            ::std::string::String,
        >,
        empathy_confidence_score: ::std::result::Result<f64, ::std::string::String>,
        identified_knowledge_gaps: ::std::result::Result<
            ::std::vec::Vec<super::IdentifiedKnowledgeGapsItem>,
            ::std::string::String,
        >,
        target_agent_cid: ::std::result::Result<super::TargetAgentCid, ::std::string::String>,
    }
    impl ::std::default::Default for TheoryOfMindSnapshot {
        fn default() -> Self {
            Self {
                assumed_shared_beliefs: Err(
                    "no value supplied for assumed_shared_beliefs".to_string()
                ),
                empathy_confidence_score: Err(
                    "no value supplied for empathy_confidence_score".to_string()
                ),
                identified_knowledge_gaps: Err(
                    "no value supplied for identified_knowledge_gaps".to_string()
                ),
                target_agent_cid: Err("no value supplied for target_agent_cid".to_string()),
            }
        }
    }
    impl TheoryOfMindSnapshot {
        pub fn assumed_shared_beliefs<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AssumedSharedBeliefsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.assumed_shared_beliefs = value.try_into().map_err(|e| {
                format!("error converting supplied value for assumed_shared_beliefs: {e}")
            });
            self
        }
        pub fn empathy_confidence_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.empathy_confidence_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for empathy_confidence_score: {e}")
            });
            self
        }
        pub fn identified_knowledge_gaps<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::IdentifiedKnowledgeGapsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.identified_knowledge_gaps = value.try_into().map_err(|e| {
                format!("error converting supplied value for identified_knowledge_gaps: {e}")
            });
            self
        }
        pub fn target_agent_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetAgentCid>,
            T::Error: ::std::fmt::Display,
        {
            self.target_agent_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_agent_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TheoryOfMindSnapshot> for super::TheoryOfMindSnapshot {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TheoryOfMindSnapshot,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                assumed_shared_beliefs: value.assumed_shared_beliefs?,
                empathy_confidence_score: value.empathy_confidence_score?,
                identified_knowledge_gaps: value.identified_knowledge_gaps?,
                target_agent_cid: value.target_agent_cid?,
            })
        }
    }
    impl ::std::convert::From<super::TheoryOfMindSnapshot> for TheoryOfMindSnapshot {
        fn from(value: super::TheoryOfMindSnapshot) -> Self {
            Self {
                assumed_shared_beliefs: Ok(value.assumed_shared_beliefs),
                empathy_confidence_score: Ok(value.empathy_confidence_score),
                identified_knowledge_gaps: Ok(value.identified_knowledge_gaps),
                target_agent_cid: Ok(value.target_agent_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ThoughtBranchState {
        branch_cid: ::std::result::Result<super::BranchCid, ::std::string::String>,
        latent_content_hash: ::std::result::Result<super::LatentContentHash, ::std::string::String>,
        parent_branch_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        prm_score: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for ThoughtBranchState {
        fn default() -> Self {
            Self {
                branch_cid: Err("no value supplied for branch_cid".to_string()),
                latent_content_hash: Err("no value supplied for latent_content_hash".to_string()),
                parent_branch_cid: Ok(Default::default()),
                prm_score: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl ThoughtBranchState {
        pub fn branch_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::BranchCid>,
            T::Error: ::std::fmt::Display,
        {
            self.branch_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for branch_cid: {e}"));
            self
        }
        pub fn latent_content_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::LatentContentHash>,
            T::Error: ::std::fmt::Display,
        {
            self.latent_content_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for latent_content_hash: {e}")
            });
            self
        }
        pub fn parent_branch_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.parent_branch_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for parent_branch_cid: {e}"));
            self
        }
        pub fn prm_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.prm_score = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prm_score: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ThoughtBranchState> for super::ThoughtBranchState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ThoughtBranchState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                branch_cid: value.branch_cid?,
                latent_content_hash: value.latent_content_hash?,
                parent_branch_cid: value.parent_branch_cid?,
                prm_score: value.prm_score?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::ThoughtBranchState> for ThoughtBranchState {
        fn from(value: super::ThoughtBranchState) -> Self {
            Self {
                branch_cid: Ok(value.branch_cid),
                latent_content_hash: Ok(value.latent_content_hash),
                parent_branch_cid: Ok(value.parent_branch_cid),
                prm_score: Ok(value.prm_score),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TokenBurnReceipt {
        burn_magnitude: ::std::result::Result<u64, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        input_tokens: ::std::result::Result<u64, ::std::string::String>,
        output_tokens: ::std::result::Result<u64, ::std::string::String>,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        tool_invocation_cid: ::std::result::Result<super::ToolInvocationCid, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for TokenBurnReceipt {
        fn default() -> Self {
            Self {
                burn_magnitude: Err("no value supplied for burn_magnitude".to_string()),
                event_cid: Err("no value supplied for event_cid".to_string()),
                input_tokens: Err("no value supplied for input_tokens".to_string()),
                output_tokens: Err("no value supplied for output_tokens".to_string()),
                prior_event_hash: Ok(Default::default()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                tool_invocation_cid: Err("no value supplied for tool_invocation_cid".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl TokenBurnReceipt {
        pub fn burn_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.burn_magnitude = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for burn_magnitude: {e}"));
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn input_tokens<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.input_tokens = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for input_tokens: {e}"));
            self
        }
        pub fn output_tokens<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.output_tokens = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for output_tokens: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn tool_invocation_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ToolInvocationCid>,
            T::Error: ::std::fmt::Display,
        {
            self.tool_invocation_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for tool_invocation_cid: {e}")
            });
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TokenBurnReceipt> for super::TokenBurnReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TokenBurnReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                burn_magnitude: value.burn_magnitude?,
                event_cid: value.event_cid?,
                input_tokens: value.input_tokens?,
                output_tokens: value.output_tokens?,
                prior_event_hash: value.prior_event_hash?,
                timestamp: value.timestamp?,
                tool_invocation_cid: value.tool_invocation_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::TokenBurnReceipt> for TokenBurnReceipt {
        fn from(value: super::TokenBurnReceipt) -> Self {
            Self {
                burn_magnitude: Ok(value.burn_magnitude),
                event_cid: Ok(value.event_cid),
                input_tokens: Ok(value.input_tokens),
                output_tokens: Ok(value.output_tokens),
                prior_event_hash: Ok(value.prior_event_hash),
                timestamp: Ok(value.timestamp),
                tool_invocation_cid: Ok(value.tool_invocation_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ToolInvocationEvent {
        agent_attestation:
            ::std::result::Result<super::AgentAttestationReceipt, ::std::string::String>,
        authorized_budget_magnitude:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        event_cid: ::std::result::Result<super::EventCid, ::std::string::String>,
        parameters: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        prior_event_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        timestamp: ::std::result::Result<f64, ::std::string::String>,
        tool_name: ::std::result::Result<super::ToolName, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        zk_proof: ::std::result::Result<super::ZeroKnowledgeReceipt, ::std::string::String>,
    }
    impl ::std::default::Default for ToolInvocationEvent {
        fn default() -> Self {
            Self {
                agent_attestation: Err("no value supplied for agent_attestation".to_string()),
                authorized_budget_magnitude: Err(
                    "no value supplied for authorized_budget_magnitude".to_string(),
                ),
                event_cid: Err("no value supplied for event_cid".to_string()),
                parameters: Err("no value supplied for parameters".to_string()),
                prior_event_hash: Ok(Default::default()),
                timestamp: Err("no value supplied for timestamp".to_string()),
                tool_name: Err("no value supplied for tool_name".to_string()),
                topology_class: Ok(Default::default()),
                zk_proof: Err("no value supplied for zk_proof".to_string()),
            }
        }
    }
    impl ToolInvocationEvent {
        pub fn agent_attestation<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AgentAttestationReceipt>,
            T::Error: ::std::fmt::Display,
        {
            self.agent_attestation = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for agent_attestation: {e}"));
            self
        }
        pub fn authorized_budget_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.authorized_budget_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for authorized_budget_magnitude: {e}")
            });
            self
        }
        pub fn event_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EventCid>,
            T::Error: ::std::fmt::Display,
        {
            self.event_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for event_cid: {e}"));
            self
        }
        pub fn parameters<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.parameters = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for parameters: {e}"));
            self
        }
        pub fn prior_event_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.prior_event_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for prior_event_hash: {e}"));
            self
        }
        pub fn timestamp<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.timestamp = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for timestamp: {e}"));
            self
        }
        pub fn tool_name<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ToolName>,
            T::Error: ::std::fmt::Display,
        {
            self.tool_name = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for tool_name: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
        pub fn zk_proof<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ZeroKnowledgeReceipt>,
            T::Error: ::std::fmt::Display,
        {
            self.zk_proof = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for zk_proof: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ToolInvocationEvent> for super::ToolInvocationEvent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ToolInvocationEvent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                agent_attestation: value.agent_attestation?,
                authorized_budget_magnitude: value.authorized_budget_magnitude?,
                event_cid: value.event_cid?,
                parameters: value.parameters?,
                prior_event_hash: value.prior_event_hash?,
                timestamp: value.timestamp?,
                tool_name: value.tool_name?,
                topology_class: value.topology_class?,
                zk_proof: value.zk_proof?,
            })
        }
    }
    impl ::std::convert::From<super::ToolInvocationEvent> for ToolInvocationEvent {
        fn from(value: super::ToolInvocationEvent) -> Self {
            Self {
                agent_attestation: Ok(value.agent_attestation),
                authorized_budget_magnitude: Ok(value.authorized_budget_magnitude),
                event_cid: Ok(value.event_cid),
                parameters: Ok(value.parameters),
                prior_event_hash: Ok(value.prior_event_hash),
                timestamp: Ok(value.timestamp),
                tool_name: Ok(value.tool_name),
                topology_class: Ok(value.topology_class),
                zk_proof: Ok(value.zk_proof),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TopologicalFidelityReceipt {
        contextual_completeness_score: ::std::result::Result<f64, ::std::string::String>,
        surrounding_token_density: ::std::result::Result<u64, ::std::string::String>,
    }
    impl ::std::default::Default for TopologicalFidelityReceipt {
        fn default() -> Self {
            Self {
                contextual_completeness_score: Err(
                    "no value supplied for contextual_completeness_score".to_string(),
                ),
                surrounding_token_density: Err(
                    "no value supplied for surrounding_token_density".to_string()
                ),
            }
        }
    }
    impl TopologicalFidelityReceipt {
        pub fn contextual_completeness_score<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.contextual_completeness_score = value.try_into().map_err(|e| {
                format!("error converting supplied value for contextual_completeness_score: {e}")
            });
            self
        }
        pub fn surrounding_token_density<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.surrounding_token_density = value.try_into().map_err(|e| {
                format!("error converting supplied value for surrounding_token_density: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<TopologicalFidelityReceipt> for super::TopologicalFidelityReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TopologicalFidelityReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                contextual_completeness_score: value.contextual_completeness_score?,
                surrounding_token_density: value.surrounding_token_density?,
            })
        }
    }
    impl ::std::convert::From<super::TopologicalFidelityReceipt> for TopologicalFidelityReceipt {
        fn from(value: super::TopologicalFidelityReceipt) -> Self {
            Self {
                contextual_completeness_score: Ok(value.contextual_completeness_score),
                surrounding_token_density: Ok(value.surrounding_token_density),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TopologicalProjectionIntent {
        epistemic_status: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        isomorphism_confidence: ::std::result::Result<f64, ::std::string::String>,
        lossy_translation_divergence: ::std::result::Result<
            ::std::vec::Vec<super::LossyTranslationDivergenceItem>,
            ::std::string::String,
        >,
        projection_cid: ::std::result::Result<super::ProjectionCid, ::std::string::String>,
        provenance_trace_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        source_superposition_cid:
            ::std::result::Result<super::SourceSuperpositionCid, ::std::string::String>,
        target_topology: ::std::result::Result<super::TargetTopologyProfile, ::std::string::String>,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for TopologicalProjectionIntent {
        fn default() -> Self {
            Self {
                epistemic_status: Ok(Default::default()),
                isomorphism_confidence: Err(
                    "no value supplied for isomorphism_confidence".to_string()
                ),
                lossy_translation_divergence: Err(
                    "no value supplied for lossy_translation_divergence".to_string(),
                ),
                projection_cid: Err("no value supplied for projection_cid".to_string()),
                provenance_trace_cid: Ok(Default::default()),
                source_superposition_cid: Err(
                    "no value supplied for source_superposition_cid".to_string()
                ),
                target_topology: Err("no value supplied for target_topology".to_string()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl TopologicalProjectionIntent {
        pub fn epistemic_status<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_status = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for epistemic_status: {e}"));
            self
        }
        pub fn isomorphism_confidence<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.isomorphism_confidence = value.try_into().map_err(|e| {
                format!("error converting supplied value for isomorphism_confidence: {e}")
            });
            self
        }
        pub fn lossy_translation_divergence<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::LossyTranslationDivergenceItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.lossy_translation_divergence = value.try_into().map_err(|e| {
                format!("error converting supplied value for lossy_translation_divergence: {e}")
            });
            self
        }
        pub fn projection_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProjectionCid>,
            T::Error: ::std::fmt::Display,
        {
            self.projection_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for projection_cid: {e}"));
            self
        }
        pub fn provenance_trace_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.provenance_trace_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for provenance_trace_cid: {e}")
            });
            self
        }
        pub fn source_superposition_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SourceSuperpositionCid>,
            T::Error: ::std::fmt::Display,
        {
            self.source_superposition_cid = value.try_into().map_err(|e| {
                format!("error converting supplied value for source_superposition_cid: {e}")
            });
            self
        }
        pub fn target_topology<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TargetTopologyProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.target_topology = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_topology: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TopologicalProjectionIntent> for super::TopologicalProjectionIntent {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TopologicalProjectionIntent,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                epistemic_status: value.epistemic_status?,
                isomorphism_confidence: value.isomorphism_confidence?,
                lossy_translation_divergence: value.lossy_translation_divergence?,
                projection_cid: value.projection_cid?,
                provenance_trace_cid: value.provenance_trace_cid?,
                source_superposition_cid: value.source_superposition_cid?,
                target_topology: value.target_topology?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::TopologicalProjectionIntent> for TopologicalProjectionIntent {
        fn from(value: super::TopologicalProjectionIntent) -> Self {
            Self {
                epistemic_status: Ok(value.epistemic_status),
                isomorphism_confidence: Ok(value.isomorphism_confidence),
                lossy_translation_divergence: Ok(value.lossy_translation_divergence),
                projection_cid: Ok(value.projection_cid),
                provenance_trace_cid: Ok(value.provenance_trace_cid),
                source_superposition_cid: Ok(value.source_superposition_cid),
                target_topology: Ok(value.target_topology),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TopologicalRetrievalContract {
        allowed_causal_relationships: ::std::result::Result<
            ::std::vec::Vec<super::AllowedCausalRelationshipsItem>,
            ::std::string::String,
        >,
        enforce_isometry: ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        max_hop_depth: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for TopologicalRetrievalContract {
        fn default() -> Self {
            Self {
                allowed_causal_relationships: Err(
                    "no value supplied for allowed_causal_relationships".to_string(),
                ),
                enforce_isometry: Ok(Default::default()),
                max_hop_depth: Err("no value supplied for max_hop_depth".to_string()),
            }
        }
    }
    impl TopologicalRetrievalContract {
        pub fn allowed_causal_relationships<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::AllowedCausalRelationshipsItem>>,
            T::Error: ::std::fmt::Display,
        {
            self.allowed_causal_relationships = value.try_into().map_err(|e| {
                format!("error converting supplied value for allowed_causal_relationships: {e}")
            });
            self
        }
        pub fn enforce_isometry<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.enforce_isometry = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for enforce_isometry: {e}"));
            self
        }
        pub fn max_hop_depth<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_hop_depth = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_hop_depth: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TopologicalRetrievalContract> for super::TopologicalRetrievalContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TopologicalRetrievalContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                allowed_causal_relationships: value.allowed_causal_relationships?,
                enforce_isometry: value.enforce_isometry?,
                max_hop_depth: value.max_hop_depth?,
            })
        }
    }
    impl ::std::convert::From<super::TopologicalRetrievalContract> for TopologicalRetrievalContract {
        fn from(value: super::TopologicalRetrievalContract) -> Self {
            Self {
                allowed_causal_relationships: Ok(value.allowed_causal_relationships),
                enforce_isometry: Ok(value.enforce_isometry),
                max_hop_depth: Ok(value.max_hop_depth),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TraceContextState {
        causal_clock: ::std::result::Result<::std::option::Option<u64>, ::std::string::String>,
        parent_span_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        span_cid: ::std::result::Result<super::SpanCid, ::std::string::String>,
        trace_cid: ::std::result::Result<super::TraceCid, ::std::string::String>,
    }
    impl ::std::default::Default for TraceContextState {
        fn default() -> Self {
            Self {
                causal_clock: Ok(Default::default()),
                parent_span_cid: Ok(Default::default()),
                span_cid: Err("no value supplied for span_cid".to_string()),
                trace_cid: Err("no value supplied for trace_cid".to_string()),
            }
        }
    }
    impl TraceContextState {
        pub fn causal_clock<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<u64>>,
            T::Error: ::std::fmt::Display,
        {
            self.causal_clock = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for causal_clock: {e}"));
            self
        }
        pub fn parent_span_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.parent_span_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for parent_span_cid: {e}"));
            self
        }
        pub fn span_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SpanCid>,
            T::Error: ::std::fmt::Display,
        {
            self.span_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for span_cid: {e}"));
            self
        }
        pub fn trace_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::TraceCid>,
            T::Error: ::std::fmt::Display,
        {
            self.trace_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for trace_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TraceContextState> for super::TraceContextState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TraceContextState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                causal_clock: value.causal_clock?,
                parent_span_cid: value.parent_span_cid?,
                span_cid: value.span_cid?,
                trace_cid: value.trace_cid?,
            })
        }
    }
    impl ::std::convert::From<super::TraceContextState> for TraceContextState {
        fn from(value: super::TraceContextState) -> Self {
            Self {
                causal_clock: Ok(value.causal_clock),
                parent_span_cid: Ok(value.parent_span_cid),
                span_cid: Ok(value.span_cid),
                trace_cid: Ok(value.trace_cid),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TransitionEdgeProfile {
        compute_weight_magnitude: ::std::result::Result<u64, ::std::string::String>,
        eval_strategy: ::std::result::Result<
            ::std::option::Option<super::EvalStrategy>,
            ::std::string::String,
        >,
        payload_mappings: ::std::result::Result<
            ::std::vec::Vec<super::EdgeMappingContract>,
            ::std::string::String,
        >,
        probability_weight: ::std::result::Result<f64, ::std::string::String>,
        target_intent: ::std::result::Result<
            ::std::option::Option<super::SemanticDiscoveryIntent>,
            ::std::string::String,
        >,
        target_node_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        topology_class: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for TransitionEdgeProfile {
        fn default() -> Self {
            Self {
                compute_weight_magnitude: Err(
                    "no value supplied for compute_weight_magnitude".to_string()
                ),
                eval_strategy: Ok(Default::default()),
                payload_mappings: Ok(Default::default()),
                probability_weight: Err("no value supplied for probability_weight".to_string()),
                target_intent: Ok(Default::default()),
                target_node_cid: Ok(Default::default()),
                topology_class: Ok(Default::default()),
            }
        }
    }
    impl TransitionEdgeProfile {
        pub fn compute_weight_magnitude<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<u64>,
            T::Error: ::std::fmt::Display,
        {
            self.compute_weight_magnitude = value.try_into().map_err(|e| {
                format!("error converting supplied value for compute_weight_magnitude: {e}")
            });
            self
        }
        pub fn eval_strategy<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EvalStrategy>>,
            T::Error: ::std::fmt::Display,
        {
            self.eval_strategy = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for eval_strategy: {e}"));
            self
        }
        pub fn payload_mappings<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::vec::Vec<super::EdgeMappingContract>>,
            T::Error: ::std::fmt::Display,
        {
            self.payload_mappings = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for payload_mappings: {e}"));
            self
        }
        pub fn probability_weight<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.probability_weight = value.try_into().map_err(|e| {
                format!("error converting supplied value for probability_weight: {e}")
            });
            self
        }
        pub fn target_intent<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::SemanticDiscoveryIntent>>,
            T::Error: ::std::fmt::Display,
        {
            self.target_intent = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_intent: {e}"));
            self
        }
        pub fn target_node_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.target_node_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for target_node_cid: {e}"));
            self
        }
        pub fn topology_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.topology_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<TransitionEdgeProfile> for super::TransitionEdgeProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TransitionEdgeProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                compute_weight_magnitude: value.compute_weight_magnitude?,
                eval_strategy: value.eval_strategy?,
                payload_mappings: value.payload_mappings?,
                probability_weight: value.probability_weight?,
                target_intent: value.target_intent?,
                target_node_cid: value.target_node_cid?,
                topology_class: value.topology_class?,
            })
        }
    }
    impl ::std::convert::From<super::TransitionEdgeProfile> for TransitionEdgeProfile {
        fn from(value: super::TransitionEdgeProfile) -> Self {
            Self {
                compute_weight_magnitude: Ok(value.compute_weight_magnitude),
                eval_strategy: Ok(value.eval_strategy),
                payload_mappings: Ok(value.payload_mappings),
                probability_weight: Ok(value.probability_weight),
                target_intent: Ok(value.target_intent),
                target_node_cid: Ok(value.target_node_cid),
                topology_class: Ok(value.topology_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct TruthMaintenancePolicy {
        decay_propagation_rate: ::std::result::Result<f64, ::std::string::String>,
        enforce_cross_agent_quarantine:
            ::std::result::Result<::std::option::Option<bool>, ::std::string::String>,
        epistemic_quarantine_threshold: ::std::result::Result<f64, ::std::string::String>,
        max_cascade_depth: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        max_quarantine_blast_radius:
            ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
        retroactive_falsification_mode: ::std::result::Result<
            ::std::option::Option<super::RetroactiveFalsificationMode>,
            ::std::string::String,
        >,
    }
    impl ::std::default::Default for TruthMaintenancePolicy {
        fn default() -> Self {
            Self {
                decay_propagation_rate: Err(
                    "no value supplied for decay_propagation_rate".to_string()
                ),
                enforce_cross_agent_quarantine: Ok(Default::default()),
                epistemic_quarantine_threshold: Err(
                    "no value supplied for epistemic_quarantine_threshold".to_string(),
                ),
                max_cascade_depth: Err("no value supplied for max_cascade_depth".to_string()),
                max_quarantine_blast_radius: Err(
                    "no value supplied for max_quarantine_blast_radius".to_string(),
                ),
                retroactive_falsification_mode: Ok(Default::default()),
            }
        }
    }
    impl TruthMaintenancePolicy {
        pub fn decay_propagation_rate<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.decay_propagation_rate = value.try_into().map_err(|e| {
                format!("error converting supplied value for decay_propagation_rate: {e}")
            });
            self
        }
        pub fn enforce_cross_agent_quarantine<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<bool>>,
            T::Error: ::std::fmt::Display,
        {
            self.enforce_cross_agent_quarantine = value.try_into().map_err(|e| {
                format!("error converting supplied value for enforce_cross_agent_quarantine: {e}")
            });
            self
        }
        pub fn epistemic_quarantine_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.epistemic_quarantine_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for epistemic_quarantine_threshold: {e}")
            });
            self
        }
        pub fn max_cascade_depth<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_cascade_depth = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for max_cascade_depth: {e}"));
            self
        }
        pub fn max_quarantine_blast_radius<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.max_quarantine_blast_radius = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_quarantine_blast_radius: {e}")
            });
            self
        }
        pub fn retroactive_falsification_mode<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::RetroactiveFalsificationMode>>,
            T::Error: ::std::fmt::Display,
        {
            self.retroactive_falsification_mode = value.try_into().map_err(|e| {
                format!("error converting supplied value for retroactive_falsification_mode: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<TruthMaintenancePolicy> for super::TruthMaintenancePolicy {
        type Error = super::error::ConversionError;
        fn try_from(
            value: TruthMaintenancePolicy,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                decay_propagation_rate: value.decay_propagation_rate?,
                enforce_cross_agent_quarantine: value.enforce_cross_agent_quarantine?,
                epistemic_quarantine_threshold: value.epistemic_quarantine_threshold?,
                max_cascade_depth: value.max_cascade_depth?,
                max_quarantine_blast_radius: value.max_quarantine_blast_radius?,
                retroactive_falsification_mode: value.retroactive_falsification_mode?,
            })
        }
    }
    impl ::std::convert::From<super::TruthMaintenancePolicy> for TruthMaintenancePolicy {
        fn from(value: super::TruthMaintenancePolicy) -> Self {
            Self {
                decay_propagation_rate: Ok(value.decay_propagation_rate),
                enforce_cross_agent_quarantine: Ok(value.enforce_cross_agent_quarantine),
                epistemic_quarantine_threshold: Ok(value.epistemic_quarantine_threshold),
                max_cascade_depth: Ok(value.max_cascade_depth),
                max_quarantine_blast_radius: Ok(value.max_quarantine_blast_radius),
                retroactive_falsification_mode: Ok(value.retroactive_falsification_mode),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct UtilityJustificationGraphReceipt {
        degrading_vectors: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, f64>,
            ::std::string::String,
        >,
        ensemble_spec: ::std::result::Result<
            ::std::option::Option<super::EnsembleTopologyProfile>,
            ::std::string::String,
        >,
        optimizing_vectors: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, f64>,
            ::std::string::String,
        >,
        superposition_variance_threshold: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for UtilityJustificationGraphReceipt {
        fn default() -> Self {
            Self {
                degrading_vectors: Ok(Default::default()),
                ensemble_spec: Ok(Default::default()),
                optimizing_vectors: Ok(Default::default()),
                superposition_variance_threshold: Err(
                    "no value supplied for superposition_variance_threshold".to_string(),
                ),
            }
        }
    }
    impl UtilityJustificationGraphReceipt {
        pub fn degrading_vectors<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::collections::HashMap<::std::string::String, f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.degrading_vectors = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for degrading_vectors: {e}"));
            self
        }
        pub fn ensemble_spec<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::EnsembleTopologyProfile>>,
            T::Error: ::std::fmt::Display,
        {
            self.ensemble_spec = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for ensemble_spec: {e}"));
            self
        }
        pub fn optimizing_vectors<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::collections::HashMap<::std::string::String, f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.optimizing_vectors = value.try_into().map_err(|e| {
                format!("error converting supplied value for optimizing_vectors: {e}")
            });
            self
        }
        pub fn superposition_variance_threshold<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.superposition_variance_threshold = value.try_into().map_err(|e| {
                format!("error converting supplied value for superposition_variance_threshold: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<UtilityJustificationGraphReceipt>
        for super::UtilityJustificationGraphReceipt
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: UtilityJustificationGraphReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                degrading_vectors: value.degrading_vectors?,
                ensemble_spec: value.ensemble_spec?,
                optimizing_vectors: value.optimizing_vectors?,
                superposition_variance_threshold: value.superposition_variance_threshold?,
            })
        }
    }
    impl ::std::convert::From<super::UtilityJustificationGraphReceipt>
        for UtilityJustificationGraphReceipt
    {
        fn from(value: super::UtilityJustificationGraphReceipt) -> Self {
            Self {
                degrading_vectors: Ok(value.degrading_vectors),
                ensemble_spec: Ok(value.ensemble_spec),
                optimizing_vectors: Ok(value.optimizing_vectors),
                superposition_variance_threshold: Ok(value.superposition_variance_threshold),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct VectorEmbeddingState {
        dimensionality: ::std::result::Result<i64, ::std::string::String>,
        foundation_matrix_name:
            ::std::result::Result<super::FoundationMatrixName, ::std::string::String>,
        temporal_decay_function: ::std::result::Result<
            ::std::option::Option<super::TemporalDecayFunction>,
            ::std::string::String,
        >,
        time_derivative_vector: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        vector_base64: ::std::result::Result<super::VectorBase64, ::std::string::String>,
    }
    impl ::std::default::Default for VectorEmbeddingState {
        fn default() -> Self {
            Self {
                dimensionality: Err("no value supplied for dimensionality".to_string()),
                foundation_matrix_name: Err(
                    "no value supplied for foundation_matrix_name".to_string()
                ),
                temporal_decay_function: Ok(Default::default()),
                time_derivative_vector: Ok(Default::default()),
                vector_base64: Err("no value supplied for vector_base64".to_string()),
            }
        }
    }
    impl VectorEmbeddingState {
        pub fn dimensionality<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<i64>,
            T::Error: ::std::fmt::Display,
        {
            self.dimensionality = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for dimensionality: {e}"));
            self
        }
        pub fn foundation_matrix_name<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::FoundationMatrixName>,
            T::Error: ::std::fmt::Display,
        {
            self.foundation_matrix_name = value.try_into().map_err(|e| {
                format!("error converting supplied value for foundation_matrix_name: {e}")
            });
            self
        }
        pub fn temporal_decay_function<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::TemporalDecayFunction>>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_decay_function = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_decay_function: {e}")
            });
            self
        }
        pub fn time_derivative_vector<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.time_derivative_vector = value.try_into().map_err(|e| {
                format!("error converting supplied value for time_derivative_vector: {e}")
            });
            self
        }
        pub fn vector_base64<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VectorBase64>,
            T::Error: ::std::fmt::Display,
        {
            self.vector_base64 = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for vector_base64: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<VectorEmbeddingState> for super::VectorEmbeddingState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: VectorEmbeddingState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                dimensionality: value.dimensionality?,
                foundation_matrix_name: value.foundation_matrix_name?,
                temporal_decay_function: value.temporal_decay_function?,
                time_derivative_vector: value.time_derivative_vector?,
                vector_base64: value.vector_base64?,
            })
        }
    }
    impl ::std::convert::From<super::VectorEmbeddingState> for VectorEmbeddingState {
        fn from(value: super::VectorEmbeddingState) -> Self {
            Self {
                dimensionality: Ok(value.dimensionality),
                foundation_matrix_name: Ok(value.foundation_matrix_name),
                temporal_decay_function: Ok(value.temporal_decay_function),
                time_derivative_vector: Ok(value.time_derivative_vector),
                vector_base64: Ok(value.vector_base64),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct VerifiableCredentialPresentationReceipt {
        authorization_claims: ::std::result::Result<
            ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            ::std::string::String,
        >,
        cryptographic_proof_blob:
            ::std::result::Result<super::CryptographicProofBlob, ::std::string::String>,
        issuer_did: ::std::result::Result<super::NodeCidState, ::std::string::String>,
        presentation_format:
            ::std::result::Result<super::PresentationFormat, ::std::string::String>,
    }
    impl ::std::default::Default for VerifiableCredentialPresentationReceipt {
        fn default() -> Self {
            Self {
                authorization_claims: Err("no value supplied for authorization_claims".to_string()),
                cryptographic_proof_blob: Err(
                    "no value supplied for cryptographic_proof_blob".to_string()
                ),
                issuer_did: Err("no value supplied for issuer_did".to_string()),
                presentation_format: Err("no value supplied for presentation_format".to_string()),
            }
        }
    }
    impl VerifiableCredentialPresentationReceipt {
        pub fn authorization_claims<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<::std::string::String, super::JsonPrimitiveState>,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.authorization_claims = value.try_into().map_err(|e| {
                format!("error converting supplied value for authorization_claims: {e}")
            });
            self
        }
        pub fn cryptographic_proof_blob<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CryptographicProofBlob>,
            T::Error: ::std::fmt::Display,
        {
            self.cryptographic_proof_blob = value.try_into().map_err(|e| {
                format!("error converting supplied value for cryptographic_proof_blob: {e}")
            });
            self
        }
        pub fn issuer_did<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::NodeCidState>,
            T::Error: ::std::fmt::Display,
        {
            self.issuer_did = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for issuer_did: {e}"));
            self
        }
        pub fn presentation_format<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PresentationFormat>,
            T::Error: ::std::fmt::Display,
        {
            self.presentation_format = value.try_into().map_err(|e| {
                format!("error converting supplied value for presentation_format: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<VerifiableCredentialPresentationReceipt>
        for super::VerifiableCredentialPresentationReceipt
    {
        type Error = super::error::ConversionError;
        fn try_from(
            value: VerifiableCredentialPresentationReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                authorization_claims: value.authorization_claims?,
                cryptographic_proof_blob: value.cryptographic_proof_blob?,
                issuer_did: value.issuer_did?,
                presentation_format: value.presentation_format?,
            })
        }
    }
    impl ::std::convert::From<super::VerifiableCredentialPresentationReceipt>
        for VerifiableCredentialPresentationReceipt
    {
        fn from(value: super::VerifiableCredentialPresentationReceipt) -> Self {
            Self {
                authorization_claims: Ok(value.authorization_claims),
                cryptographic_proof_blob: Ok(value.cryptographic_proof_blob),
                issuer_did: Ok(value.issuer_did),
                presentation_format: Ok(value.presentation_format),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct VerifiableEntropyReceipt {
        public_key: ::std::result::Result<super::PublicKey, ::std::string::String>,
        seed_hash: ::std::result::Result<super::SeedHash, ::std::string::String>,
        vrf_proof: ::std::result::Result<super::VrfProof, ::std::string::String>,
    }
    impl ::std::default::Default for VerifiableEntropyReceipt {
        fn default() -> Self {
            Self {
                public_key: Err("no value supplied for public_key".to_string()),
                seed_hash: Err("no value supplied for seed_hash".to_string()),
                vrf_proof: Err("no value supplied for vrf_proof".to_string()),
            }
        }
    }
    impl VerifiableEntropyReceipt {
        pub fn public_key<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PublicKey>,
            T::Error: ::std::fmt::Display,
        {
            self.public_key = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for public_key: {e}"));
            self
        }
        pub fn seed_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SeedHash>,
            T::Error: ::std::fmt::Display,
        {
            self.seed_hash = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for seed_hash: {e}"));
            self
        }
        pub fn vrf_proof<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VrfProof>,
            T::Error: ::std::fmt::Display,
        {
            self.vrf_proof = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for vrf_proof: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<VerifiableEntropyReceipt> for super::VerifiableEntropyReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: VerifiableEntropyReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                public_key: value.public_key?,
                seed_hash: value.seed_hash?,
                vrf_proof: value.vrf_proof?,
            })
        }
    }
    impl ::std::convert::From<super::VerifiableEntropyReceipt> for VerifiableEntropyReceipt {
        fn from(value: super::VerifiableEntropyReceipt) -> Self {
            Self {
                public_key: Ok(value.public_key),
                seed_hash: Ok(value.seed_hash),
                vrf_proof: Ok(value.vrf_proof),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ViewportProjectionContract {
        clipping_plane_far: ::std::result::Result<f64, ::std::string::String>,
        clipping_plane_near: ::std::result::Result<f64, ::std::string::String>,
        field_of_view_degrees:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        projection_class: ::std::result::Result<super::ProjectionClass, ::std::string::String>,
    }
    impl ::std::default::Default for ViewportProjectionContract {
        fn default() -> Self {
            Self {
                clipping_plane_far: Err("no value supplied for clipping_plane_far".to_string()),
                clipping_plane_near: Err("no value supplied for clipping_plane_near".to_string()),
                field_of_view_degrees: Ok(Default::default()),
                projection_class: Err("no value supplied for projection_class".to_string()),
            }
        }
    }
    impl ViewportProjectionContract {
        pub fn clipping_plane_far<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.clipping_plane_far = value.try_into().map_err(|e| {
                format!("error converting supplied value for clipping_plane_far: {e}")
            });
            self
        }
        pub fn clipping_plane_near<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.clipping_plane_near = value.try_into().map_err(|e| {
                format!("error converting supplied value for clipping_plane_near: {e}")
            });
            self
        }
        pub fn field_of_view_degrees<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.field_of_view_degrees = value.try_into().map_err(|e| {
                format!("error converting supplied value for field_of_view_degrees: {e}")
            });
            self
        }
        pub fn projection_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProjectionClass>,
            T::Error: ::std::fmt::Display,
        {
            self.projection_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for projection_class: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ViewportProjectionContract> for super::ViewportProjectionContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ViewportProjectionContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                clipping_plane_far: value.clipping_plane_far?,
                clipping_plane_near: value.clipping_plane_near?,
                field_of_view_degrees: value.field_of_view_degrees?,
                projection_class: value.projection_class?,
            })
        }
    }
    impl ::std::convert::From<super::ViewportProjectionContract> for ViewportProjectionContract {
        fn from(value: super::ViewportProjectionContract) -> Self {
            Self {
                clipping_plane_far: Ok(value.clipping_plane_far),
                clipping_plane_near: Ok(value.clipping_plane_near),
                field_of_view_degrees: Ok(value.field_of_view_degrees),
                projection_class: Ok(value.projection_class),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct VisualEncodingProfile {
        channel: ::std::result::Result<super::Channel, ::std::string::String>,
        field: ::std::result::Result<super::Field, ::std::string::String>,
        scale:
            ::std::result::Result<::std::option::Option<super::ScalePolicy>, ::std::string::String>,
    }
    impl ::std::default::Default for VisualEncodingProfile {
        fn default() -> Self {
            Self {
                channel: Err("no value supplied for channel".to_string()),
                field: Err("no value supplied for field".to_string()),
                scale: Ok(Default::default()),
            }
        }
    }
    impl VisualEncodingProfile {
        pub fn channel<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Channel>,
            T::Error: ::std::fmt::Display,
        {
            self.channel = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for channel: {e}"));
            self
        }
        pub fn field<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Field>,
            T::Error: ::std::fmt::Display,
        {
            self.field = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for field: {e}"));
            self
        }
        pub fn scale<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ScalePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.scale = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for scale: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<VisualEncodingProfile> for super::VisualEncodingProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: VisualEncodingProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                channel: value.channel?,
                field: value.field?,
                scale: value.scale?,
            })
        }
    }
    impl ::std::convert::From<super::VisualEncodingProfile> for VisualEncodingProfile {
        fn from(value: super::VisualEncodingProfile) -> Self {
            Self {
                channel: Ok(value.channel),
                field: Ok(value.field),
                scale: Ok(value.scale),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct VolumetricBoundingProfile {
        center_transform: ::std::result::Result<super::Se3TransformProfile, ::std::string::String>,
        extents_x: ::std::result::Result<f64, ::std::string::String>,
        extents_y: ::std::result::Result<f64, ::std::string::String>,
        extents_z: ::std::result::Result<f64, ::std::string::String>,
    }
    impl ::std::default::Default for VolumetricBoundingProfile {
        fn default() -> Self {
            Self {
                center_transform: Err("no value supplied for center_transform".to_string()),
                extents_x: Err("no value supplied for extents_x".to_string()),
                extents_y: Err("no value supplied for extents_y".to_string()),
                extents_z: Err("no value supplied for extents_z".to_string()),
            }
        }
    }
    impl VolumetricBoundingProfile {
        pub fn center_transform<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Se3TransformProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.center_transform = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for center_transform: {e}"));
            self
        }
        pub fn extents_x<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.extents_x = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for extents_x: {e}"));
            self
        }
        pub fn extents_y<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.extents_y = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for extents_y: {e}"));
            self
        }
        pub fn extents_z<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<f64>,
            T::Error: ::std::fmt::Display,
        {
            self.extents_z = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for extents_z: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<VolumetricBoundingProfile> for super::VolumetricBoundingProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: VolumetricBoundingProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                center_transform: value.center_transform?,
                extents_x: value.extents_x?,
                extents_y: value.extents_y?,
                extents_z: value.extents_z?,
            })
        }
    }
    impl ::std::convert::From<super::VolumetricBoundingProfile> for VolumetricBoundingProfile {
        fn from(value: super::VolumetricBoundingProfile) -> Self {
            Self {
                center_transform: Ok(value.center_transform),
                extents_x: Ok(value.extents_x),
                extents_y: Ok(value.extents_y),
                extents_z: Ok(value.extents_z),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct VolumetricEdgeProfile {
        curve_class: ::std::result::Result<super::CurveClass, ::std::string::String>,
        edge_thickness: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        flow_velocity: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        spatial_repulsion_scalar:
            ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
        tension: ::std::result::Result<::std::option::Option<f64>, ::std::string::String>,
    }
    impl ::std::default::Default for VolumetricEdgeProfile {
        fn default() -> Self {
            Self {
                curve_class: Err("no value supplied for curve_class".to_string()),
                edge_thickness: Ok(Default::default()),
                flow_velocity: Ok(Default::default()),
                spatial_repulsion_scalar: Ok(Default::default()),
                tension: Ok(Default::default()),
            }
        }
    }
    impl VolumetricEdgeProfile {
        pub fn curve_class<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CurveClass>,
            T::Error: ::std::fmt::Display,
        {
            self.curve_class = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for curve_class: {e}"));
            self
        }
        pub fn edge_thickness<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.edge_thickness = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for edge_thickness: {e}"));
            self
        }
        pub fn flow_velocity<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.flow_velocity = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for flow_velocity: {e}"));
            self
        }
        pub fn spatial_repulsion_scalar<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.spatial_repulsion_scalar = value.try_into().map_err(|e| {
                format!("error converting supplied value for spatial_repulsion_scalar: {e}")
            });
            self
        }
        pub fn tension<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<f64>>,
            T::Error: ::std::fmt::Display,
        {
            self.tension = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for tension: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<VolumetricEdgeProfile> for super::VolumetricEdgeProfile {
        type Error = super::error::ConversionError;
        fn try_from(
            value: VolumetricEdgeProfile,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                curve_class: value.curve_class?,
                edge_thickness: value.edge_thickness?,
                flow_velocity: value.flow_velocity?,
                spatial_repulsion_scalar: value.spatial_repulsion_scalar?,
                tension: value.tension?,
            })
        }
    }
    impl ::std::convert::From<super::VolumetricEdgeProfile> for VolumetricEdgeProfile {
        fn from(value: super::VolumetricEdgeProfile) -> Self {
            Self {
                curve_class: Ok(value.curve_class),
                edge_thickness: Ok(value.edge_thickness),
                flow_velocity: Ok(value.flow_velocity),
                spatial_repulsion_scalar: Ok(value.spatial_repulsion_scalar),
                tension: Ok(value.tension),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct VolumetricPartitionState {
        optical_hardware_constraint_proof: ::std::result::Result<
            ::std::option::Option<super::ZeroKnowledgeReceipt>,
            ::std::string::String,
        >,
        partition_boundary:
            ::std::result::Result<super::VolumetricBoundingProfile, ::std::string::String>,
        subscription_ttl_ms: ::std::result::Result<::std::num::NonZeroU64, ::std::string::String>,
    }
    impl ::std::default::Default for VolumetricPartitionState {
        fn default() -> Self {
            Self {
                optical_hardware_constraint_proof: Ok(Default::default()),
                partition_boundary: Err("no value supplied for partition_boundary".to_string()),
                subscription_ttl_ms: Err("no value supplied for subscription_ttl_ms".to_string()),
            }
        }
    }
    impl VolumetricPartitionState {
        pub fn optical_hardware_constraint_proof<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::ZeroKnowledgeReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.optical_hardware_constraint_proof = value.try_into().map_err(|e| {
                format!(
                    "error converting supplied value for optical_hardware_constraint_proof: {e}"
                )
            });
            self
        }
        pub fn partition_boundary<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VolumetricBoundingProfile>,
            T::Error: ::std::fmt::Display,
        {
            self.partition_boundary = value.try_into().map_err(|e| {
                format!("error converting supplied value for partition_boundary: {e}")
            });
            self
        }
        pub fn subscription_ttl_ms<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::num::NonZeroU64>,
            T::Error: ::std::fmt::Display,
        {
            self.subscription_ttl_ms = value.try_into().map_err(|e| {
                format!("error converting supplied value for subscription_ttl_ms: {e}")
            });
            self
        }
    }
    impl ::std::convert::TryFrom<VolumetricPartitionState> for super::VolumetricPartitionState {
        type Error = super::error::ConversionError;
        fn try_from(
            value: VolumetricPartitionState,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                optical_hardware_constraint_proof: value.optical_hardware_constraint_proof?,
                partition_boundary: value.partition_boundary?,
                subscription_ttl_ms: value.subscription_ttl_ms?,
            })
        }
    }
    impl ::std::convert::From<super::VolumetricPartitionState> for VolumetricPartitionState {
        fn from(value: super::VolumetricPartitionState) -> Self {
            Self {
                optical_hardware_constraint_proof: Ok(value.optical_hardware_constraint_proof),
                partition_boundary: Ok(value.partition_boundary),
                subscription_ttl_ms: Ok(value.subscription_ttl_ms),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct WetwareAttestationContract {
        cryptographic_payload:
            ::std::result::Result<super::CryptographicPayload, ::std::string::String>,
        dag_node_nonce: ::std::result::Result<super::DagNodeNonce, ::std::string::String>,
        did_subject: ::std::result::Result<super::DidSubject, ::std::string::String>,
        liveness_challenge_hash:
            ::std::result::Result<super::LivenessChallengeHash, ::std::string::String>,
        mechanism: ::std::result::Result<super::Mechanism, ::std::string::String>,
    }
    impl ::std::default::Default for WetwareAttestationContract {
        fn default() -> Self {
            Self {
                cryptographic_payload: Err(
                    "no value supplied for cryptographic_payload".to_string()
                ),
                dag_node_nonce: Err("no value supplied for dag_node_nonce".to_string()),
                did_subject: Err("no value supplied for did_subject".to_string()),
                liveness_challenge_hash: Err(
                    "no value supplied for liveness_challenge_hash".to_string()
                ),
                mechanism: Err("no value supplied for mechanism".to_string()),
            }
        }
    }
    impl WetwareAttestationContract {
        pub fn cryptographic_payload<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CryptographicPayload>,
            T::Error: ::std::fmt::Display,
        {
            self.cryptographic_payload = value.try_into().map_err(|e| {
                format!("error converting supplied value for cryptographic_payload: {e}")
            });
            self
        }
        pub fn dag_node_nonce<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DagNodeNonce>,
            T::Error: ::std::fmt::Display,
        {
            self.dag_node_nonce = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for dag_node_nonce: {e}"));
            self
        }
        pub fn did_subject<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::DidSubject>,
            T::Error: ::std::fmt::Display,
        {
            self.did_subject = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for did_subject: {e}"));
            self
        }
        pub fn liveness_challenge_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::LivenessChallengeHash>,
            T::Error: ::std::fmt::Display,
        {
            self.liveness_challenge_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for liveness_challenge_hash: {e}")
            });
            self
        }
        pub fn mechanism<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::Mechanism>,
            T::Error: ::std::fmt::Display,
        {
            self.mechanism = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for mechanism: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<WetwareAttestationContract> for super::WetwareAttestationContract {
        type Error = super::error::ConversionError;
        fn try_from(
            value: WetwareAttestationContract,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                cryptographic_payload: value.cryptographic_payload?,
                dag_node_nonce: value.dag_node_nonce?,
                did_subject: value.did_subject?,
                liveness_challenge_hash: value.liveness_challenge_hash?,
                mechanism: value.mechanism?,
            })
        }
    }
    impl ::std::convert::From<super::WetwareAttestationContract> for WetwareAttestationContract {
        fn from(value: super::WetwareAttestationContract) -> Self {
            Self {
                cryptographic_payload: Ok(value.cryptographic_payload),
                dag_node_nonce: Ok(value.dag_node_nonce),
                did_subject: Ok(value.did_subject),
                liveness_challenge_hash: Ok(value.liveness_challenge_hash),
                mechanism: Ok(value.mechanism),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct WorkflowManifest {
        genesis_provenance:
            ::std::result::Result<super::EpistemicProvenanceReceipt, ::std::string::String>,
        governance: ::std::result::Result<
            ::std::option::Option<super::GlobalGovernancePolicy>,
            ::std::string::String,
        >,
        manifest_version: ::std::result::Result<super::SemanticVersionState, ::std::string::String>,
        max_risk_tolerance: ::std::result::Result<
            ::std::option::Option<super::RiskLevelPolicy>,
            ::std::string::String,
        >,
        pq_signature: ::std::result::Result<
            ::std::option::Option<super::PostQuantumSignatureReceipt>,
            ::std::string::String,
        >,
        session_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        tenant_cid: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        topology: ::std::result::Result<super::AnyTopologyManifest, ::std::string::String>,
    }
    impl ::std::default::Default for WorkflowManifest {
        fn default() -> Self {
            Self {
                genesis_provenance: Err("no value supplied for genesis_provenance".to_string()),
                governance: Ok(Default::default()),
                manifest_version: Err("no value supplied for manifest_version".to_string()),
                max_risk_tolerance: Ok(Default::default()),
                pq_signature: Ok(Default::default()),
                session_cid: Ok(Default::default()),
                tenant_cid: Ok(Default::default()),
                topology: Err("no value supplied for topology".to_string()),
            }
        }
    }
    impl WorkflowManifest {
        pub fn genesis_provenance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::EpistemicProvenanceReceipt>,
            T::Error: ::std::fmt::Display,
        {
            self.genesis_provenance = value.try_into().map_err(|e| {
                format!("error converting supplied value for genesis_provenance: {e}")
            });
            self
        }
        pub fn governance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::GlobalGovernancePolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.governance = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for governance: {e}"));
            self
        }
        pub fn manifest_version<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::SemanticVersionState>,
            T::Error: ::std::fmt::Display,
        {
            self.manifest_version = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for manifest_version: {e}"));
            self
        }
        pub fn max_risk_tolerance<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::RiskLevelPolicy>>,
            T::Error: ::std::fmt::Display,
        {
            self.max_risk_tolerance = value.try_into().map_err(|e| {
                format!("error converting supplied value for max_risk_tolerance: {e}")
            });
            self
        }
        pub fn pq_signature<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<super::PostQuantumSignatureReceipt>>,
            T::Error: ::std::fmt::Display,
        {
            self.pq_signature = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for pq_signature: {e}"));
            self
        }
        pub fn session_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.session_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for session_cid: {e}"));
            self
        }
        pub fn tenant_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.tenant_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for tenant_cid: {e}"));
            self
        }
        pub fn topology<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::AnyTopologyManifest>,
            T::Error: ::std::fmt::Display,
        {
            self.topology = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for topology: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<WorkflowManifest> for super::WorkflowManifest {
        type Error = super::error::ConversionError;
        fn try_from(
            value: WorkflowManifest,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                genesis_provenance: value.genesis_provenance?,
                governance: value.governance?,
                manifest_version: value.manifest_version?,
                max_risk_tolerance: value.max_risk_tolerance?,
                pq_signature: value.pq_signature?,
                session_cid: value.session_cid?,
                tenant_cid: value.tenant_cid?,
                topology: value.topology?,
            })
        }
    }
    impl ::std::convert::From<super::WorkflowManifest> for WorkflowManifest {
        fn from(value: super::WorkflowManifest) -> Self {
            Self {
                genesis_provenance: Ok(value.genesis_provenance),
                governance: Ok(value.governance),
                manifest_version: Ok(value.manifest_version),
                max_risk_tolerance: Ok(value.max_risk_tolerance),
                pq_signature: Ok(value.pq_signature),
                session_cid: Ok(value.session_cid),
                tenant_cid: Ok(value.tenant_cid),
                topology: Ok(value.topology),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct ZeroKnowledgeReceipt {
        cryptographic_blob: ::std::result::Result<super::CryptographicBlob, ::std::string::String>,
        latent_state_commitments: ::std::result::Result<
            ::std::collections::HashMap<
                ::std::string::String,
                super::ZeroKnowledgeReceiptLatentStateCommitmentsValue,
            >,
            ::std::string::String,
        >,
        logical_circuit_hash:
            ::std::result::Result<super::LogicalCircuitHash, ::std::string::String>,
        proof_protocol: ::std::result::Result<super::ProofProtocol, ::std::string::String>,
        public_inputs_hash: ::std::result::Result<super::PublicInputsHash, ::std::string::String>,
        temporal_circuit_hash: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        temporal_interval_proof: ::std::result::Result<
            ::std::option::Option<::std::string::String>,
            ::std::string::String,
        >,
        verifier_key_cid: ::std::result::Result<super::VerifierKeyCid, ::std::string::String>,
    }
    impl ::std::default::Default for ZeroKnowledgeReceipt {
        fn default() -> Self {
            Self {
                cryptographic_blob: Err("no value supplied for cryptographic_blob".to_string()),
                latent_state_commitments: Ok(Default::default()),
                logical_circuit_hash: Err("no value supplied for logical_circuit_hash".to_string()),
                proof_protocol: Err("no value supplied for proof_protocol".to_string()),
                public_inputs_hash: Err("no value supplied for public_inputs_hash".to_string()),
                temporal_circuit_hash: Ok(Default::default()),
                temporal_interval_proof: Ok(Default::default()),
                verifier_key_cid: Err("no value supplied for verifier_key_cid".to_string()),
            }
        }
    }
    impl ZeroKnowledgeReceipt {
        pub fn cryptographic_blob<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::CryptographicBlob>,
            T::Error: ::std::fmt::Display,
        {
            self.cryptographic_blob = value.try_into().map_err(|e| {
                format!("error converting supplied value for cryptographic_blob: {e}")
            });
            self
        }
        pub fn latent_state_commitments<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::ZeroKnowledgeReceiptLatentStateCommitmentsValue,
                >,
            >,
            T::Error: ::std::fmt::Display,
        {
            self.latent_state_commitments = value.try_into().map_err(|e| {
                format!("error converting supplied value for latent_state_commitments: {e}")
            });
            self
        }
        pub fn logical_circuit_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::LogicalCircuitHash>,
            T::Error: ::std::fmt::Display,
        {
            self.logical_circuit_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for logical_circuit_hash: {e}")
            });
            self
        }
        pub fn proof_protocol<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::ProofProtocol>,
            T::Error: ::std::fmt::Display,
        {
            self.proof_protocol = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for proof_protocol: {e}"));
            self
        }
        pub fn public_inputs_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::PublicInputsHash>,
            T::Error: ::std::fmt::Display,
        {
            self.public_inputs_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for public_inputs_hash: {e}")
            });
            self
        }
        pub fn temporal_circuit_hash<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_circuit_hash = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_circuit_hash: {e}")
            });
            self
        }
        pub fn temporal_interval_proof<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
            T::Error: ::std::fmt::Display,
        {
            self.temporal_interval_proof = value.try_into().map_err(|e| {
                format!("error converting supplied value for temporal_interval_proof: {e}")
            });
            self
        }
        pub fn verifier_key_cid<T>(mut self, value: T) -> Self
        where
            T: ::std::convert::TryInto<super::VerifierKeyCid>,
            T::Error: ::std::fmt::Display,
        {
            self.verifier_key_cid = value
                .try_into()
                .map_err(|e| format!("error converting supplied value for verifier_key_cid: {e}"));
            self
        }
    }
    impl ::std::convert::TryFrom<ZeroKnowledgeReceipt> for super::ZeroKnowledgeReceipt {
        type Error = super::error::ConversionError;
        fn try_from(
            value: ZeroKnowledgeReceipt,
        ) -> ::std::result::Result<Self, super::error::ConversionError> {
            Ok(Self {
                cryptographic_blob: value.cryptographic_blob?,
                latent_state_commitments: value.latent_state_commitments?,
                logical_circuit_hash: value.logical_circuit_hash?,
                proof_protocol: value.proof_protocol?,
                public_inputs_hash: value.public_inputs_hash?,
                temporal_circuit_hash: value.temporal_circuit_hash?,
                temporal_interval_proof: value.temporal_interval_proof?,
                verifier_key_cid: value.verifier_key_cid?,
            })
        }
    }
    impl ::std::convert::From<super::ZeroKnowledgeReceipt> for ZeroKnowledgeReceipt {
        fn from(value: super::ZeroKnowledgeReceipt) -> Self {
            Self {
                cryptographic_blob: Ok(value.cryptographic_blob),
                latent_state_commitments: Ok(value.latent_state_commitments),
                logical_circuit_hash: Ok(value.logical_circuit_hash),
                proof_protocol: Ok(value.proof_protocol),
                public_inputs_hash: Ok(value.public_inputs_hash),
                temporal_circuit_hash: Ok(value.temporal_circuit_hash),
                temporal_interval_proof: Ok(value.temporal_interval_proof),
                verifier_key_cid: Ok(value.verifier_key_cid),
            }
        }
    }
}
