hedera_network

type AccountAmount struct {

	// *
	// The Account ID that sends/receives cryptocurrency or tokens
	AccountID *AccountID `protobuf:"bytes,1,opt,name=accountID,proto3" json:"accountID,omitempty"`
	// *
	// The amount of tinybars (for Crypto transfers) or in the lowest
	// denomination (for Token transfers) that the account sends(negative) or
	// receives(positive)
	Amount int64 `protobuf:"zigzag64,2,opt,name=amount,proto3" json:"amount,omitempty"`
	// *
	// If true then the transfer is expected to be an approved allowance and the
	// accountID is expected to be the owner. The default is false (omitted).
	IsApproval bool `protobuf:"varint,3,opt,name=is_approval,json=isApproval,proto3" json:"is_approval,omitempty"`
	// contains filtered or unexported fields
}

type AccountID struct {

	// *
	// The shard number (nonnegative)
	ShardNum int64 `protobuf:"varint,1,opt,name=shardNum,proto3" json:"shardNum,omitempty"`
	// *
	// The realm number (nonnegative)
	RealmNum int64 `protobuf:"varint,2,opt,name=realmNum,proto3" json:"realmNum,omitempty"`
	// *
	// The account number unique within its realm which can be either a non-negative integer or an alias public key.
	// For any AccountID fields in the query response, transaction record or transaction receipt only accountNum will
	// be populated.
	//
	// Types that are valid to be assigned to Account:
	//
	//	*AccountID_AccountNum
	//	*AccountID_Alias
	Account isAccountID_Account `protobuf_oneof:"account"`
	// contains filtered or unexported fields
}

type AccountID_AccountNum struct {
	// *
	// A non-negative account number unique within its realm
	AccountNum int64 `protobuf:"varint,3,opt,name=accountNum,proto3,oneof"`
}

type AccountID_Alias struct {
	// *
	// The public key bytes to be used as the account's alias. The public key bytes are the result of serializing
	// a protobuf Key message for any primitive key type. Currently only primitive key bytes are supported as an alias
	// (ThresholdKey, KeyList, ContractID, and delegatable_contract_id are not supported)
	//
	// May also be the ethereum account 20-byte EVM address to be used initially in place of the public key bytes. This EVM
	// address may be either the encoded form of the shard.realm.num or the keccak-256 hash of a ECDSA_SECP256K1 primitive key.
	//
	// At most one account can ever have a given alias and it is used for account creation if it
	// was automatically created using a crypto transfer. It will be null if an account is created normally.
	// It is immutable once it is set for an account.
	//
	// If a transaction auto-creates the account, any further transfers to that alias will simply be deposited
	// in that account, without creating anything, and with no creation fee being charged.
	//
	// If a transaction lazily-creates this account, a subsequent transaction will be required containing the public key bytes
	// that map to the EVM address bytes. The provided public key bytes will then serve as the final alias bytes.
	Alias []byte `protobuf:"bytes,4,opt,name=alias,proto3,oneof"`
}

type ContractID struct {

	// *
	// The shard number (nonnegative)
	ShardNum int64 `protobuf:"varint,1,opt,name=shardNum,proto3" json:"shardNum,omitempty"`
	// *
	// The realm number (nonnegative)
	RealmNum int64 `protobuf:"varint,2,opt,name=realmNum,proto3" json:"realmNum,omitempty"`
	// Types that are valid to be assigned to Contract:
	//
	//	*ContractID_ContractNum
	//	*ContractID_EvmAddress
	Contract isContractID_Contract `protobuf_oneof:"contract"`
	// contains filtered or unexported fields
}

type ContractID_ContractNum struct {
	// *
	// A nonnegative number unique within a given shard and realm
	ContractNum int64 `protobuf:"varint,3,opt,name=contractNum,proto3,oneof"`
}

type ContractID_EvmAddress struct {
	// *
	// The 20-byte EVM address of the contract to call.
	//
	// Every contract has an EVM address determined by its <tt>shard.realm.num</tt> id.
	// This address is as follows:
	//
	//	<ol>
	//	  <li>The first 4 bytes are the big-endian representation of the shard.</li>
	//	  <li>The next 8 bytes are the big-endian representation of the realm.</li>
	//	  <li>The final 8 bytes are the big-endian representation of the number.</li>
	//	</ol>
	//
	// Contracts created via CREATE2 have an <b>additional, primary address</b> that is
	// derived from the <a href="https://eips.ethereum.org/EIPS/eip-1014">EIP-1014</a>
	// specification, and does not have a simple relation to a <tt>shard.realm.num</tt> id.
	//
	// (Please do note that CREATE2 contracts can also be referenced by the three-part
	// EVM address described above.)
	EvmAddress []byte `protobuf:"bytes,4,opt,name=evm_address,json=evmAddress,proto3,oneof"`
}

