Struct Amendment 

pub struct Amendment {
    pub agora_governance_amendment: u32,
    pub target: GovernanceLogId,
    pub target_entry_hash: Sha256Hex,
    pub kind: AmendmentKind,
    pub authority: Option<GovernanceLogId>,
    pub basis: AmendmentText,
    pub note: AmendmentText,
    pub rationale: Option<AmendmentText>,
    pub redaction: Option<Redaction>,
    pub revision: Option<Revision>,
}

The data of an amendment entry: what an earlier entry now means.

The target is never edited — except its data under a Redaction — so the amendment is the whole record of the change, and both are signed links of the same chain.

Fields

agora_governance_amendment: u32

Always AMENDMENT_VERSION

target: GovernanceLogId

target_entry_hash: Sha256Hex

The target’s entry_hash — binds this to one exact entry

kind: AmendmentKind

authority: Option<GovernanceLogId>

The governance entry that authorizes this, when one does (e.g. GOV-2026-0005). None for a lawful-deletion redaction.

basis: AmendmentText

Section or legal basis, human-readable: "§1 (Red Team Cases Recharacterized)", "GDPR Art. 17(1)(a)". Never personal data — and erasable, for the day that rule is broken.

note: AmendmentText

The label readers and prompts show next to the target

rationale: Option<AmendmentText>

Why, at length — note is the label, this is the reasoning.

redaction: Option<Redaction>

Present iff kind is AmendmentKind::Redaction

revision: Option<Revision>

Present iff kind is AmendmentKind::Revision (0.43)

Implementations

impl Amendment

pub fn validate(&self) -> Result<(), AmendmentError>

Version, the shape of the texts for that version, and the redaction- and revision-shape invariants — everything checkable without the rest of the chain

pub fn text_status( &self, beside: Option<&AmendmentTexts>, ) -> Result<Option<AmendmentTextStatus>, AmendmentError>

Where each committed text stands given what is beside the entry; None for version 1, whose texts are in the signed data.

A text that is beside the entry and is not the one committed to, or that the entry never committed to at all, is an error: someone put words next to a signed entry that the signer did not write.

Trait Implementations

impl Clone for Amendment

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Amendment

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Amendment

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Amendment

impl PartialEq for Amendment

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Amendment

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Amendment