Struct GovernanceEntryResponse 

pub struct GovernanceEntryResponse {

    pub id: GovernanceLogId,
    pub entry_type: GovernanceLogEntryType,
    pub title: String,
    pub created_at: DateTime<Utc>,
    pub tags: Option<Vec<String>>,
    pub summary: Option<String>,
    pub summary_authorship: Option<SummaryAuthorship>,
    pub total_rounds: Option<u64>,
    pub round_bytes: Vec<u64>,
    pub data: Option<Value>,
    pub round: Option<u64>,
    pub attachments: Vec<AttachmentListing>,
    pub attachment: Option<String>,
    pub version: Option<RecordVersion>,
    pub revisions: Vec<GovernanceLogId>,
    pub attestation: Option<GovernanceAttestation>,
    pub standing: Standing,
    pub outcome: Option<DecisionOutcome>,
    pub vote_tally: Option<Redactable<String>>,
    pub steward_veto: bool,
    pub amendments: Vec<AmendmentNotice>,
    pub cited_by: Vec<GovernanceCitation>,
    pub texts: Option<AmendmentTexts>,
    pub obligation: Option<ObligationListing>,
    pub obligations: Vec<ObligationListing>,
    pub data_file: Option<DataFileContent>,
    pub data_set: Option<DataSetView>,
}

A single governance log entry as get_content returns it.

data is the record — for a Council decision, every round of deliberation — and is absent only from a detail=summary read. total_rounds is present whenever the entry has rounds.

Fields

id: GovernanceLogId

entry_type: GovernanceLogEntryType

title: String

created_at: DateTime<Utc>

tags: Option<Vec<String>>

summary: Option<String>

The precedent summary — a structured markdown digest, typically a few hundred words, grounded in the Constitution (short relative to the full record, not short in absolute terms). On a Council decision signed with one, the record’s own summary in the version served, revisions applied (see summary_authorship); otherwise the Clerk’s, None only in the window between an entry being written and its summary being batched. See served_summary.

summary_authorship: Option<SummaryAuthorship>

Present when summary is the decision’s signed one: who wrote and who accepted it (0.96)

total_rounds: Option<u64>

How many deliberation rounds the record holds, when it holds rounds. Present at any detail level: it is what tells a reader whether round= paging is available and how far it goes.

round_bytes: Vec<u64>

Each round’s size in bytes, round 1 first, when the record holds rounds: about what one round=<n> read costs, known before reading it. Empty from a server older than this field

data: Option<Value>

The record, absent at detail=summary and narrowed when round or attachment was given. The default read leaves the attachments’ text out; only detail=full_with_attachments is verbatim (see attestation).

round: Option<u64>

The 1-indexed round data was narrowed to, when one was requested.

attachments: Vec<AttachmentListing>

The record’s attachments, listed at any detail level so a reader knows they exist; read one with attachment=<name>. (0.42)

attachment: Option<String>

The attachment data was narrowed to, when one was requested. (0.42)

version: Option<RecordVersion>

The RecordVersion data is, when one was requested (0.43)

revisions: Vec<GovernanceLogId>

The revisions applied, in chain order, to the stored data to produce what was served: empty for the original. (0.43)

attestation: Option<GovernanceAttestation>

The server’s signature and chain position for this entry; null for an entry not yet attested. data_hash covers the full data only — verify it against a detail=full_with_attachments read with no round or attachment. See crate::govlog.

standing: Standing

Derived from amendments: anything but in_force and this entry is not citable as it stands.

outcome: Option<DecisionOutcome>

A Council decision’s outcome, as the version served signs it: what the Council decided on the item as titled (0.107.3). approved says the Council approved what the item put to it, which the summary says; not by itself that a measure is in effect. Absent for every other kind of entry.

vote_tally: Option<Redactable<String>>

Beside outcome: the record’s vote tally ("5-0"), or the marker of the redaction that removed it (0.107.3)

steward_veto: bool

The Steward vetoed the item (Art. IV § 5): outcome is rejected whatever vote_tally, which counts the others’ votes (0.107.3)

amendments: Vec<AmendmentNotice>

Later entries that name this one. The entry itself is never edited — except its data, under a redaction.

cited_by: Vec<GovernanceCitation>

Later entries whose records name this one other than as an amendment’s target — a Steward’s record about it, an amendment made under its authority — in chain order. (0.68)

texts: Option<AmendmentTexts>

For an amendment entry written since 0.28: the words its data commits to — basis, note, rationale — and the salt that opens each commitment, as far as the platform still holds them. data alone shows only the commitments. A text that was lawfully withheld is simply absent. (0.29)

obligation: Option<ObligationListing>

For an obligation entry: where it stands now, from the updates in amendments (0.72)

obligations: Vec<ObligationListing>

The obligations this entry created, oldest first, each with its status; read one with get_content (0.72)

data_file: Option<DataFileContent>

For a data_set entry read with attachment=<path>: that file’s text, checked against the SHA-256 the manifest signs for (0.91)

data_set: Option<DataSetView>

For a data_set entry: its files, held to the read’s budget and rolled up by directory when they do not fit; or one directory’s, read with attachment="<dir>/" (0.91)

Implementations

impl GovernanceEntryResponse

pub fn missing_part( &self, round: Option<u64>, attachment: Option<&str>, by_link: bool, ) -> Option<String>

Why the part of entry a read asked for is not there, if it is not: a round past its last, or an attachment it does not have (beta round of 0.112.0: a missing part was read as an empty one, the whole record served and a full read spent). by_link names the attachments by their links

impl GovernanceEntryResponse

pub fn council_decision(&self) -> Option<Result<CouncilDecisionRecord, Error>>

data typed, on a council_decision read that carries it (with rounds narrowed when round was given). None for any other entry or read.

Verify data_hash against data, not against this. An Err means a shape this version doesn’t know, or a redaction of a value the record doesn’t type as Redactable; data still has everything.

pub fn data_set(&self) -> Option<Result<DataSet, Error>>

data typed, on a data_set read that carries it (0.91)

pub fn test_entry(&self) -> Option<Result<TestEntry, Error>>

data typed, on a test read that carries it (0.102). Its council_record() is the decision the test sitting would have made

Trait Implementations

impl Clone for GovernanceEntryResponse

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 GovernanceEntryResponse

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GovernanceEntryResponse

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GovernanceEntryResponse

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

where __S: Serializer,

Serialize this value into the given Serde serializer.