type CryptoTransferTransactionBody struct {

	// *
	// The desired hbar balance adjustments
	Transfers *TransferList `protobuf:"bytes,1,opt,name=transfers,proto3" json:"transfers,omitempty"`
	// *
	// The desired token unit balance adjustments; if any custom fees are assessed, the ledger will
	// try to deduct them from the payer of this CryptoTransfer, resolving the transaction to
	// INSUFFICIENT_PAYER_BALANCE_FOR_CUSTOM_FEE if this is not possible
	TokenTransfers []*TokenTransferList `protobuf:"bytes,2,rep,name=tokenTransfers,proto3" json:"tokenTransfers,omitempty"`
	// contains filtered or unexported fields
}

type CurrentAndNextFeeSchedule struct {

	// *
	// Contains current Fee Schedule
	CurrentFeeSchedule *FeeSchedule `protobuf:"bytes,1,opt,name=currentFeeSchedule,proto3" json:"currentFeeSchedule,omitempty"`
	// *
	// Contains next Fee Schedule
	NextFeeSchedule *FeeSchedule `protobuf:"bytes,2,opt,name=nextFeeSchedule,proto3" json:"nextFeeSchedule,omitempty"`
	// contains filtered or unexported fields
}

type Duration struct {

	// *
	// The number of seconds
	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
	// contains filtered or unexported fields
}

type FeeComponents struct {

	// *
	// A minimum, the calculated fee must be greater than this value
	Min int64 `protobuf:"varint,1,opt,name=min,proto3" json:"min,omitempty"`
	// *
	// A maximum, the calculated fee must be less than this value
	Max int64 `protobuf:"varint,2,opt,name=max,proto3" json:"max,omitempty"`
	// *
	// A constant contribution to the fee
	Constant int64 `protobuf:"varint,3,opt,name=constant,proto3" json:"constant,omitempty"`
	// *
	// The price of bandwidth consumed by a transaction, measured in bytes
	Bpt int64 `protobuf:"varint,4,opt,name=bpt,proto3" json:"bpt,omitempty"`
	// *
	// The price per signature verification for a transaction
	Vpt int64 `protobuf:"varint,5,opt,name=vpt,proto3" json:"vpt,omitempty"`
	// *
	// The price of RAM consumed by a transaction, measured in byte-hours
	Rbh int64 `protobuf:"varint,6,opt,name=rbh,proto3" json:"rbh,omitempty"`
	// *
	// The price of storage consumed by a transaction, measured in byte-hours
	Sbh int64 `protobuf:"varint,7,opt,name=sbh,proto3" json:"sbh,omitempty"`
	// *
	// The price of computation for a smart contract transaction, measured in gas
	Gas int64 `protobuf:"varint,8,opt,name=gas,proto3" json:"gas,omitempty"`
	// *
	// The price per hbar transferred for a transfer
	Tv int64 `protobuf:"varint,9,opt,name=tv,proto3" json:"tv,omitempty"`
	// *
	// The price of bandwidth for data retrieved from memory for a response, measured in bytes
	Bpr int64 `protobuf:"varint,10,opt,name=bpr,proto3" json:"bpr,omitempty"`
	// *
	// The price of bandwidth for data retrieved from disk for a response, measured in bytes
	Sbpr int64 `protobuf:"varint,11,opt,name=sbpr,proto3" json:"sbpr,omitempty"`
	// contains filtered or unexported fields
}

type FeeData struct {

	// *
	// Fee paid to the submitting node
	Nodedata *FeeComponents `protobuf:"bytes,1,opt,name=nodedata,proto3" json:"nodedata,omitempty"`
	// *
	// Fee paid to the network for processing a transaction into consensus
	Networkdata *FeeComponents `protobuf:"bytes,2,opt,name=networkdata,proto3" json:"networkdata,omitempty"`
	// *
	// Fee paid to the network for providing the service associated with the
	// transaction; for instance, storing a file
	Servicedata *FeeComponents `protobuf:"bytes,3,opt,name=servicedata,proto3" json:"servicedata,omitempty"`
	// *
	// SubType distinguishing between different types of FeeData, correlating
	// to the same HederaFunctionality
	SubType SubType `protobuf:"varint,4,opt,name=subType,proto3,enum=proto.SubType" json:"subType,omitempty"`
	// contains filtered or unexported fields
}

