class ActivityFailureInfo(betterproto.Message):
scheduled_event_id: int = betterproto.int64_field(1)
started_event_id: int = betterproto.int64_field(2)
identity: str = betterproto.string_field(3)
activity_type: v1common.ActivityType = betterproto.message_field(4)
activity_id: str = betterproto.string_field(5)
retry_state: v1enums.RetryState = betterproto.enum_field(6)
class ChildWorkflowExecutionFailureInfo(betterproto.Message):
namespace: str = betterproto.string_field(1)
workflow_execution: v1common.WorkflowExecution = betterproto.message_field(2)
workflow_type: v1common.WorkflowType = betterproto.message_field(3)
initiated_event_id: int = betterproto.int64_field(4)
started_event_id: int = betterproto.int64_field(5)
retry_state: v1enums.RetryState = betterproto.enum_field(6)
class CMsgClientWalletInfoUpdate(betterproto.Message):
has_wallet: bool = betterproto.bool_field(1)
balance: int = betterproto.int32_field(2)
currency: int = betterproto.int32_field(3)
balance_delayed: int = betterproto.int32_field(4)
balance64: int = betterproto.int64_field(5)
balance64_delayed: int = betterproto.int64_field(6)
class ActivityTaskTimedOutEventAttributes(betterproto.Message):
# For retry activity, it may have a failure before timeout. It is stored as
# `cause` in `failure`.
failure: v1failure.Failure = betterproto.message_field(1)
scheduled_event_id: int = betterproto.int64_field(2)
started_event_id: int = betterproto.int64_field(3)
retry_state: v1enums.RetryState = betterproto.enum_field(4)
class UeMetrics(betterproto.Message):
# Latency (in nanoseconds) of the most recent hand-over
ho_latency: int = betterproto.int64_field(1)
# Handover report timestamp (in nanoseconds since epoch)
ho_report_timestamp: int = betterproto.int64_field(2)
# flag to indicate the first measurement
is_first: bool = betterproto.bool_field(3)
class ChildWorkflowExecutionTerminatedEventAttributes(betterproto.Message):
namespace: str = betterproto.string_field(1)
workflow_execution: v1common.WorkflowExecution = betterproto.message_field(
2)
workflow_type: v1common.WorkflowType = betterproto.message_field(3)
initiated_event_id: int = betterproto.int64_field(4)
started_event_id: int = betterproto.int64_field(5)
class ChildWorkflowExecutionCanceledEventAttributes(betterproto.Message):
details: v1common.Payloads = betterproto.message_field(1)
namespace: str = betterproto.string_field(2)
workflow_execution: v1common.WorkflowExecution = betterproto.message_field(
3)
workflow_type: v1common.WorkflowType = betterproto.message_field(4)
initiated_event_id: int = betterproto.int64_field(5)
started_event_id: int = betterproto.int64_field(6)
class CoreMessage(betterproto.Message):
id: str = betterproto.string_field(1)
type: str = betterproto.string_field(2)
body: bytes = betterproto.bytes_field(3)
to: List[str] = betterproto.string_field(4)
from_: str = betterproto.string_field(5)
created: int = betterproto.int64_field(6)
expires: int = betterproto.int64_field(7)
class Cell(betterproto.Message):
cgi: str = betterproto.string_field(1)
num_ues: int = betterproto.int64_field(2)
cumulative_handovers_in: int = betterproto.int64_field(4)
cumulative_handovers_out: int = betterproto.int64_field(5)
def __post_init__(self) -> None:
super().__post_init__()
class StartChildWorkflowExecutionFailedEventAttributes(betterproto.Message):
namespace: str = betterproto.string_field(1)
workflow_id: str = betterproto.string_field(2)
workflow_type: v1common.WorkflowType = betterproto.message_field(3)
cause: v1enums.StartChildWorkflowExecutionFailedCause = betterproto.enum_field(
4)
control: str = betterproto.string_field(5)
initiated_event_id: int = betterproto.int64_field(6)
workflow_task_completed_event_id: int = betterproto.int64_field(7)
class ExchangeRate(betterproto.Message):
"""* An exchange rate between Bitcoin and some fiat currency."""
# This much of satoshis (1E-8 fractions)…
coin_value: int = betterproto.int64_field(1)
# …is worth this much of fiat (1E-4 fractions).
fiat_value: int = betterproto.int64_field(2)
# ISO 4217 currency code (if available) of the fiat currency.
fiat_currency_code: str = betterproto.string_field(3)
class SignalExternalWorkflowExecutionFailedEventAttributes(
betterproto.Message):
cause: v1enums.SignalExternalWorkflowExecutionFailedCause = betterproto.enum_field(
1)
workflow_task_completed_event_id: int = betterproto.int64_field(2)
namespace: str = betterproto.string_field(3)
workflow_execution: v1common.WorkflowExecution = betterproto.message_field(
4)
initiated_event_id: int = betterproto.int64_field(5)
control: str = betterproto.string_field(6)
class Int64Range(betterproto.Message):
"""
Specifies the int64 start and end of the range using half-open interval
semantics [start, end).
"""
# start of the range (inclusive)
start: int = betterproto.int64_field(1)
# end of the range (exclusive)
end: int = betterproto.int64_field(2)
class WorkflowTaskFailedEventAttributes(betterproto.Message):
scheduled_event_id: int = betterproto.int64_field(1)
started_event_id: int = betterproto.int64_field(2)
cause: v1enums.WorkflowTaskFailedCause = betterproto.enum_field(3)
failure: v1failure.Failure = betterproto.message_field(4)
identity: str = betterproto.string_field(5)
# For reset workflow.
base_run_id: str = betterproto.string_field(6)
new_run_id: str = betterproto.string_field(7)
fork_event_version: int = betterproto.int64_field(8)
binary_checksum: str = betterproto.string_field(9)
class CUserAccountGetAvailableValveDiscountPromotionsResponseValveDiscountPromotionDetails(betterproto.Message):
promotionid: int = betterproto.uint32_field(1)
promotion_description: str = betterproto.string_field(2)
minimum_cart_amount: int = betterproto.int64_field(3)
minimum_cart_amount_for_display: int = betterproto.int64_field(4)
discount_amount: int = betterproto.int64_field(5)
currency_code: int = betterproto.int32_field(6)
available_use_count: int = betterproto.int32_field(7)
promotional_discount_type: int = betterproto.int32_field(8)
loyalty_reward_id: int = betterproto.int32_field(9)
localized_name_token: str = betterproto.string_field(10)
max_use_count: int = betterproto.int32_field(11)
class WorkflowExecutionInfo(betterproto.Message):
execution: v1common.WorkflowExecution = betterproto.message_field(1)
type: v1common.WorkflowType = betterproto.message_field(2)
start_time: datetime = betterproto.message_field(3)
close_time: datetime = betterproto.message_field(4)
status: v1enums.WorkflowExecutionStatus = betterproto.enum_field(5)
history_length: int = betterproto.int64_field(6)
parent_namespace_id: str = betterproto.string_field(7)
parent_execution: v1common.WorkflowExecution = betterproto.message_field(8)
execution_time: datetime = betterproto.message_field(9)
memo: v1common.Memo = betterproto.message_field(10)
search_attributes: v1common.SearchAttributes = betterproto.message_field(11)
auto_reset_points: "ResetPoints" = betterproto.message_field(12)
task_queue: str = betterproto.string_field(13)
state_transition_count: int = betterproto.int64_field(14)
class MarkerRecordedEventAttributes(betterproto.Message):
marker_name: str = betterproto.string_field(1)
details: Dict[str, v1common.Payloads] = betterproto.map_field(
2, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE)
workflow_task_completed_event_id: int = betterproto.int64_field(3)
header: v1common.Header = betterproto.message_field(4)
failure: v1failure.Failure = betterproto.message_field(5)
class TripUpdateStopTimeEvent(betterproto.Message):
"""
Timing information for a single predicted event (either arrival or
departure). Timing consists of delay and/or estimated time, and
uncertainty. - delay should be used when the prediction is given relative
to some existing schedule in GTFS. - time should be given whether there
is a predicted schedule or not. If both time and delay are specified,
time will take precedence (although normally, time, if given for a
scheduled trip, should be equal to scheduled time in GTFS + delay).
Uncertainty applies equally to both time and delay. The uncertainty roughly
specifies the expected error in true delay (but note, we don't yet define
its precise statistical meaning). It's possible for the uncertainty to be
0, for example for trains that are driven under computer timing control.
"""
# Delay (in seconds) can be positive (meaning that the vehicle is late) or
# negative (meaning that the vehicle is ahead of schedule). Delay of 0 means
# that the vehicle is exactly on time.
delay: int = betterproto.int32_field(1)
# Event as absolute time. In Unix time (i.e., number of seconds since January
# 1st 1970 00:00:00 UTC).
time: int = betterproto.int64_field(2)
# If uncertainty is omitted, it is interpreted as unknown. If the prediction
# is unknown or too uncertain, the delay (or time) field should be empty. In
# such case, the uncertainty field is ignored. To specify a completely
# certain prediction, set its uncertainty to 0.
uncertainty: int = betterproto.int32_field(3)
class ActivityTaskScheduledEventAttributes(betterproto.Message):
activity_id: str = betterproto.string_field(1)
activity_type: v1common.ActivityType = betterproto.message_field(2)
namespace: str = betterproto.string_field(3)
task_queue: v1taskqueue.TaskQueue = betterproto.message_field(4)
header: v1common.Header = betterproto.message_field(5)
input: v1common.Payloads = betterproto.message_field(6)
# (-- api-linter: core::0140::prepositions=disabled aip.dev/not-
# precedent: "to" is used to indicate interval. --) Indicates how long the
# caller is willing to wait for an activity completion. Limits for how long
# retries are happening. Either this or start_to_close_timeout_seconds must
# be specified.
schedule_to_close_timeout: timedelta = betterproto.message_field(7)
# (-- api-linter: core::0140::prepositions=disabled aip.dev/not-
# precedent: "to" is used to indicate interval. --) Limits time an activity
# task can stay in a task queue before a worker picks it up. This timeout is
# always non retryable as all a retry would achieve is to put it back into
# the same queue. Defaults to schedule_to_close_timeout_seconds or workflow
# execution timeout if not specified.
schedule_to_start_timeout: timedelta = betterproto.message_field(8)
# (-- api-linter: core::0140::prepositions=disabled aip.dev/not-
# precedent: "to" is used to indicate interval. --) Maximum time an activity
# is allowed to execute after a pick up by a worker. This timeout is always
# retryable. Either this or schedule_to_close_timeout_seconds must be
# specified.
start_to_close_timeout: timedelta = betterproto.message_field(9)
# Maximum time between successful worker heartbeats.
heartbeat_timeout: timedelta = betterproto.message_field(10)
workflow_task_completed_event_id: int = betterproto.int64_field(11)
# Activities are provided by a default retry policy controlled through the
# service dynamic configuration. Retries are happening up to
# schedule_to_close_timeout. To disable retries set
# retry_policy.maximum_attempts to 1.
retry_policy: v1common.RetryPolicy = betterproto.message_field(12)
class SetRequest(betterproto.Message):
headers: "__primitive__.RequestHeaders" = betterproto.message_field(1)
value: int = betterproto.int64_field(2)
preconditions: List["Precondition"] = betterproto.message_field(3)
def __post_init__(self) -> None:
super().__post_init__()
class Wallet(betterproto.Message):
"""* A bitcoin wallet"""
network_identifier: str = betterproto.string_field(1)
# The SHA256 hash of the head of the best chain seen by this wallet.
last_seen_block_hash: bytes = betterproto.bytes_field(2)
# The height in the chain of the last seen block.
last_seen_block_height: int = betterproto.uint32_field(12)
last_seen_block_time_secs: int = betterproto.int64_field(14)
key: List["Key"] = betterproto.message_field(3)
transaction: List["Transaction"] = betterproto.message_field(4)
watched_script: List["Script"] = betterproto.message_field(15)
encryption_type: "WalletEncryptionType" = betterproto.enum_field(5)
encryption_parameters: "ScryptParameters" = betterproto.message_field(6)
# The version number of the wallet - used to detect wallets that were
# produced in the future (i.e. the wallet may contain some future format this
# protobuf or parser code does not know about). A version that's higher than
# the default is considered from the future.
version: int = betterproto.int32_field(7)
extension: List["Extension"] = betterproto.message_field(10)
# A UTF8 encoded text description of the wallet that is intended for end user
# provided text.
description: str = betterproto.string_field(11)
# UNIX time in seconds since the epoch. If set, then any keys created before
# this date are assumed to be no longer wanted. Money sent to them will be
# re-spent automatically to the first key that was created after this time.
# It can be used to recover a compromised wallet, or just as part of
# preventative defence-in-depth measures.
key_rotation_time: int = betterproto.uint64_field(13)
tags: List["Tag"] = betterproto.message_field(16)
# transaction signers added to the wallet
transaction_signers: List["TransactionSigner"] = betterproto.message_field(
17)
class GetRobotTokenRequest(betterproto.Message):
# The returned token will allow the caller to access resources as this robot
# user
robot: str = betterproto.string_field(1)
# ttl indicates the requested (approximate) remaining lifetime of this token,
# in seconds
ttl: int = betterproto.int64_field(2)
class SetResponse(betterproto.Message):
"""
SetResponse is the response to a SetRequest, sent from the target to the
client. It reports the result of the modifications to the data tree that
were specified by the client. Errors for this RPC should be reported using
the https://github.com/googleapis/googleapis/blob/master/google/rpc/status.
proto message in the RPC return. The gnmi.Error message can be used to add
additional details where required. Reference: gNMI Specification Section
3.4.2
"""
prefix: "Path" = betterproto.message_field(1)
# A set of responses specifying the result of the operations specified in the
# SetRequest.
response: List["UpdateResult"] = betterproto.message_field(2)
message: "Error" = betterproto.message_field(3)
timestamp: int = betterproto.int64_field(4)
# Extension messages associated with the SetResponse. See the gNMI extension
# specification for further definition.
extension: List["_gnmi_ext__.Extension"] = betterproto.message_field(5)
def __post_init__(self) -> None:
super().__post_init__()
if self.message:
warnings.warn("SetResponse.message is deprecated",
DeprecationWarning)
class CMsgClientStat2StatDetail(betterproto.Message):
client_stat: int = betterproto.uint32_field(1)
ll_value: int = betterproto.int64_field(2)
time_of_day: int = betterproto.uint32_field(3)
cell_id: int = betterproto.uint32_field(4)
depot_id: int = betterproto.uint32_field(5)
app_id: int = betterproto.uint32_field(6)
class StartChildWorkflowExecutionInitiatedEventAttributes(betterproto.Message):
namespace: str = betterproto.string_field(1)
workflow_id: str = betterproto.string_field(2)
workflow_type: v1common.WorkflowType = betterproto.message_field(3)
task_queue: v1taskqueue.TaskQueue = betterproto.message_field(4)
input: v1common.Payloads = betterproto.message_field(5)
# Total workflow execution timeout including retries and continue as new.
workflow_execution_timeout: timedelta = betterproto.message_field(6)
# Timeout of a single workflow run.
workflow_run_timeout: timedelta = betterproto.message_field(7)
# Timeout of a single workflow task.
workflow_task_timeout: timedelta = betterproto.message_field(8)
# Default: PARENT_CLOSE_POLICY_TERMINATE.
parent_close_policy: v1enums.ParentClosePolicy = betterproto.enum_field(9)
control: str = betterproto.string_field(10)
workflow_task_completed_event_id: int = betterproto.int64_field(11)
# Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE.
workflow_id_reuse_policy: v1enums.WorkflowIdReusePolicy = betterproto.enum_field(
12)
retry_policy: v1common.RetryPolicy = betterproto.message_field(13)
cron_schedule: str = betterproto.string_field(14)
header: v1common.Header = betterproto.message_field(15)
memo: v1common.Memo = betterproto.message_field(16)
search_attributes: v1common.SearchAttributes = betterproto.message_field(
17)
class TypedValue(betterproto.Message):
"""
TypedValue is used to encode a value being sent between the client and
target (originated by either entity).
"""
string_val: str = betterproto.string_field(1, group="value")
int_val: int = betterproto.int64_field(2, group="value")
uint_val: int = betterproto.uint64_field(3, group="value")
bool_val: bool = betterproto.bool_field(4, group="value")
bytes_val: bytes = betterproto.bytes_field(5, group="value")
float_val: float = betterproto.float_field(6, group="value")
decimal_val: "Decimal64" = betterproto.message_field(7, group="value")
leaflist_val: "ScalarArray" = betterproto.message_field(8, group="value")
any_val: "betterproto_lib_google_protobuf.Any" = betterproto.message_field(
9, group="value")
json_val: bytes = betterproto.bytes_field(10, group="value")
json_ietf_val: bytes = betterproto.bytes_field(11, group="value")
ascii_val: str = betterproto.string_field(12, group="value")
# Protobuf binary encoded bytes. The message type is not included. See the
# specification at
# github.com/openconfig/reference/blob/master/rpc/gnmi/protobuf-vals.md for a
# complete specification.
proto_bytes: bytes = betterproto.bytes_field(13, group="value")
def __post_init__(self) -> None:
super().__post_init__()
class Key(betterproto.Message):
"""
* A key used to control Bitcoin spending. Either the private key, the
public key or both may be present. It is recommended that if the private
key is provided that the public key is provided too because deriving it is
slow. If only the public key is provided, the key can only be used to watch
the blockchain and verify transactions, and not for spending.
"""
type: "KeyType" = betterproto.enum_field(1)
# Either the private EC key bytes (without any ASN.1 wrapping), or the
# deterministic root seed. If the secret is encrypted, or this is a "watching
# entry" then this is missing.
secret_bytes: bytes = betterproto.bytes_field(2)
# If the secret data is encrypted, then secret_bytes is missing and this
# field is set.
encrypted_data: "EncryptedData" = betterproto.message_field(6)
# The public EC key derived from the private key. We allow both to be stored
# to avoid mobile clients having to do lots of slow EC math on startup. For
# DETERMINISTIC_MNEMONIC entries this is missing.
public_key: bytes = betterproto.bytes_field(3)
# User-provided label associated with the key.
label: str = betterproto.string_field(4)
# Timestamp stored as millis since epoch. Useful for skipping block bodies
# before this point. Only reason it's optional is that some very old wallets
# don't have this data.
creation_timestamp: int = betterproto.int64_field(5)
deterministic_key: "DeterministicKey" = betterproto.message_field(7)
# The seed for a deterministic key hierarchy. Derived from the mnemonic, but
# cached here for quick startup. Only applicable to a DETERMINISTIC_MNEMONIC
# key entry.
deterministic_seed: bytes = betterproto.bytes_field(8)
# Encrypted version of the seed
encrypted_deterministic_seed: "EncryptedData" = betterproto.message_field(
9)
class PendingChildExecutionInfo(betterproto.Message):
workflow_id: str = betterproto.string_field(1)
run_id: str = betterproto.string_field(2)
workflow_type_name: str = betterproto.string_field(3)
initiated_id: int = betterproto.int64_field(4)
# Default: PARENT_CLOSE_POLICY_TERMINATE.
parent_close_policy: v1enums.ParentClosePolicy = betterproto.enum_field(5)
class Transaction(betterproto.Message):
# See Wallet.java for detailed description of pool semantics
version: int = betterproto.int32_field(1)
hash: bytes = betterproto.bytes_field(2)
# If pool is not present, that means either: - This Transaction is either
# not in a wallet at all (the proto is re-used elsewhere) - Or it is stored
# but for other purposes, for example, because it is the overriding
# transaction of a double spend. - Or the Pool enum got a new value which
# your software is too old to parse.
pool: "TransactionPool" = betterproto.enum_field(3)
lock_time: int = betterproto.uint32_field(4)
updated_at: int = betterproto.int64_field(5)
transaction_input: List["TransactionInput"] = betterproto.message_field(6)
transaction_output: List["TransactionOutput"] = betterproto.message_field(
7)
# A list of blocks in which the transaction has been observed (on any chain).
# Also, a number used to disambiguate ordering within a block.
block_hash: List[bytes] = betterproto.bytes_field(8)
block_relativity_offsets: List[int] = betterproto.int32_field(11)
# Data describing where the transaction is in the chain.
confidence: "TransactionConfidence" = betterproto.message_field(9)
purpose: "TransactionPurpose" = betterproto.enum_field(10)
# Exchange rate that was valid when the transaction was sent.
exchange_rate: "ExchangeRate" = betterproto.message_field(12)
# Memo of the transaction. It can be used to record the memo of the payment
# request that initiated the transaction.
memo: str = betterproto.string_field(13)
class TransactionConfidence(betterproto.Message):
"""
* A description of the confidence we have that a transaction cannot be
reversed in the future. Parsing should be lenient, since this could change
for different applications yet we should maintain backward compatibility.
"""
# This is optional in case we add confidence types to prevent parse errors -
# backwards compatible.
type: "TransactionConfidenceType" = betterproto.enum_field(1)
# If type == BUILDING then this is the chain height at which the transaction
# was included.
appeared_at_height: int = betterproto.int32_field(2)
# If set, hash of the transaction that double spent this one into oblivion. A
# transaction can be double spent by multiple transactions in the case of
# several inputs being re-spent by several transactions but we don't bother
# to track them all, just the first. This only makes sense if type = DEAD.
overriding_transaction: bytes = betterproto.bytes_field(3)
# If type == BUILDING then this is the depth of the transaction in the
# blockchain. Zero confirmations: depth = 0, one confirmation: depth = 1 etc.
depth: int = betterproto.int32_field(4)
broadcast_by: List["PeerAddress"] = betterproto.message_field(6)
# Millis since epoch the transaction was last announced to us.
last_broadcasted_at: int = betterproto.int64_field(8)
source: "TransactionConfidenceSource" = betterproto.enum_field(7)