use oas_document::lineage_section::LineageSection;

let lineage = LineageSection {
    human_root_did: "did:oas:acme:hmr:alice".to_string(),
    creator_did: "did:oas:acme:hmr:alice".to_string(),
    generation: 0,
    derivation_proof: None,
    human_root_chain: vec![
        "did:oas:acme:ao:research".to_string(),
        "did:oas:acme:hmr:alice".to_string(),
    ],
    org_inclusion_proof: None,
    anchor_refs: None,
};
assert_eq!(lineage.generation, 0);

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LineageSection {
/// DID of the ultimate human root (HMR, MHR, or ENR).

pub human_root_did: String,
/// DID of the entity that directly created this entity.

pub creator_did: String,
/// Number of derivation steps from human root.

/// 0 = created directly by human root.

pub generation: u32,
/// AgentLineageProof2025 linking this entity to its creator.

#[serde(skip_serializing_if = "Option::is_none")]
pub derivation_proof: Option<AgentLineageProof>,
/// Ordered array of DIDs from this entity to human root.

pub human_root_chain: Vec<String>,
/// Optional Merkle inclusion proof binding this entity to the

/// `OrgLineageRoot` of its creator (an MHR / ENR org). REQUIRED at

/// resolution time when the GAL has an `OrgLineageRoot` for the

/// creator DID. Verification uses BLAKE3; see

/// [`OrgInclusionProof`].

#[serde(skip_serializing_if = "Option::is_none")]
pub org_inclusion_proof: Option<OrgInclusionProof>,
/// References to on-chain or transparency-log anchors attesting to

/// this lineage section's registration.

///

/// Lineage authority is backend-agnostic (see [`AnchorRef`]). An

/// entity MAY be anchored on multiple backends at once - Sigil and an

/// EAS attestation and a transparency log - and verifiers consult the

/// refs for the schemes they trust. A verifier MUST ignore refs whose

/// `scheme` it does not support rather than rejecting the document:

/// unknown schemes are additive, never breaking.

#[serde(skip_serializing_if = "Option::is_none")]
pub anchor_refs: Option<Vec<AnchorRef>>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AnchorRef {
/// The anchor scheme: `sigil`, `eas`, `ctlog`, or a future registered

/// name. Verifiers ignore schemes they do not support.

pub scheme: String,
/// Scheme-specific locator: a transaction hash (`sigil`), an

/// attestation UID (`eas`), a log identifier and leaf index (`ctlog`).

/// Opaque to verifiers that do not implement the scheme.

pub locator: String,
/// Optional inclusion proof binding the locator to the anchor

/// backend's canonical root. Presence semantics are scheme-specific;

/// some schemes (EAS) are self-proving and carry none, others (batch

/// Merkle anchoring) require one.

#[serde(skip_serializing_if = "Option::is_none")]
pub inclusion_proof: Option<AnchorInclusionProof>
}

pub fn to_uri(&self) -> String;

pub fn parse_uri(uri: &str) -> Option<Self>;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AnchorInclusionProof {
/// The proof family: `merkle-blake3`, `eas-attestation`, or a future

/// registered name. Verifiers ignore types they do not support.

pub proof_type: String,
/// The root this proof binds to (hex digest or backend-native form).

pub root: String,
/// The leaf the anchored registration hashes to.

pub leaf_hash: String,
/// Ordered sibling path from leaf to root (Merkle-family proofs).

/// Empty for self-proving schemes.

#[serde(default)]
pub path: Vec<MerkleProofNode>
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum MerkleDirection {
    /// Sibling is on the left; reconstructed hash combines as
    /// `H(sibling || current)`.
    Left,
    /// Sibling is on the right; reconstructed hash combines as
    /// `H(current || sibling)`.
    Right,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MerkleProofNode {
/// `blake3:`-prefixed hex of the sibling hash at this level.

pub sibling_hash: String,
/// Direction of the sibling relative to the current node.

pub direction: MerkleDirection
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OrgInclusionProof {
/// `blake3:`-prefixed hex of the org's Merkle root. MUST equal the

/// on-chain `OrgLineageRoot.merkle_root`.

pub merkle_root: String,
/// `blake3:`-prefixed hex of the leaf — `BLAKE3(child_did)`.

pub leaf_hash: String,
/// Ordered path of sibling hashes from leaf to root.

pub path: Vec<MerkleProofNode>
}