type FeeSchedule struct {

	// *
	// List of price coefficients for network resources
	TransactionFeeSchedule []*TransactionFeeSchedule `protobuf:"bytes,1,rep,name=transactionFeeSchedule,proto3" json:"transactionFeeSchedule,omitempty"`
	// *
	// FeeSchedule expiry time
	ExpiryTime *TimestampSeconds `protobuf:"bytes,2,opt,name=expiryTime,proto3" json:"expiryTime,omitempty"`
	// contains filtered or unexported fields
}

type FileID struct {

	// *
	// The shard number (nonnegative)
	ShardNum int64 `protobuf:"varint,1,opt,name=shardNum,proto3" json:"shardNum,omitempty"`
	// *
	// The realm number (nonnegative)
	RealmNum int64 `protobuf:"varint,2,opt,name=realmNum,proto3" json:"realmNum,omitempty"`
	// *
	// A nonnegative File number unique within its realm
	FileNum int64 `protobuf:"varint,3,opt,name=fileNum,proto3" json:"fileNum,omitempty"`
	// contains filtered or unexported fields
}

type Fraction struct {

	// *
	// The rational's numerator
	Numerator int64 `protobuf:"varint,1,opt,name=numerator,proto3" json:"numerator,omitempty"`
	// *
	// The rational's denominator; a zero value will result in FRACTION_DIVIDES_BY_ZERO
	Denominator int64 `protobuf:"varint,2,opt,name=denominator,proto3" json:"denominator,omitempty"`
	// contains filtered or unexported fields
}

type HederaFunctionality int32

type Key struct {

	// Types that are valid to be assigned to Key:
	//
	//	*Key_ContractID
	//	*Key_Ed25519
	//	*Key_RSA_3072
	//	*Key_ECDSA_384
	//	*Key_ThresholdKey
	//	*Key_KeyList
	//	*Key_ECDSASecp256K1
	//	*Key_DelegatableContractId
	Key isKey_Key `protobuf_oneof:"key"`
	// contains filtered or unexported fields
}

type KeyList struct {

	// *
	// list of keys
	Keys []*Key `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`
	// contains filtered or unexported fields
}

type Key_ContractID struct {
	// *
	// smart contract instance that is authorized as if it had signed with a key
	ContractID *ContractID `protobuf:"bytes,1,opt,name=contractID,proto3,oneof"`
}

type Key_DelegatableContractId struct {
	// *
	// A smart contract that, if the recipient of the active message frame, should be treated
	// as having signed. (Note this does not mean the <i>code being executed in the frame</i>
	// will belong to the given contract, since it could be running another contract's code via
	// <tt>delegatecall</tt>. So setting this key is a more permissive version of setting the
	// contractID key, which also requires the code in the active message frame belong to the
	// the contract with the given id.)
	DelegatableContractId *ContractID `protobuf:"bytes,8,opt,name=delegatable_contract_id,json=delegatableContractId,proto3,oneof"`
}

type Key_ECDSASecp256K1 struct {
	// *
	// Compressed ECDSA(secp256k1) public key bytes
	ECDSASecp256K1 []byte `protobuf:"bytes,7,opt,name=ECDSA_secp256k1,json=ECDSASecp256k1,proto3,oneof"`
}

type Key_ECDSA_384 struct {
	// *
	// (NOT SUPPORTED) ECDSA with the p-384 curve public key bytes
	ECDSA_384 []byte `protobuf:"bytes,4,opt,name=ECDSA_384,json=ECDSA384,proto3,oneof"`
}

type Key_Ed25519 struct {
	// *
	// Ed25519 public key bytes
	Ed25519 []byte `protobuf:"bytes,2,opt,name=ed25519,proto3,oneof"`
}

type Key_KeyList struct {
	// *
	// A list of Keys of the Key type.
	KeyList *KeyList `protobuf:"bytes,6,opt,name=keyList,proto3,oneof"`
}

type Key_RSA_3072 struct {
	// *
	// (NOT SUPPORTED) RSA-3072 public key bytes
	RSA_3072 []byte `protobuf:"bytes,3,opt,name=RSA_3072,json=RSA3072,proto3,oneof"`
}

type Key_ThresholdKey struct {
	// *
	// a threshold N followed by a list of M keys, any N of which are required to form a valid
	// signature
	ThresholdKey *ThresholdKey `protobuf:"bytes,5,opt,name=thresholdKey,proto3,oneof"`
}

type NftTransfer struct {

	// *
	// The accountID of the sender
	SenderAccountID *AccountID `protobuf:"bytes,1,opt,name=senderAccountID,proto3" json:"senderAccountID,omitempty"`
	// *
	// The accountID of the receiver
	ReceiverAccountID *AccountID `protobuf:"bytes,2,opt,name=receiverAccountID,proto3" json:"receiverAccountID,omitempty"`
	// *
	// The serial number of the NFT
	SerialNumber int64 `protobuf:"varint,3,opt,name=serialNumber,proto3" json:"serialNumber,omitempty"`
	// *
	// If true then the transfer is expected to be an approved allowance and the
	// senderAccountID is expected to be the owner. The default is false (omitted).
	IsApproval bool `protobuf:"varint,4,opt,name=is_approval,json=isApproval,proto3" json:"is_approval,omitempty"`
	// contains filtered or unexported fields
}

