accumulate-sdk 2.1.0

//! Protocol Types for Accumulate
//!
//! Auto-generated from Go protocol YAML files.
//! Generated at: 2025-10-04T06:19:17.820322
//!
//! DO NOT EDIT: This file is auto-generated by Stage 3.2
//! To modify types, edit the Go protocol YAML files and re-run the generator.

#![allow(missing_docs)]

use serde::{Serialize, Deserialize};

// Import enum types from other modules
use crate::generated::enums::{
    BookType, ExecutorVersion, ObjectType, PartitionType, TransactionType, VoteType
};

// Re-export types that may be used as field types
pub use serde_json::Value as JsonValue;


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ADI {
    #[serde(rename = "Url")]
    pub url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AccountAuth {
    #[serde(rename = "Authorities")]
    pub authorities: AuthorityEntry,
}

// Type AccountAuthOperationType already defined in enums module


// Type AccountType already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AccumulateDataEntry {
    #[serde(rename = "Data")]
    pub data: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AcmeFaucet {
    #[serde(rename = "Url")]
    pub url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AcmeOracle {
    #[serde(rename = "Price")]
    pub price: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ActivateProtocolVersion {
    #[serde(rename = "Version")]
    pub version: ExecutorVersion,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AddAccountAuthorityOperation {
    #[serde(rename = "Authority")]
    pub authority: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AddCredits {
    #[serde(rename = "Recipient")]
    pub recipient: String,
    #[serde(rename = "Amount")]
    pub amount: String,
    #[serde(rename = "Oracle")]
    pub oracle: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AddCreditsResult {
    #[serde(rename = "Amount")]
    pub amount: String,
    #[serde(rename = "Credits")]
    pub credits: u64,
    #[serde(rename = "Oracle")]
    pub oracle: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AddKeyOperation {
    #[serde(rename = "Entry")]
    pub entry: KeySpecParams,
}

// Type AllowedTransactionBit already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AnchorLedger {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "MinorBlockSequenceNumber")]
    pub minor_block_sequence_number: u64,
    #[serde(rename = "MajorBlockIndex")]
    pub major_block_index: u64,
    #[serde(rename = "MajorBlockTime")]
    pub major_block_time: String,
    #[serde(rename = "PendingMajorBlockAnchors")]
    pub pending_major_block_anchors: String,
    #[serde(rename = "Sequence")]
    pub sequence: PartitionSyntheticLedger,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AnchorMetadata {
    #[serde(rename = "Account")]
    pub account: String,
    #[serde(rename = "Index")]
    pub index: u64,
    #[serde(rename = "SourceIndex")]
    pub source_index: u64,
    #[serde(rename = "SourceBlock")]
    pub source_block: u64,
    #[serde(rename = "Entry")]
    pub entry: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AnnotatedReceipt {
    #[serde(rename = "Receipt")]
    pub receipt: Vec<u8>,
    #[serde(rename = "Anchor")]
    pub anchor: AnchorMetadata,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AuthorityEntry {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "Disabled")]
    pub disabled: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AuthoritySignature {
    #[serde(rename = "Origin")]
    pub origin: String,
    #[serde(rename = "Authority")]
    pub authority: String,
    #[serde(rename = "Vote")]
    pub vote: VoteType,
    #[serde(rename = "TxID")]
    pub tx_id: [u8; 32],
    #[serde(rename = "Cause")]
    pub cause: [u8; 32],
    #[serde(rename = "Delegator")]
    pub delegator: String,
    #[serde(rename = "Memo")]
    pub memo: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BTCLegacySignature {
    #[serde(rename = "PublicKey")]
    pub public_key: Vec<u8>,
    #[serde(rename = "Signature")]
    pub signature: Vec<u8>,
    #[serde(rename = "Signer")]
    pub signer: String,
    #[serde(rename = "SignerVersion")]
    pub signer_version: u64,
    #[serde(rename = "Timestamp")]
    pub timestamp: u64,
    #[serde(rename = "Vote")]
    pub vote: VoteType,
    #[serde(rename = "TransactionHash")]
    pub transaction_hash: [u8; 32],
    #[serde(rename = "Memo")]
    pub memo: String,
    #[serde(rename = "Data")]
    pub data: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BTCSignature {
    #[serde(rename = "PublicKey")]
    pub public_key: Vec<u8>,
    #[serde(rename = "Signature")]
    pub signature: Vec<u8>,
    #[serde(rename = "Signer")]
    pub signer: String,
    #[serde(rename = "SignerVersion")]
    pub signer_version: u64,
    #[serde(rename = "Timestamp")]
    pub timestamp: u64,
    #[serde(rename = "Vote")]
    pub vote: VoteType,
    #[serde(rename = "TransactionHash")]
    pub transaction_hash: [u8; 32],
    #[serde(rename = "Memo")]
    pub memo: String,
    #[serde(rename = "Data")]
    pub data: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BlockEntry {
    #[serde(rename = "Account")]
    pub account: String,
    #[serde(rename = "Chain")]
    pub chain: String,
    #[serde(rename = "Index")]
    pub index: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BlockLedger {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "Index")]
    pub index: u64,
    #[serde(rename = "Time")]
    pub time: String,
    #[serde(rename = "Entries")]
    pub entries: BlockEntry,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BlockValidatorAnchor {
    #[serde(rename = "AcmeBurnt")]
    pub acme_burnt: String,
}

// Type BookType already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BurnCredits {
    #[serde(rename = "Amount")]
    pub amount: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BurnTokens {
    #[serde(rename = "Amount")]
    pub amount: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ChainMetadata {
    #[serde(rename = "Name")]
    pub name: String,
    #[serde(rename = "Type")]
    pub r#type: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ChainParams {
    #[serde(rename = "Data")]
    pub data: Vec<u8>,
    #[serde(rename = "IsUpdate")]
    pub is_update: bool,
}

// Type ChainType already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateDataAccount {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "Authorities")]
    pub authorities: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateIdentity {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "KeyHash")]
    pub key_hash: Vec<u8>,
    #[serde(rename = "KeyBookUrl")]
    pub key_book_url: String,
    #[serde(rename = "Authorities")]
    pub authorities: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateKeyBook {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "PublicKeyHash")]
    pub public_key_hash: Vec<u8>,
    #[serde(rename = "Authorities")]
    pub authorities: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateKeyPage {
    #[serde(rename = "Keys")]
    pub keys: KeySpecParams,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateLiteTokenAccount {

}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateToken {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "Symbol")]
    pub symbol: String,
    #[serde(rename = "Precision")]
    pub precision: u64,
    #[serde(rename = "Properties")]
    pub properties: String,
    #[serde(rename = "SupplyLimit")]
    pub supply_limit: String,
    #[serde(rename = "Authorities")]
    pub authorities: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateTokenAccount {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "TokenUrl")]
    pub token_url: String,
    #[serde(rename = "Authorities")]
    pub authorities: String,
    #[serde(rename = "Proof")]
    pub proof: TokenIssuerProof,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreditRecipient {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "Amount")]
    pub amount: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DataAccount {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "Entry")]
    pub entry: serde_json::Value,
}

// Type DataEntryType already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DelegatedSignature {
    #[serde(rename = "Signature")]
    pub signature: serde_json::Value,
    #[serde(rename = "Delegator")]
    pub delegator: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DirectoryAnchor {
    #[serde(rename = "Updates")]
    pub updates: NetworkAccountUpdate,
    #[serde(rename = "Receipts")]
    pub receipts: PartitionAnchorReceipt,
    #[serde(rename = "MakeMajorBlock")]
    pub make_major_block: u64,
    #[serde(rename = "MakeMajorBlockTime")]
    pub make_major_block_time: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DisableAccountAuthOperation {
    #[serde(rename = "Authority")]
    pub authority: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DoubleHashDataEntry {
    #[serde(rename = "Data")]
    pub data: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ED25519Signature {
    #[serde(rename = "PublicKey")]
    pub public_key: Vec<u8>,
    #[serde(rename = "Signature")]
    pub signature: Vec<u8>,
    #[serde(rename = "Signer")]
    pub signer: String,
    #[serde(rename = "SignerVersion")]
    pub signer_version: u64,
    #[serde(rename = "Timestamp")]
    pub timestamp: u64,
    #[serde(rename = "Vote")]
    pub vote: VoteType,
    #[serde(rename = "TransactionHash")]
    pub transaction_hash: [u8; 32],
    #[serde(rename = "Memo")]
    pub memo: String,
    #[serde(rename = "Data")]
    pub data: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ETHSignature {
    #[serde(rename = "PublicKey")]
    pub public_key: Vec<u8>,
    #[serde(rename = "Signature")]
    pub signature: Vec<u8>,
    #[serde(rename = "Signer")]
    pub signer: String,
    #[serde(rename = "SignerVersion")]
    pub signer_version: u64,
    #[serde(rename = "Timestamp")]
    pub timestamp: u64,
    #[serde(rename = "Vote")]
    pub vote: VoteType,
    #[serde(rename = "TransactionHash")]
    pub transaction_hash: [u8; 32],
    #[serde(rename = "Memo")]
    pub memo: String,
    #[serde(rename = "Data")]
    pub data: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EcdsaSha256Signature {
    #[serde(rename = "PublicKey")]
    pub public_key: Vec<u8>,
    #[serde(rename = "Signature")]
    pub signature: Vec<u8>,
    #[serde(rename = "Signer")]
    pub signer: String,
    #[serde(rename = "SignerVersion")]
    pub signer_version: u64,
    #[serde(rename = "Timestamp")]
    pub timestamp: u64,
    #[serde(rename = "Vote")]
    pub vote: VoteType,
    #[serde(rename = "TransactionHash")]
    pub transaction_hash: [u8; 32],
    #[serde(rename = "Memo")]
    pub memo: String,
    #[serde(rename = "Data")]
    pub data: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EmptyResult {

}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EnableAccountAuthOperation {
    #[serde(rename = "Authority")]
    pub authority: String,
}

// Type ErrorCode already defined in enums module


// Type ExecutorVersion already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ExpireOptions {
    #[serde(rename = "AtTime")]
    pub at_time: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FactomDataEntry {
    #[serde(rename = "AccountId")]
    pub account_id: [u8; 32],
    #[serde(rename = "Data")]
    pub data: Vec<u8>,
    #[serde(rename = "ExtIds")]
    pub ext_ids: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FactomDataEntryWrapper {

}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FeeSchedule {
    #[serde(rename = "CreateIdentitySliding")]
    pub create_identity_sliding: String,
    #[serde(rename = "CreateSubIdentity")]
    pub create_sub_identity: String,
    #[serde(rename = "BareIdentityDiscount")]
    pub bare_identity_discount: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct HoldUntilOptions {
    #[serde(rename = "MinorBlock")]
    pub minor_block: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IndexEntry {
    #[serde(rename = "Source")]
    pub source: u64,
    #[serde(rename = "Anchor")]
    pub anchor: u64,
    #[serde(rename = "BlockIndex")]
    pub block_index: u64,
    #[serde(rename = "BlockTime")]
    pub block_time: String,
    #[serde(rename = "RootIndexIndex")]
    pub root_index_index: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InternalSignature {
    #[serde(rename = "Cause")]
    pub cause: [u8; 32],
    #[serde(rename = "TransactionHash")]
    pub transaction_hash: [u8; 32],
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IssueTokens {
    #[serde(rename = "Recipient")]
    pub recipient: String,
    #[serde(rename = "Amount")]
    pub amount: String,
    #[serde(rename = "To")]
    pub to: TokenRecipient,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct KeyBook {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "BookType")]
    pub book_type: BookType,
    #[serde(rename = "PageCount")]
    pub page_count: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct KeyPage {
    #[serde(rename = "KeyBook")]
    pub key_book: String,
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "CreditBalance")]
    pub credit_balance: u64,
    #[serde(rename = "AcceptThreshold")]
    pub accept_threshold: u64,
    #[serde(rename = "RejectThreshold")]
    pub reject_threshold: u64,
    #[serde(rename = "ResponseThreshold")]
    pub response_threshold: u64,
    #[serde(rename = "BlockThreshold")]
    pub block_threshold: u64,
    #[serde(rename = "Version")]
    pub version: u64,
    #[serde(rename = "Keys")]
    pub keys: KeySpec,
    #[serde(rename = "TransactionBlacklist")]
    pub transaction_blacklist: Vec<String>,
}

// Type KeyPageOperationType already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct KeySpec {
    #[serde(rename = "PublicKeyHash")]
    pub public_key_hash: Vec<u8>,
    #[serde(rename = "LastUsedOn")]
    pub last_used_on: u64,
    #[serde(rename = "Delegate")]
    pub delegate: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct KeySpecParams {
    #[serde(rename = "KeyHash")]
    pub key_hash: Vec<u8>,
    #[serde(rename = "Delegate")]
    pub delegate: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LegacyED25519Signature {
    #[serde(rename = "Timestamp")]
    pub timestamp: u64,
    #[serde(rename = "PublicKey")]
    pub public_key: Vec<u8>,
    #[serde(rename = "Signature")]
    pub signature: Vec<u8>,
    #[serde(rename = "Signer")]
    pub signer: String,
    #[serde(rename = "SignerVersion")]
    pub signer_version: u64,
    #[serde(rename = "Vote")]
    pub vote: VoteType,
    #[serde(rename = "TransactionHash")]
    pub transaction_hash: [u8; 32],
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LiteDataAccount {
    #[serde(rename = "Url")]
    pub url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LiteIdentity {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "CreditBalance")]
    pub credit_balance: u64,
    #[serde(rename = "LastUsedOn")]
    pub last_used_on: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LiteTokenAccount {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "TokenUrl")]
    pub token_url: String,
    #[serde(rename = "Balance")]
    pub balance: String,
    #[serde(rename = "LockHeight")]
    pub lock_height: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LockAccount {
    #[serde(rename = "Height")]
    pub height: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MetricsRequest {
    #[serde(rename = "Metric")]
    pub metric: String,
    #[serde(rename = "Duration")]
    pub duration: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MetricsResponse {
    #[serde(rename = "Value")]
    pub value: serde_json::Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NetworkAccountUpdate {
    #[serde(rename = "Name")]
    pub name: String,
    #[serde(rename = "Body")]
    pub body: serde_json::Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NetworkDefinition {
    #[serde(rename = "NetworkName")]
    pub network_name: String,
    #[serde(rename = "Version")]
    pub version: u64,
    #[serde(rename = "Partitions")]
    pub partitions: PartitionInfo,
    #[serde(rename = "Validators")]
    pub validators: ValidatorInfo,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NetworkGlobals {
    #[serde(rename = "OperatorAcceptThreshold")]
    pub operator_accept_threshold: Rational,
    #[serde(rename = "ValidatorAcceptThreshold")]
    pub validator_accept_threshold: Rational,
    #[serde(rename = "MajorBlockSchedule")]
    pub major_block_schedule: String,
    #[serde(rename = "AnchorEmptyBlocks")]
    pub anchor_empty_blocks: bool,
    #[serde(rename = "FeeSchedule")]
    pub fee_schedule: FeeSchedule,
    #[serde(rename = "Limits")]
    pub limits: NetworkLimits,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NetworkLimits {
    #[serde(rename = "DataEntryParts")]
    pub data_entry_parts: u64,
    #[serde(rename = "AccountAuthorities")]
    pub account_authorities: u64,
    #[serde(rename = "BookPages")]
    pub book_pages: u64,
    #[serde(rename = "PageEntries")]
    pub page_entries: u64,
    #[serde(rename = "IdentityAccounts")]
    pub identity_accounts: u64,
    #[serde(rename = "PendingMajorBlocks")]
    pub pending_major_blocks: u64,
    #[serde(rename = "EventsPerBlock")]
    pub events_per_block: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NetworkMaintenance {
    #[serde(rename = "Operations")]
    pub operations: serde_json::Value,
}

// Type NetworkMaintenanceOperationType already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Object {
    #[serde(rename = "Type")]
    pub r#type: ObjectType,
    #[serde(rename = "Chains")]
    pub chains: ChainMetadata,
    #[serde(rename = "Pending")]
    pub pending: TxIdSet,
}

// Type ObjectType already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PartitionAnchor {
    #[serde(rename = "Source")]
    pub source: String,
    #[serde(rename = "MajorBlockIndex")]
    pub major_block_index: u64,
    #[serde(rename = "MinorBlockIndex")]
    pub minor_block_index: u64,
    #[serde(rename = "RootChainIndex")]
    pub root_chain_index: u64,
    #[serde(rename = "RootChainAnchor")]
    pub root_chain_anchor: [u8; 32],
    #[serde(rename = "StateTreeAnchor")]
    pub state_tree_anchor: [u8; 32],
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PartitionAnchorReceipt {
    #[serde(rename = "Anchor")]
    pub anchor: PartitionAnchor,
    #[serde(rename = "RootChainReceipt")]
    pub root_chain_receipt: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PartitionExecutorVersion {
    #[serde(rename = "Partition")]
    pub partition: String,
    #[serde(rename = "Version")]
    pub version: ExecutorVersion,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PartitionInfo {
    #[serde(rename = "ID")]
    pub id: String,
    #[serde(rename = "Type")]
    pub r#type: PartitionType,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PartitionSignature {
    #[serde(rename = "SourceNetwork")]
    pub source_network: String,
    #[serde(rename = "DestinationNetwork")]
    pub destination_network: String,
    #[serde(rename = "SequenceNumber")]
    pub sequence_number: u64,
    #[serde(rename = "TransactionHash")]
    pub transaction_hash: [u8; 32],
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PartitionSyntheticLedger {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "Produced")]
    pub produced: u64,
    #[serde(rename = "Received")]
    pub received: u64,
    #[serde(rename = "Delivered")]
    pub delivered: u64,
    #[serde(rename = "Pending")]
    pub pending: [u8; 32],
}

// Type PartitionType already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PendingTransactionGCOperation {
    #[serde(rename = "Account")]
    pub account: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RCD1Signature {
    #[serde(rename = "PublicKey")]
    pub public_key: Vec<u8>,
    #[serde(rename = "Signature")]
    pub signature: Vec<u8>,
    #[serde(rename = "Signer")]
    pub signer: String,
    #[serde(rename = "SignerVersion")]
    pub signer_version: u64,
    #[serde(rename = "Timestamp")]
    pub timestamp: u64,
    #[serde(rename = "Vote")]
    pub vote: VoteType,
    #[serde(rename = "TransactionHash")]
    pub transaction_hash: [u8; 32],
    #[serde(rename = "Memo")]
    pub memo: String,
    #[serde(rename = "Data")]
    pub data: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Rational {
    #[serde(rename = "Numerator")]
    pub numerator: u64,
    #[serde(rename = "Denominator")]
    pub denominator: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReceiptSignature {
    #[serde(rename = "SourceNetwork")]
    pub source_network: String,
    #[serde(rename = "Proof")]
    pub proof: Vec<u8>,
    #[serde(rename = "TransactionHash")]
    pub transaction_hash: [u8; 32],
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RemoteSignature {
    #[serde(rename = "Destination")]
    pub destination: String,
    #[serde(rename = "Signature")]
    pub signature: serde_json::Value,
    #[serde(rename = "Cause")]
    pub cause: [u8; 32],
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RemoteTransaction {
    #[serde(rename = "Hash")]
    pub hash: [u8; 32],
}

// Type RemoteTransactionReason not found in graph


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RemoveAccountAuthorityOperation {
    #[serde(rename = "Authority")]
    pub authority: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RemoveKeyOperation {
    #[serde(rename = "Entry")]
    pub entry: KeySpecParams,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Route {
    #[serde(rename = "Length")]
    pub length: u64,
    #[serde(rename = "Value")]
    pub value: u64,
    #[serde(rename = "Partition")]
    pub partition: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RouteOverride {
    #[serde(rename = "Account")]
    pub account: String,
    #[serde(rename = "Partition")]
    pub partition: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RoutingTable {
    #[serde(rename = "Overrides")]
    pub overrides: RouteOverride,
    #[serde(rename = "Routes")]
    pub routes: Route,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RsaSha256Signature {
    #[serde(rename = "PublicKey")]
    pub public_key: Vec<u8>,
    #[serde(rename = "Signature")]
    pub signature: Vec<u8>,
    #[serde(rename = "Signer")]
    pub signer: String,
    #[serde(rename = "SignerVersion")]
    pub signer_version: u64,
    #[serde(rename = "Timestamp")]
    pub timestamp: u64,
    #[serde(rename = "Vote")]
    pub vote: VoteType,
    #[serde(rename = "TransactionHash")]
    pub transaction_hash: [u8; 32],
    #[serde(rename = "Memo")]
    pub memo: String,
    #[serde(rename = "Data")]
    pub data: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SendTokens {
    #[serde(rename = "Hash")]
    pub hash: [u8; 32],
    #[serde(rename = "Meta")]
    pub meta: serde_json::Value,
    #[serde(rename = "To")]
    pub to: TokenRecipient,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetRejectThresholdKeyPageOperation {
    #[serde(rename = "Threshold")]
    pub threshold: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetResponseThresholdKeyPageOperation {
    #[serde(rename = "Threshold")]
    pub threshold: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetThresholdKeyPageOperation {
    #[serde(rename = "Threshold")]
    pub threshold: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SignatureSet {
    #[serde(rename = "Vote")]
    pub vote: VoteType,
    #[serde(rename = "Signer")]
    pub signer: String,
    #[serde(rename = "TransactionHash")]
    pub transaction_hash: [u8; 32],
    #[serde(rename = "Signatures")]
    pub signatures: serde_json::Value,
    #[serde(rename = "Authority")]
    pub authority: String,
}

// Type SignatureType already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyntheticBurnTokens {
    #[serde(rename = "Amount")]
    pub amount: String,
    #[serde(rename = "IsRefund")]
    pub is_refund: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyntheticCreateIdentity {
    #[serde(rename = "Accounts")]
    pub accounts: serde_json::Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyntheticDepositCredits {
    #[serde(rename = "Amount")]
    pub amount: u64,
    #[serde(rename = "AcmeRefundAmount")]
    pub acme_refund_amount: String,
    #[serde(rename = "IsRefund")]
    pub is_refund: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyntheticDepositTokens {
    #[serde(rename = "Token")]
    pub token: String,
    #[serde(rename = "Amount")]
    pub amount: String,
    #[serde(rename = "IsIssuer")]
    pub is_issuer: bool,
    #[serde(rename = "IsRefund")]
    pub is_refund: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyntheticForwardTransaction {
    #[serde(rename = "Signatures")]
    pub signatures: RemoteSignature,
    #[serde(rename = "Transaction")]
    pub transaction: Transaction,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyntheticLedger {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "Sequence")]
    pub sequence: PartitionSyntheticLedger,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyntheticOrigin {
    #[serde(rename = "Cause")]
    pub cause: [u8; 32],
    #[serde(rename = "Source")]
    pub source: String,
    #[serde(rename = "Initiator")]
    pub initiator: String,
    #[serde(rename = "FeeRefund")]
    pub fee_refund: u64,
    #[serde(rename = "Index")]
    pub index: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyntheticWriteData {
    #[serde(rename = "Entry")]
    pub entry: serde_json::Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SystemGenesis {
    // Union variants would be populated based on the union definition
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SystemLedger {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "Index")]
    pub index: u64,
    #[serde(rename = "Timestamp")]
    pub timestamp: String,
    #[serde(rename = "AcmeBurnt")]
    pub acme_burnt: String,
    #[serde(rename = "PendingUpdates")]
    pub pending_updates: NetworkAccountUpdate,
    #[serde(rename = "Anchor")]
    pub anchor: serde_json::Value,
    #[serde(rename = "ExecutorVersion")]
    pub executor_version: ExecutorVersion,
    #[serde(rename = "BvnExecutorVersions")]
    pub bvn_executor_versions: PartitionExecutorVersion,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SystemWriteData {
    #[serde(rename = "Entry")]
    pub entry: serde_json::Value,
    #[serde(rename = "WriteToState")]
    pub write_to_state: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TokenAccount {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "TokenUrl")]
    pub token_url: String,
    #[serde(rename = "Balance")]
    pub balance: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TokenIssuer {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "Symbol")]
    pub symbol: String,
    #[serde(rename = "Precision")]
    pub precision: u64,
    #[serde(rename = "Properties")]
    pub properties: String,
    #[serde(rename = "Issued")]
    pub issued: String,
    #[serde(rename = "SupplyLimit")]
    pub supply_limit: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TokenIssuerProof {
    #[serde(rename = "Transaction")]
    pub transaction: CreateToken,
    #[serde(rename = "Receipt")]
    pub receipt: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TokenRecipient {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "Amount")]
    pub amount: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Transaction {
    #[serde(rename = "Header")]
    pub header: TransactionHeader,
    #[serde(rename = "Body")]
    pub body: serde_json::Value,
    pub hash: Vec<u8>,
    pub header64bytes: bool,
    pub body64bytes: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TransactionHeader {
    #[serde(rename = "Principal")]
    pub principal: String,
    #[serde(rename = "Initiator")]
    pub initiator: [u8; 32],
    #[serde(rename = "Memo")]
    pub memo: String,
    #[serde(rename = "Metadata")]
    pub metadata: Vec<u8>,
    #[serde(rename = "Expire")]
    pub expire: ExpireOptions,
    #[serde(rename = "HoldUntil")]
    pub hold_until: HoldUntilOptions,
    #[serde(rename = "Authorities")]
    pub authorities: String,
}

// Type TransactionMax already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TransactionResultSet {
    #[serde(rename = "Results")]
    pub results: TransactionStatus,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TransactionStatus {
    #[serde(rename = "TxID")]
    pub tx_id: [u8; 32],
    #[serde(rename = "Code")]
    pub code: String,
    #[serde(rename = "Remote")]
    pub remote: bool,
    #[serde(rename = "Delivered")]
    pub delivered: bool,
    #[serde(rename = "Pending")]
    pub pending: bool,
    #[serde(rename = "Failed")]
    pub failed: bool,
    #[serde(rename = "CodeNum")]
    pub code_num: u64,
    #[serde(rename = "Error")]
    pub error: String,
    #[serde(rename = "Result")]
    pub result: serde_json::Value,
    #[serde(rename = "Received")]
    pub received: u64,
    #[serde(rename = "Initiator")]
    pub initiator: String,
    #[serde(rename = "Signers")]
    pub signers: String,
    #[serde(rename = "SourceNetwork")]
    pub source_network: String,
    #[serde(rename = "DestinationNetwork")]
    pub destination_network: String,
    #[serde(rename = "SequenceNumber")]
    pub sequence_number: u64,
    #[serde(rename = "GotDirectoryReceipt")]
    pub got_directory_receipt: bool,
    #[serde(rename = "Proof")]
    pub proof: Vec<u8>,
    #[serde(rename = "AnchorSigners")]
    pub anchor_signers: Vec<u8>,
}

// Type TransactionType already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TransferCredits {
    #[serde(rename = "To")]
    pub to: CreditRecipient,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TxIdSet {
    #[serde(rename = "Entries")]
    pub entries: [u8; 32],
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TypedDataSignature {
    #[serde(rename = "PublicKey")]
    pub public_key: Vec<u8>,
    #[serde(rename = "Signature")]
    pub signature: Vec<u8>,
    #[serde(rename = "Signer")]
    pub signer: String,
    #[serde(rename = "SignerVersion")]
    pub signer_version: u64,
    #[serde(rename = "Timestamp")]
    pub timestamp: u64,
    #[serde(rename = "Vote")]
    pub vote: VoteType,
    #[serde(rename = "TransactionHash")]
    pub transaction_hash: [u8; 32],
    #[serde(rename = "Memo")]
    pub memo: String,
    #[serde(rename = "Data")]
    pub data: Vec<u8>,
    #[serde(rename = "ChainID")]
    pub chain_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UnknownAccount {
    #[serde(rename = "Url")]
    pub url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UnknownSigner {
    #[serde(rename = "Url")]
    pub url: String,
    #[serde(rename = "Version")]
    pub version: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UpdateAccountAuth {
    #[serde(rename = "Operations")]
    pub operations: serde_json::Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UpdateAllowedKeyPageOperation {
    #[serde(rename = "Allow")]
    pub allow: TransactionType,
    #[serde(rename = "Deny")]
    pub deny: TransactionType,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UpdateKey {
    #[serde(rename = "NewKeyHash")]
    pub new_key_hash: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UpdateKeyOperation {
    #[serde(rename = "OldEntry")]
    pub old_entry: KeySpecParams,
    #[serde(rename = "NewEntry")]
    pub new_entry: KeySpecParams,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UpdateKeyPage {
    #[serde(rename = "Operation")]
    pub operation: serde_json::Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ValidatorInfo {
    #[serde(rename = "PublicKey")]
    pub public_key: Vec<u8>,
    #[serde(rename = "PublicKeyHash")]
    pub public_key_hash: [u8; 32],
    #[serde(rename = "Operator")]
    pub operator: String,
    #[serde(rename = "Partitions")]
    pub partitions: ValidatorPartitionInfo,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ValidatorPartitionInfo {
    #[serde(rename = "ID")]
    pub id: String,
    #[serde(rename = "Active")]
    pub active: bool,
}

// Type VoteType already defined in enums module


#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WriteData {
    #[serde(rename = "Entry")]
    pub entry: serde_json::Value,
    #[serde(rename = "Scratch")]
    pub scratch: bool,
    #[serde(rename = "WriteToState")]
    pub write_to_state: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WriteDataResult {
    #[serde(rename = "EntryHash")]
    pub entry_hash: [u8; 32],
    #[serde(rename = "AccountUrl")]
    pub account_url: String,
    #[serde(rename = "AccountID")]
    pub account_id: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WriteDataTo {
    #[serde(rename = "Recipient")]
    pub recipient: String,
    #[serde(rename = "Entry")]
    pub entry: serde_json::Value,
}