type NodeAddress struct {

	// *
	// The IP address of the Node with separator & octets encoded in UTF-8.  Usage is deprecated,
	// ServiceEndpoint is preferred to retrieve a node's list of IP addresses and ports
	//
	// Deprecated: Marked as deprecated in basic_types.proto.
	IpAddress []byte `protobuf:"bytes,1,opt,name=ipAddress,proto3" json:"ipAddress,omitempty"`
	// *
	// The port number of the grpc server for the node.  Usage is deprecated, ServiceEndpoint is
	// preferred to retrieve a node's list of IP addresses and ports
	//
	// Deprecated: Marked as deprecated in basic_types.proto.
	Portno int32 `protobuf:"varint,2,opt,name=portno,proto3" json:"portno,omitempty"`
	// *
	// Usage is deprecated, nodeAccountId is preferred to retrieve a node's account ID
	//
	// Deprecated: Marked as deprecated in basic_types.proto.
	Memo []byte `protobuf:"bytes,3,opt,name=memo,proto3" json:"memo,omitempty"`
	// *
	// The node's X509 RSA public key used to sign stream files (e.g., record stream
	// files). Precisely, this field is a string of hexadecimal characters which,
	// translated to binary, are the public key's DER encoding.
	RSA_PubKey string `protobuf:"bytes,4,opt,name=RSA_PubKey,json=RSAPubKey,proto3" json:"RSA_PubKey,omitempty"`
	// *
	// # A non-sequential identifier for the node
	NodeId int64 `protobuf:"varint,5,opt,name=nodeId,proto3" json:"nodeId,omitempty"`
	// *
	// # The account to be paid for queries and transactions sent to this node
	NodeAccountId *AccountID `protobuf:"bytes,6,opt,name=nodeAccountId,proto3" json:"nodeAccountId,omitempty"`
	// *
	// # Hash of the node's TLS certificate. Precisely, this field is a string of
	// hexadecimal characters which, translated to binary, are the SHA-384 hash of
	// the UTF-8 NFKD encoding of the node's TLS cert in PEM format. Its value can be
	// used to verify the node's certificate it presents during TLS negotiations.
	NodeCertHash []byte `protobuf:"bytes,7,opt,name=nodeCertHash,proto3" json:"nodeCertHash,omitempty"`
	// *
	// # A node's service IP addresses and ports
	ServiceEndpoint []*ServiceEndpoint `protobuf:"bytes,8,rep,name=serviceEndpoint,proto3" json:"serviceEndpoint,omitempty"`
	// *
	// A description of the node, with UTF-8 encoding up to 100 bytes
	Description string `protobuf:"bytes,9,opt,name=description,proto3" json:"description,omitempty"`
	// *
	// [Deprecated] The amount of tinybars staked to the node
	//
	// Deprecated: Marked as deprecated in basic_types.proto.
	Stake int64 `protobuf:"varint,10,opt,name=stake,proto3" json:"stake,omitempty"`
	// contains filtered or unexported fields
}

type NodeAddressBook struct {

	// *
	// Metadata of all nodes in the network
	NodeAddress []*NodeAddress `protobuf:"bytes,1,rep,name=nodeAddress,proto3" json:"nodeAddress,omitempty"`
	// contains filtered or unexported fields
}

type RealmID struct {

	// *
	// The shard number (nonnegative)
	ShardNum int64 `protobuf:"varint,1,opt,name=shardNum,proto3" json:"shardNum,omitempty"`
	// *
	// The realm number (nonnegative)
	RealmNum int64 `protobuf:"varint,2,opt,name=realmNum,proto3" json:"realmNum,omitempty"`
	// contains filtered or unexported fields
}

type ScheduleID struct {

	// *
	// A nonnegative shard number
	ShardNum int64 `protobuf:"varint,1,opt,name=shardNum,proto3" json:"shardNum,omitempty"`
	// *
	// A nonnegative realm number
	RealmNum int64 `protobuf:"varint,2,opt,name=realmNum,proto3" json:"realmNum,omitempty"`
	// *
	// A nonnegative schedule number
	ScheduleNum int64 `protobuf:"varint,3,opt,name=scheduleNum,proto3" json:"scheduleNum,omitempty"`
	// contains filtered or unexported fields
}

type SemanticVersion struct {

	// *
	// Increases with incompatible API changes
	Major int32 `protobuf:"varint,1,opt,name=major,proto3" json:"major,omitempty"`
	// *
	// Increases with backwards-compatible new functionality
	Minor int32 `protobuf:"varint,2,opt,name=minor,proto3" json:"minor,omitempty"`
	// *
	// Increases with backwards-compatible bug fixes
	Patch int32 `protobuf:"varint,3,opt,name=patch,proto3" json:"patch,omitempty"`
	// *
	// A pre-release version MAY be denoted by appending a hyphen and a series of dot separated
	// identifiers (https://semver.org/#spec-item-9); so given a semver 0.14.0-alpha.1+21AF26D3,
	// this field would contain 'alpha.1'
	Pre string `protobuf:"bytes,4,opt,name=pre,proto3" json:"pre,omitempty"`
	// *
	// Build metadata MAY be denoted by appending a plus sign and a series of dot separated
	// identifiers immediately following the patch or pre-release version
	// (https://semver.org/#spec-item-10); so given a semver 0.14.0-alpha.1+21AF26D3, this field
	// would contain '21AF26D3'
	Build string `protobuf:"bytes,5,opt,name=build,proto3" json:"build,omitempty"`
	// contains filtered or unexported fields
}

type ServiceEndpoint struct {

	// *
	// The 32-bit IPv4 address of the node encoded in left to right order (e.g.  127.0.0.1 has 127
	// as its first byte)
	IpAddressV4 []byte `protobuf:"bytes,1,opt,name=ipAddressV4,proto3" json:"ipAddressV4,omitempty"`
	// *
	// The port of the node
	Port int32 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	// contains filtered or unexported fields
}

type ServicesConfigurationList struct {

	// *
	// list of name value pairs of the application properties
	NameValue []*Setting `protobuf:"bytes,1,rep,name=nameValue,proto3" json:"nameValue,omitempty"`
	// contains filtered or unexported fields
}

type Setting struct {

	// *
	// name of the property
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// *
	// value of the property
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// *
	// any data associated with property
	Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	// contains filtered or unexported fields
}

type ShardID struct {

	// *
	// the shard number (nonnegative)
	ShardNum int64 `protobuf:"varint,1,opt,name=shardNum,proto3" json:"shardNum,omitempty"`
	// contains filtered or unexported fields
}

type SignatureMap struct {

	// *
	// Each signature pair corresponds to a unique Key required to sign the transaction.
	SigPair []*SignaturePair `protobuf:"bytes,1,rep,name=sigPair,proto3" json:"sigPair,omitempty"`
	// contains filtered or unexported fields
}

type SignaturePair struct {

	// *
	// First few bytes of the public key
	PubKeyPrefix []byte `protobuf:"bytes,1,opt,name=pubKeyPrefix,proto3" json:"pubKeyPrefix,omitempty"`
	// Types that are valid to be assigned to Signature:
	//
	//	*SignaturePair_Contract
	//	*SignaturePair_Ed25519
	//	*SignaturePair_RSA_3072
	//	*SignaturePair_ECDSA_384
	//	*SignaturePair_ECDSASecp256K1
	Signature isSignaturePair_Signature `protobuf_oneof:"signature"`
	// contains filtered or unexported fields
}

type SignaturePair_Contract struct {
	// *
	// smart contract virtual signature (always length zero)
	Contract []byte `protobuf:"bytes,2,opt,name=contract,proto3,oneof"`
}

type SignaturePair_ECDSASecp256K1 struct {
	// *
	// ECDSA(secp256k1) signature
	ECDSASecp256K1 []byte `protobuf:"bytes,6,opt,name=ECDSA_secp256k1,json=ECDSASecp256k1,proto3,oneof"`
}

type SignaturePair_ECDSA_384 struct {
	// *
	// ECDSA p-384 signature
	ECDSA_384 []byte `protobuf:"bytes,5,opt,name=ECDSA_384,json=ECDSA384,proto3,oneof"`
}

type SignaturePair_Ed25519 struct {
	// *
	// ed25519 signature
	Ed25519 []byte `protobuf:"bytes,3,opt,name=ed25519,proto3,oneof"`
}

type SignaturePair_RSA_3072 struct {
	// *
	// RSA-3072 signature
	RSA_3072 []byte `protobuf:"bytes,4,opt,name=RSA_3072,json=RSA3072,proto3,oneof"`
}

type Signature_Contract struct {
	// *
	// smart contract virtual signature (always length zero)
	Contract []byte `protobuf:"bytes,1,opt,name=contract,proto3,oneof"`
}

type Signature_ECDSA_384 struct {
	// *
	// ECDSA p-384 signature bytes
	ECDSA_384 []byte `protobuf:"bytes,4,opt,name=ECDSA_384,json=ECDSA384,proto3,oneof"`
}

type Signature_Ed25519 struct {
	// *
	// ed25519 signature bytes
	Ed25519 []byte `protobuf:"bytes,2,opt,name=ed25519,proto3,oneof"`
}

type Signature_RSA_3072 struct {
	// *
	// RSA-3072 signature bytes
	RSA_3072 []byte `protobuf:"bytes,3,opt,name=RSA_3072,json=RSA3072,proto3,oneof"`
}

type Signature_SignatureList struct {
	// *
	// A list of M signatures, each corresponding to a Key in a KeyList of the same length.
	SignatureList *SignatureList `protobuf:"bytes,6,opt,name=signatureList,proto3,oneof"`
}

type Signature_ThresholdSignature struct {
	// *
	// A list of signatures for a single N-of-M threshold Key. This must be a list of exactly M
	// signatures, at least N of which are non-null.
	ThresholdSignature *ThresholdSignature `protobuf:"bytes,5,opt,name=thresholdSignature,proto3,oneof"`
}

type SignedTransaction struct {

	// *
	// TransactionBody serialized into bytes, which needs to be signed
	BodyBytes []byte `protobuf:"bytes,1,opt,name=bodyBytes,proto3" json:"bodyBytes,omitempty"`
	// *
	// The signatures on the body with the new format, to authorize the transaction
	SigMap *SignatureMap `protobuf:"bytes,2,opt,name=sigMap,proto3" json:"sigMap,omitempty"`
	// contains filtered or unexported fields
}

type StakingInfo struct {

	// *
	// If true, this account or contract declined to receive a staking reward.
	DeclineReward bool `protobuf:"varint,1,opt,name=decline_reward,json=declineReward,proto3" json:"decline_reward,omitempty"`
	// *
	// The staking period during which either the staking settings for this account or contract changed (such as starting
	// staking or changing staked_node_id) or the most recent reward was earned, whichever is later. If this account or contract
	// is not currently staked to a node, then this field is not set.
	StakePeriodStart *Timestamp `protobuf:"bytes,2,opt,name=stake_period_start,json=stakePeriodStart,proto3" json:"stake_period_start,omitempty"`
	// *
	// The amount in tinybars that will be received in the next reward situation.
	PendingReward int64 `protobuf:"varint,3,opt,name=pending_reward,json=pendingReward,proto3" json:"pending_reward,omitempty"`
	// *
	// The total of balance of all accounts staked to this account or contract.
	StakedToMe int64 `protobuf:"varint,4,opt,name=staked_to_me,json=stakedToMe,proto3" json:"staked_to_me,omitempty"`
	// *
	// ID of the account or node to which this account or contract is staking.
	//
	// Types that are valid to be assigned to StakedId:
	//
	//	*StakingInfo_StakedAccountId
	//	*StakingInfo_StakedNodeId
	StakedId isStakingInfo_StakedId `protobuf_oneof:"staked_id"`
	// contains filtered or unexported fields
}

type StakingInfo_StakedAccountId struct {
	// *
	// The account to which this account or contract is staking.
	StakedAccountId *AccountID `protobuf:"bytes,5,opt,name=staked_account_id,json=stakedAccountId,proto3,oneof"`
}

type StakingInfo_StakedNodeId struct {
	// *
	// The ID of the node this account or contract is staked to.
	StakedNodeId int64 `protobuf:"varint,6,opt,name=staked_node_id,json=stakedNodeId,proto3,oneof"`
}

type SubType int32

type ThresholdKey struct {

	// *
	// A valid signature set must have at least this many signatures
	Threshold uint32 `protobuf:"varint,1,opt,name=threshold,proto3" json:"threshold,omitempty"`
	// *
	// List of all the keys that can sign
	Keys *KeyList `protobuf:"bytes,2,opt,name=keys,proto3" json:"keys,omitempty"`
	// contains filtered or unexported fields
}

type Timestamp struct {

	// *
	// Number of complete seconds since the start of the epoch
	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
	// *
	// Number of nanoseconds since the start of the last second
	Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
	// contains filtered or unexported fields
}

type TimestampSeconds struct {

	// *
	// Number of complete seconds since the start of the epoch
	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
	// contains filtered or unexported fields
}

type TokenAssociation struct {
	TokenId   *TokenID   `protobuf:"bytes,1,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"`       // The token involved in the association
	AccountId *AccountID `protobuf:"bytes,2,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"` // The account involved in the association
	// contains filtered or unexported fields
}

type TokenBalance struct {

	// *
	// A unique token id
	TokenId *TokenID `protobuf:"bytes,1,opt,name=tokenId,proto3" json:"tokenId,omitempty"`
	// *
	// Number of transferable units of the identified token. For token of type FUNGIBLE_COMMON -
	// balance in the smallest denomination. For token of type NON_FUNGIBLE_UNIQUE - the number of
	// NFTs held by the account
	Balance uint64 `protobuf:"varint,2,opt,name=balance,proto3" json:"balance,omitempty"`
	// *
	// Tokens divide into <tt>10<sup>decimals</sup></tt> pieces
	Decimals uint32 `protobuf:"varint,3,opt,name=decimals,proto3" json:"decimals,omitempty"`
	// contains filtered or unexported fields
}

type TokenBalances struct {
	TokenBalances []*TokenBalance `protobuf:"bytes,1,rep,name=tokenBalances,proto3" json:"tokenBalances,omitempty"`
	// contains filtered or unexported fields
}

type TokenFreezeStatus int32

type TokenID struct {

	// *
	// A nonnegative shard number
	ShardNum int64 `protobuf:"varint,1,opt,name=shardNum,proto3" json:"shardNum,omitempty"`
	// *
	// A nonnegative realm number
	RealmNum int64 `protobuf:"varint,2,opt,name=realmNum,proto3" json:"realmNum,omitempty"`
	// *
	// A nonnegative token number
	TokenNum int64 `protobuf:"varint,3,opt,name=tokenNum,proto3" json:"tokenNum,omitempty"`
	// contains filtered or unexported fields
}

type TokenKycStatus int32

type TokenPauseStatus int32

type TokenRelationship struct {

	// *
	// The ID of the token
	TokenId *TokenID `protobuf:"bytes,1,opt,name=tokenId,proto3" json:"tokenId,omitempty"`
	// *
	// The Symbol of the token
	Symbol string `protobuf:"bytes,2,opt,name=symbol,proto3" json:"symbol,omitempty"`
	// *
	// For token of type FUNGIBLE_COMMON - the balance that the Account holds in the smallest
	// denomination. For token of type NON_FUNGIBLE_UNIQUE - the number of NFTs held by the account
	Balance uint64 `protobuf:"varint,3,opt,name=balance,proto3" json:"balance,omitempty"`
	// *
	// The KYC status of the account (KycNotApplicable, Granted or Revoked). If the token does not
	// have KYC key, KycNotApplicable is returned
	KycStatus TokenKycStatus `protobuf:"varint,4,opt,name=kycStatus,proto3,enum=proto.TokenKycStatus" json:"kycStatus,omitempty"`
	// *
	// The Freeze status of the account (FreezeNotApplicable, Frozen or Unfrozen). If the token does
	// not have Freeze key, FreezeNotApplicable is returned
	FreezeStatus TokenFreezeStatus `protobuf:"varint,5,opt,name=freezeStatus,proto3,enum=proto.TokenFreezeStatus" json:"freezeStatus,omitempty"`
	// *
	// Tokens divide into <tt>10<sup>decimals</sup></tt> pieces
	Decimals uint32 `protobuf:"varint,6,opt,name=decimals,proto3" json:"decimals,omitempty"`
	// *
	// Specifies if the relationship is created implicitly. False : explicitly associated, True :
	// implicitly associated.
	AutomaticAssociation bool `protobuf:"varint,7,opt,name=automatic_association,json=automaticAssociation,proto3" json:"automatic_association,omitempty"`
	// contains filtered or unexported fields
}

type TokenSupplyType int32

type TokenTransferList struct {

	// *
	// The ID of the token
	Token *TokenID `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	// *
	// Applicable to tokens of type FUNGIBLE_COMMON. Multiple list of AccountAmounts, each of which
	// has an account and amount
	Transfers []*AccountAmount `protobuf:"bytes,2,rep,name=transfers,proto3" json:"transfers,omitempty"`
	// *
	// Applicable to tokens of type NON_FUNGIBLE_UNIQUE. Multiple list of NftTransfers, each of
	// which has a sender and receiver account, including the serial number of the NFT
	NftTransfers []*NftTransfer `protobuf:"bytes,3,rep,name=nftTransfers,proto3" json:"nftTransfers,omitempty"`
	// *
	// If present, the number of decimals this fungible token type is expected to have. The transfer
	// will fail with UNEXPECTED_TOKEN_DECIMALS if the actual decimals differ.
	ExpectedDecimals *wrapperspb.UInt32Value `protobuf:"bytes,4,opt,name=expected_decimals,json=expectedDecimals,proto3" json:"expected_decimals,omitempty"`
	// contains filtered or unexported fields
}

type TokenType int32

type TopicID struct {

	// *
	// The shard number (nonnegative)
	ShardNum int64 `protobuf:"varint,1,opt,name=shardNum,proto3" json:"shardNum,omitempty"`
	// *
	// The realm number (nonnegative)
	RealmNum int64 `protobuf:"varint,2,opt,name=realmNum,proto3" json:"realmNum,omitempty"`
	// *
	// Unique topic identifier within a realm (nonnegative).
	TopicNum int64 `protobuf:"varint,3,opt,name=topicNum,proto3" json:"topicNum,omitempty"`
	// contains filtered or unexported fields
}

type TransactionBody struct {

	// *
	// The ID for this transaction, which includes the payer's account (the account paying the
	// transaction fee). If two transactions have the same transactionID, they won't both have an
	// effect
	TransactionID *TransactionID `protobuf:"bytes,1,opt,name=transactionID,proto3" json:"transactionID,omitempty"`
	// *
	// The account of the node that submits the client's transaction to the network
	NodeAccountID *AccountID `protobuf:"bytes,2,opt,name=nodeAccountID,proto3" json:"nodeAccountID,omitempty"`
	// *
	// The maximum transaction fee the client is willing to pay
	TransactionFee uint64 `protobuf:"varint,3,opt,name=transactionFee,proto3" json:"transactionFee,omitempty"`
	// *
	// The transaction is invalid if consensusTimestamp > transactionID.transactionValidStart +
	// transactionValidDuration
	TransactionValidDuration *Duration `protobuf:"bytes,4,opt,name=transactionValidDuration,proto3" json:"transactionValidDuration,omitempty"`
	// *
	// Any notes or descriptions that should be put into the record (max length 100)
	Memo string `protobuf:"bytes,6,opt,name=memo,proto3" json:"memo,omitempty"`
	// *
	// The choices here are arranged by service in roughly lexicographical order. The field ordinals are non-sequential, and a result of the historical order of implementation.
	//
	// Types that are valid to be assigned to Data:
	//
	//	*TransactionBody_CryptoTransfer
	Data isTransactionBody_Data `protobuf_oneof:"data"`
	// contains filtered or unexported fields
}

type TransactionBody_CryptoTransfer struct {
	// *
	// Transfer amount between accounts
	CryptoTransfer *CryptoTransferTransactionBody `protobuf:"bytes,14,opt,name=cryptoTransfer,proto3,oneof"`
}

type TransactionFeeSchedule struct {

	// *
	// A particular transaction or query
	HederaFunctionality HederaFunctionality `protobuf:"varint,1,opt,name=hederaFunctionality,proto3,enum=proto.HederaFunctionality" json:"hederaFunctionality,omitempty"`
	// *
	// Resource price coefficients
	//
	// Deprecated: Marked as deprecated in basic_types.proto.
	FeeData *FeeData `protobuf:"bytes,2,opt,name=feeData,proto3" json:"feeData,omitempty"`
	// *
	// Resource price coefficients. Supports subtype price definition.
	Fees []*FeeData `protobuf:"bytes,3,rep,name=fees,proto3" json:"fees,omitempty"`
	// contains filtered or unexported fields
}

type TransactionID struct {

	// *
	// The transaction is invalid if consensusTimestamp < transactionID.transactionStartValid
	TransactionValidStart *Timestamp `protobuf:"bytes,1,opt,name=transactionValidStart,proto3" json:"transactionValidStart,omitempty"`
	// *
	// The Account ID that paid for this transaction
	AccountID *AccountID `protobuf:"bytes,2,opt,name=accountID,proto3" json:"accountID,omitempty"`
	// *
	// Whether the Transaction is of type Scheduled or no
	Scheduled bool `protobuf:"varint,3,opt,name=scheduled,proto3" json:"scheduled,omitempty"`
	// *
	// The identifier for an internal transaction that was spawned as part
	// of handling a user transaction. (These internal transactions share the
	// transactionValidStart and accountID of the user transaction, so a
	// nonce is necessary to give them a unique TransactionID.)
	//
	// An example is when a "parent" ContractCreate or ContractCall transaction
	// calls one or more HTS precompiled contracts; each of the "child"
	// transactions spawned for a precompile has a id with a different nonce.
	Nonce int32 `protobuf:"varint,4,opt,name=nonce,proto3" json:"nonce,omitempty"`
	// contains filtered or unexported fields
}

type TransferList struct {

	// *
	// Multiple list of AccountAmount pairs, each of which has an account and
	// an amount to transfer into it (positive) or out of it (negative)
	AccountAmounts []*AccountAmount `protobuf:"bytes,1,rep,name=accountAmounts,proto3" json:"accountAmounts,omitempty"`
	// contains filtered or unexported fields
}