geode-client 0.1.1-alpha.20

// This file is @generated by prost-build.
/// ============================================================================
/// Transport Wrappers (QUIC framing)
/// ============================================================================
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClientPacket {
    #[prost(oneof = "client_packet::Msg", tags = "1")]
    pub msg: ::core::option::Option<client_packet::Msg>,
}
/// Nested message and enum types in `ClientPacket`.
pub mod client_packet {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Msg {
        #[prost(message, tag = "1")]
        Quic(super::QuicClientMessage),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServerPacket {
    #[prost(oneof = "server_packet::Msg", tags = "1")]
    pub msg: ::core::option::Option<server_packet::Msg>,
}
/// Nested message and enum types in `ServerPacket`.
pub mod server_packet {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Msg {
        #[prost(message, tag = "1")]
        Quic(super::QuicServerMessage),
    }
}
/// ============================================================================
/// QUIC Messages
/// ============================================================================
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QuicClientMessage {
    #[prost(
        oneof = "quic_client_message::Msg",
        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14"
    )]
    pub msg: ::core::option::Option<quic_client_message::Msg>,
}
/// Nested message and enum types in `QuicClientMessage`.
pub mod quic_client_message {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Msg {
        #[prost(message, tag = "1")]
        Hello(super::HelloRequest),
        #[prost(message, tag = "2")]
        Execute(super::ExecuteRequest),
        #[prost(message, tag = "3")]
        Pull(super::PullRequest),
        #[prost(message, tag = "4")]
        Ping(super::PingRequest),
        #[prost(message, tag = "5")]
        CdcDiag(super::CdcDiagnosticsRequest),
        #[prost(message, tag = "6")]
        CdcCtrl(super::CdcControlRequest),
        #[prost(message, tag = "7")]
        Begin(super::BeginRequest),
        #[prost(message, tag = "8")]
        Commit(super::CommitRequest),
        #[prost(message, tag = "9")]
        Rollback(super::RollbackRequest),
        #[prost(message, tag = "10")]
        Savepoint(super::SavepointRequest),
        #[prost(message, tag = "11")]
        RollbackTo(super::RollbackToRequest),
        #[prost(message, tag = "12")]
        Backup(super::BackupRequest),
        #[prost(message, tag = "13")]
        Restore(super::RestoreRequest),
        #[prost(message, tag = "14")]
        UploadBackup(super::UploadBackupRequest),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QuicServerMessage {
    #[prost(
        oneof = "quic_server_message::Msg",
        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14"
    )]
    pub msg: ::core::option::Option<quic_server_message::Msg>,
}
/// Nested message and enum types in `QuicServerMessage`.
pub mod quic_server_message {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Msg {
        #[prost(message, tag = "1")]
        Hello(super::HelloResponse),
        #[prost(message, tag = "2")]
        Execute(super::ExecutionResponse),
        #[prost(message, tag = "3")]
        Pull(super::PullResponse),
        #[prost(message, tag = "4")]
        Ping(super::PingResponse),
        #[prost(message, tag = "5")]
        CdcDiag(super::CdcDiagnosticsResponse),
        #[prost(message, tag = "6")]
        CdcCtrl(super::CdcControlResponse),
        #[prost(message, tag = "7")]
        Begin(super::BeginResponse),
        #[prost(message, tag = "8")]
        Commit(super::CommitResponse),
        #[prost(message, tag = "9")]
        Rollback(super::RollbackResponse),
        #[prost(message, tag = "10")]
        Savepoint(super::SavepointResponse),
        #[prost(message, tag = "11")]
        RollbackTo(super::RollbackToResponse),
        #[prost(message, tag = "12")]
        Backup(super::BackupResponse),
        #[prost(message, tag = "13")]
        Restore(super::RestoreResponse),
        #[prost(message, tag = "14")]
        UploadBackup(super::UploadBackupResponse),
    }
}
/// ============================================================================
/// Authentication (HELLO)
/// ============================================================================
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HelloRequest {
    #[prost(string, tag = "1")]
    pub username: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub password: ::prost::alloc::string::String,
    #[prost(string, optional, tag = "3")]
    pub tenant_id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, tag = "4")]
    pub client_name: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub client_version: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub wanted_conformance: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HelloResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
    #[prost(string, tag = "2")]
    pub session_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub error_message: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "4")]
    pub capabilities: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// ============================================================================
/// Query Execution (RUN_GQL + PULL)
/// ============================================================================
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecuteRequest {
    #[prost(string, tag = "1")]
    pub session_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub query: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "3")]
    pub params: ::prost::alloc::vec::Vec<Param>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Param {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub value: ::core::option::Option<Value>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PullRequest {
    #[prost(uint64, tag = "1")]
    pub request_id: u64,
    #[prost(uint32, tag = "2")]
    pub page_size: u32,
    /// Required for gRPC; ignored for QUIC
    #[prost(string, tag = "3")]
    pub session_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PullResponse {
    #[prost(message, optional, tag = "1")]
    pub response: ::core::option::Option<ExecutionResponse>,
}
/// ============================================================================
/// Execution Responses
/// ============================================================================
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Status {
    /// e.g., "00000"
    #[prost(string, tag = "1")]
    pub status_class: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub status_subclass: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "3")]
    pub additional_statuses: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "4")]
    pub flagger_findings: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutionResponse {
    #[prost(message, optional, tag = "1")]
    pub status: ::core::option::Option<Status>,
    #[prost(oneof = "execution_response::Payload", tags = "2, 3, 4, 5, 6, 7, 8")]
    pub payload: ::core::option::Option<execution_response::Payload>,
}
/// Nested message and enum types in `ExecutionResponse`.
pub mod execution_response {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Payload {
        #[prost(message, tag = "2")]
        Schema(super::SchemaDefinition),
        #[prost(message, tag = "3")]
        Page(super::DataPage),
        #[prost(message, tag = "4")]
        Error(super::Error),
        #[prost(message, tag = "5")]
        Metrics(super::ExecutionMetrics),
        #[prost(message, tag = "6")]
        Explain(super::ExplainPayload),
        #[prost(message, tag = "7")]
        Profile(super::ProfilePayload),
        #[prost(message, tag = "8")]
        Heartbeat(super::Heartbeat),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SchemaDefinition {
    #[prost(message, repeated, tag = "1")]
    pub columns: ::prost::alloc::vec::Vec<ColumnDefinition>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ColumnDefinition {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub r#type: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataPage {
    #[prost(message, repeated, tag = "1")]
    pub rows: ::prost::alloc::vec::Vec<Row>,
    #[prost(bool, tag = "2")]
    pub r#final: bool,
    #[prost(bool, tag = "3")]
    pub ordered: bool,
    #[prost(string, repeated, tag = "4")]
    pub order_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Row {
    #[prost(message, repeated, tag = "1")]
    pub values: ::prost::alloc::vec::Vec<Value>,
}
/// ----------------------------------------------------------------------------
/// Value Encoding
/// ----------------------------------------------------------------------------
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Value {
    #[prost(
        oneof = "value::Kind",
        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13"
    )]
    pub kind: ::core::option::Option<value::Kind>,
}
/// Nested message and enum types in `Value`.
pub mod value {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        NullVal(super::NullValue),
        #[prost(message, tag = "2")]
        IntVal(super::IntValue),
        #[prost(message, tag = "3")]
        DoubleVal(super::DoubleValue),
        #[prost(bool, tag = "4")]
        BoolVal(bool),
        #[prost(message, tag = "5")]
        StringVal(super::StringValue),
        #[prost(message, tag = "6")]
        DecimalVal(super::DecimalValue),
        #[prost(message, tag = "7")]
        BytesVal(super::BytesValue),
        #[prost(message, tag = "8")]
        ListVal(super::ListValue),
        #[prost(message, tag = "9")]
        MapVal(super::MapValue),
        #[prost(message, tag = "10")]
        NodeVal(super::NodeValue),
        #[prost(message, tag = "11")]
        EdgeVal(super::EdgeValue),
        #[prost(message, tag = "12")]
        PathVal(super::PathValue),
        #[prost(message, tag = "13")]
        ExtVal(super::ExtendedValue),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct NullValue {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct IntValue {
    #[prost(int64, tag = "1")]
    pub value: i64,
    #[prost(enumeration = "IntKind", tag = "2")]
    pub kind: i32,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct DoubleValue {
    #[prost(double, tag = "1")]
    pub value: f64,
    #[prost(enumeration = "FloatKind", tag = "2")]
    pub kind: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StringValue {
    #[prost(string, tag = "1")]
    pub value: ::prost::alloc::string::String,
    #[prost(enumeration = "StringKind", tag = "2")]
    pub kind: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DecimalValue {
    /// i128 as decimal string
    #[prost(string, tag = "1")]
    pub coeff: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub scale: u32,
    #[prost(uint32, tag = "3")]
    pub orig_scale: u32,
    #[prost(string, tag = "4")]
    pub orig_repr: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BytesValue {
    #[prost(bytes = "vec", tag = "1")]
    pub value: ::prost::alloc::vec::Vec<u8>,
    #[prost(enumeration = "BytesKind", tag = "2")]
    pub kind: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListValue {
    #[prost(message, repeated, tag = "1")]
    pub values: ::prost::alloc::vec::Vec<Value>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MapEntry {
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub value: ::core::option::Option<Value>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MapValue {
    #[prost(message, repeated, tag = "1")]
    pub entries: ::prost::alloc::vec::Vec<MapEntry>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NodeValue {
    #[prost(uint64, tag = "1")]
    pub id: u64,
    #[prost(string, repeated, tag = "2")]
    pub labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "3")]
    pub properties: ::prost::alloc::vec::Vec<MapEntry>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EdgeValue {
    #[prost(uint64, tag = "1")]
    pub id: u64,
    #[prost(uint64, tag = "2")]
    pub from_id: u64,
    #[prost(uint64, tag = "3")]
    pub to_id: u64,
    #[prost(string, tag = "4")]
    pub label: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "5")]
    pub properties: ::prost::alloc::vec::Vec<MapEntry>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PathValue {
    #[prost(message, repeated, tag = "1")]
    pub nodes: ::prost::alloc::vec::Vec<NodeValue>,
    #[prost(message, repeated, tag = "2")]
    pub edges: ::prost::alloc::vec::Vec<EdgeValue>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExtendedValue {
    #[prost(string, tag = "1")]
    pub type_name: ::prost::alloc::string::String,
    #[prost(oneof = "extended_value::Data", tags = "2, 3, 4, 5, 6")]
    pub data: ::core::option::Option<extended_value::Data>,
}
/// Nested message and enum types in `ExtendedValue`.
pub mod extended_value {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Data {
        #[prost(string, tag = "2")]
        Text(::prost::alloc::string::String),
        #[prost(bytes, tag = "3")]
        Bytes(::prost::alloc::vec::Vec<u8>),
        #[prost(int64, tag = "4")]
        IntVal(i64),
        #[prost(double, tag = "5")]
        DoubleVal(f64),
        #[prost(bool, tag = "6")]
        BoolVal(bool),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Error {
    #[prost(string, tag = "1")]
    pub code: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
    /// "ERROR"
    #[prost(string, tag = "3")]
    pub r#type: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub anchor: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ExecutionMetrics {
    #[prost(int64, tag = "1")]
    pub parse_duration_ns: i64,
    #[prost(int64, tag = "2")]
    pub plan_duration_ns: i64,
    #[prost(int64, tag = "3")]
    pub execute_duration_ns: i64,
    #[prost(int64, tag = "4")]
    pub total_duration_ns: i64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExplainOp {
    #[prost(uint32, tag = "1")]
    pub idx: u32,
    #[prost(string, tag = "2")]
    pub kind: ::prost::alloc::string::String,
    #[prost(int64, tag = "3")]
    pub est_rows: i64,
    #[prost(int64, tag = "4")]
    pub cost: i64,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ExplainTotals {
    #[prost(int64, tag = "1")]
    pub est_rows: i64,
    #[prost(int64, tag = "2")]
    pub cost: i64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExplainProperties {
    #[prost(bool, tag = "1")]
    pub ordered: bool,
    #[prost(uint64, tag = "2")]
    pub limit: u64,
    #[prost(uint64, tag = "3")]
    pub offset: u64,
    #[prost(bool, tag = "4")]
    pub distinct: bool,
    #[prost(string, tag = "5")]
    pub union_mode: ::prost::alloc::string::String,
    #[prost(uint32, tag = "6")]
    pub union_part_count: u32,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ExplainCalibrationEntry {
    #[prost(uint32, tag = "1")]
    pub idx: u32,
    #[prost(double, tag = "2")]
    pub est_rows: f64,
    #[prost(double, tag = "3")]
    pub actual_rows: f64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExplainCalibration {
    #[prost(double, tag = "1")]
    pub mape: f64,
    #[prost(message, repeated, tag = "2")]
    pub entries: ::prost::alloc::vec::Vec<ExplainCalibrationEntry>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExplainPayload {
    #[prost(string, tag = "1")]
    pub schema: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub ops: ::prost::alloc::vec::Vec<ExplainOp>,
    #[prost(message, optional, tag = "3")]
    pub totals: ::core::option::Option<ExplainTotals>,
    #[prost(message, optional, tag = "4")]
    pub properties: ::core::option::Option<ExplainProperties>,
    #[prost(message, optional, tag = "5")]
    pub calibration: ::core::option::Option<ExplainCalibration>,
    #[prost(uint32, tag = "6")]
    pub profile_version: u32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProfileOp {
    #[prost(string, tag = "1")]
    pub op: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub phase: ::prost::alloc::string::String,
    #[prost(uint32, tag = "3")]
    pub id: u32,
    #[prost(uint32, tag = "4")]
    pub op_index: u32,
    #[prost(uint64, tag = "5")]
    pub input_rows: u64,
    #[prost(uint64, tag = "6")]
    pub rows: u64,
    #[prost(uint64, tag = "7")]
    pub time_ns: u64,
    #[prost(uint64, tag = "8")]
    pub cpu_time_ns: u64,
    #[prost(uint64, tag = "9")]
    pub bytes_out: u64,
    #[prost(uint64, tag = "10")]
    pub bytes_alloc: u64,
    #[prost(uint64, tag = "11")]
    pub estimate_bytes: u64,
    #[prost(uint64, tag = "12")]
    pub estimate_vs_actual: u64,
    #[prost(uint64, tag = "13")]
    pub percent_peak: u64,
    #[prost(uint64, tag = "14")]
    pub percent_net: u64,
    #[prost(uint64, tag = "15")]
    pub cumulative_time_ns: u64,
    #[prost(uint64, tag = "16")]
    pub freed_bytes: u64,
    #[prost(uint64, tag = "17")]
    pub net_after_op: u64,
    #[prost(uint64, tag = "18")]
    pub error_bytes: u64,
    #[prost(uint64, tag = "19")]
    pub error_abs_pct: u64,
    #[prost(string, tag = "20")]
    pub index_name: ::prost::alloc::string::String,
    #[prost(double, tag = "21")]
    pub selectivity_est: f64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProfilePeakContributor {
    #[prost(string, tag = "1")]
    pub op: ::prost::alloc::string::String,
    #[prost(uint64, tag = "2")]
    pub bytes_alloc: u64,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ProfileTotals {
    #[prost(uint64, tag = "1")]
    pub time_ns: u64,
    #[prost(uint64, tag = "2")]
    pub peak_bytes: u64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProfileSpills {
    #[prost(uint64, tag = "1")]
    pub sort_spills: u64,
    #[prost(uint64, tag = "2")]
    pub distinct_spills: u64,
    #[prost(uint64, tag = "3")]
    pub union_spills: u64,
    #[prost(string, tag = "4")]
    pub spill_reason: ::prost::alloc::string::String,
    #[prost(uint64, tag = "5")]
    pub peak_bytes_at_spill: u64,
    #[prost(uint32, tag = "6")]
    pub first_spill_op_index: u32,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ProfileMemory {
    #[prost(uint64, tag = "1")]
    pub net_bytes: u64,
    #[prost(uint64, tag = "2")]
    pub peak_bytes: u64,
    #[prost(uint64, tag = "3")]
    pub total_alloc_bytes: u64,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ProfilePlannerEstimates {
    #[prost(uint64, tag = "1")]
    pub sum_estimate_bytes: u64,
    #[prost(uint64, tag = "2")]
    pub sum_actual_bytes: u64,
    #[prost(uint32, tag = "3")]
    pub count_estimated_ops: u32,
    #[prost(double, tag = "4")]
    pub min_error_abs_pct: f64,
    #[prost(double, tag = "5")]
    pub max_error_abs_pct: f64,
    #[prost(double, tag = "6")]
    pub mean_error_abs_pct: f64,
    #[prost(double, tag = "7")]
    pub median_error_abs_pct: f64,
    #[prost(double, tag = "8")]
    pub stddev_error_abs_pct: f64,
    #[prost(double, tag = "9")]
    pub adjusted_estimate_factor: f64,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ProfileMemCurvePoint {
    #[prost(uint32, tag = "1")]
    pub op_index: u32,
    #[prost(uint64, tag = "2")]
    pub net_after_op: u64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProfileSetOp {
    #[prost(string, tag = "1")]
    pub r#type: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub mode: ::prost::alloc::string::String,
    #[prost(uint64, tag = "3")]
    pub input_rows: u64,
    #[prost(uint64, tag = "4")]
    pub output_rows: u64,
    #[prost(uint64, tag = "5")]
    pub hash_dedup_size: u64,
    #[prost(uint64, tag = "6")]
    pub distinct_fill_pct: u64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProfilePayload {
    #[prost(uint32, tag = "1")]
    pub profile_version: u32,
    #[prost(message, repeated, tag = "2")]
    pub ops: ::prost::alloc::vec::Vec<ProfileOp>,
    #[prost(message, repeated, tag = "3")]
    pub peak_contributors: ::prost::alloc::vec::Vec<ProfilePeakContributor>,
    #[prost(message, optional, tag = "4")]
    pub totals: ::core::option::Option<ProfileTotals>,
    #[prost(uint64, tag = "5")]
    pub total_time_ns: u64,
    #[prost(message, optional, tag = "6")]
    pub spills: ::core::option::Option<ProfileSpills>,
    #[prost(message, optional, tag = "7")]
    pub memory: ::core::option::Option<ProfileMemory>,
    #[prost(message, optional, tag = "8")]
    pub planner_estimates: ::core::option::Option<ProfilePlannerEstimates>,
    #[prost(message, repeated, tag = "9")]
    pub mem_curve: ::prost::alloc::vec::Vec<ProfileMemCurvePoint>,
    #[prost(message, optional, tag = "10")]
    pub setop: ::core::option::Option<ProfileSetOp>,
    #[prost(uint64, tag = "11")]
    pub hashagg_spills: u64,
    #[prost(string, tag = "12")]
    pub hashagg_spill_reason: ::prost::alloc::string::String,
    #[prost(uint64, tag = "13")]
    pub committed_txns: u64,
    #[prost(uint64, tag = "14")]
    pub graph_store_nodes: u64,
    #[prost(uint64, tag = "15")]
    pub graph_store_edges: u64,
    #[prost(bool, tag = "16")]
    pub graph_store_dirty: bool,
    #[prost(string, repeated, tag = "17")]
    pub flagger_findings: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(bool, tag = "18")]
    pub compact: bool,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct Heartbeat {}
/// ============================================================================
/// Utilities (PING)
/// ============================================================================
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct PingRequest {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct PingResponse {
    #[prost(bool, tag = "1")]
    pub ok: bool,
}
/// ============================================================================
/// Transactions
/// ============================================================================
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BeginRequest {
    #[prost(bool, tag = "1")]
    pub read_only: bool,
    /// Required for gRPC; ignored for QUIC
    #[prost(string, tag = "2")]
    pub session_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BeginResponse {
    #[prost(string, tag = "1")]
    pub session_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub tx_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommitRequest {
    /// Required for gRPC; ignored for QUIC
    #[prost(string, tag = "1")]
    pub session_id: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CommitResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RollbackRequest {
    /// Required for gRPC; ignored for QUIC
    #[prost(string, tag = "1")]
    pub session_id: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct RollbackResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SavepointRequest {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required for gRPC; ignored for QUIC
    #[prost(string, tag = "2")]
    pub session_id: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SavepointResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RollbackToRequest {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required for gRPC; ignored for QUIC
    #[prost(string, tag = "2")]
    pub session_id: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct RollbackToResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
}
/// ============================================================================
/// CDC
/// ============================================================================
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CdcDiagnosticsRequest {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CdcDiagnosticsConfig {
    #[prost(bool, tag = "1")]
    pub enabled: bool,
    #[prost(uint64, tag = "2")]
    pub malformed_snapshot_interval: u64,
    #[prost(uint32, tag = "3")]
    pub malformed_hash_retain: u32,
    #[prost(double, tag = "4")]
    pub malformed_warn_pct: f64,
    #[prost(double, tag = "5")]
    pub malformed_abort_pct: f64,
    #[prost(uint32, tag = "6")]
    pub flush_interval_ms: u32,
    #[prost(uint32, tag = "7")]
    pub batch_size: u32,
    #[prost(uint64, tag = "8")]
    pub pending_backpressure_watermark: u64,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CdcDiagnosticsEngine {
    #[prost(bool, tag = "1")]
    pub is_running: bool,
    #[prost(int64, tag = "2")]
    pub last_flush_ms: i64,
    #[prost(uint64, tag = "3")]
    pub peak_buffer: u64,
    #[prost(uint64, tag = "4")]
    pub current_buffer: u64,
    #[prost(uint32, tag = "5")]
    pub dynamic_batch_size: u32,
    #[prost(uint32, tag = "6")]
    pub batch_adjustments: u32,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CdcMalformedSnapshot {
    #[prost(uint64, tag = "1")]
    pub count: u64,
    #[prost(int64, tag = "2")]
    pub ts_ms: i64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CdcMalformedHash {
    #[prost(uint64, tag = "1")]
    pub count: u64,
    #[prost(uint64, tag = "2")]
    pub hash: u64,
    #[prost(int64, tag = "3")]
    pub ts_ms: i64,
    #[prost(string, tag = "4")]
    pub prefix_hex: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CdcDiagnosticsResponse {
    #[prost(uint64, tag = "1")]
    pub malformed_change_records: u64,
    #[prost(uint64, tag = "2")]
    pub total_change_attempts: u64,
    #[prost(double, tag = "3")]
    pub malformed_ratio: f64,
    #[prost(bool, tag = "4")]
    pub guardrail_warn_triggered: bool,
    #[prost(bool, tag = "5")]
    pub guardrail_abort_triggered: bool,
    #[prost(int64, tag = "6")]
    pub first_warn_ts_ms: i64,
    #[prost(int64, tag = "7")]
    pub first_abort_ts_ms: i64,
    #[prost(uint64, tag = "8")]
    pub guardrail_epoch: u64,
    #[prost(int64, tag = "9")]
    pub uptime_ms: i64,
    #[prost(bool, tag = "10")]
    pub backpressure: bool,
    #[prost(message, optional, tag = "11")]
    pub config: ::core::option::Option<CdcDiagnosticsConfig>,
    #[prost(message, optional, tag = "12")]
    pub engine: ::core::option::Option<CdcDiagnosticsEngine>,
    #[prost(message, repeated, tag = "13")]
    pub malformed_snapshots: ::prost::alloc::vec::Vec<CdcMalformedSnapshot>,
    #[prost(message, repeated, tag = "14")]
    pub malformed_hashes: ::prost::alloc::vec::Vec<CdcMalformedHash>,
    #[prost(string, tag = "15")]
    pub version: ::prost::alloc::string::String,
    #[prost(int64, tag = "16")]
    pub timestamp_ms: i64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CdcControlRequest {
    #[prost(string, tag = "1")]
    pub action: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CdcControlResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
    #[prost(string, tag = "2")]
    pub status: ::prost::alloc::string::String,
    #[prost(uint64, tag = "3")]
    pub guardrail_epoch: u64,
}
/// ============================================================================
/// Backup / Restore
/// ============================================================================
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BackupRequest {
    /// "full"
    #[prost(string, tag = "1")]
    pub backup_type: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub compress: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BackupResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub backup_id: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub backup_type: ::prost::alloc::string::String,
    #[prost(uint64, tag = "5")]
    pub size_bytes: u64,
    #[prost(string, tag = "6")]
    pub compression: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub checksum: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RestoreRequest {
    #[prost(string, tag = "1")]
    pub target_time: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub confirm: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RestoreResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub restore_dir: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub target_time: ::prost::alloc::string::String,
    #[prost(uint64, tag = "5")]
    pub restore_timestamp: u64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UploadBackupRequest {
    #[prost(uint64, tag = "1")]
    pub size_bytes: u64,
    #[prost(string, tag = "2")]
    pub checksum: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UploadBackupResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub upload_path: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum IntKind {
    Unspecified = 0,
    Int = 1,
    Smallint = 2,
    Bigint = 3,
}
impl IntKind {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "INT_KIND_UNSPECIFIED",
            Self::Int => "INT",
            Self::Smallint => "SMALLINT",
            Self::Bigint => "BIGINT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "INT_KIND_UNSPECIFIED" => Some(Self::Unspecified),
            "INT" => Some(Self::Int),
            "SMALLINT" => Some(Self::Smallint),
            "BIGINT" => Some(Self::Bigint),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum FloatKind {
    Unspecified = 0,
    Double = 1,
    Real = 2,
}
impl FloatKind {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "FLOAT_KIND_UNSPECIFIED",
            Self::Double => "DOUBLE",
            Self::Real => "REAL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "FLOAT_KIND_UNSPECIFIED" => Some(Self::Unspecified),
            "DOUBLE" => Some(Self::Double),
            "REAL" => Some(Self::Real),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum StringKind {
    Unspecified = 0,
    String = 1,
    Char = 2,
    Varchar = 3,
    Text = 4,
}
impl StringKind {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "STRING_KIND_UNSPECIFIED",
            Self::String => "STRING",
            Self::Char => "CHAR",
            Self::Varchar => "VARCHAR",
            Self::Text => "TEXT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "STRING_KIND_UNSPECIFIED" => Some(Self::Unspecified),
            "STRING" => Some(Self::String),
            "CHAR" => Some(Self::Char),
            "VARCHAR" => Some(Self::Varchar),
            "TEXT" => Some(Self::Text),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum BytesKind {
    Unspecified = 0,
    Bytea = 1,
    Raw = 2,
}
impl BytesKind {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "BYTES_KIND_UNSPECIFIED",
            Self::Bytea => "BYTEA",
            Self::Raw => "RAW",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "BYTES_KIND_UNSPECIFIED" => Some(Self::Unspecified),
            "BYTEA" => Some(Self::Bytea),
            "RAW" => Some(Self::Raw),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod geode_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value
    )]
    use tonic::codegen::http::Uri;
    use tonic::codegen::*;
    /// GeodeService provides gRPC access to the Geode database.
    #[derive(Debug, Clone)]
    pub struct GeodeServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl GeodeServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> GeodeServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> GeodeServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                    http::Request<tonic::body::BoxBody>,
                    Response = http::Response<
                        <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                    >,
                >,
            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
                Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            GeodeServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        pub async fn handshake(
            &mut self,
            request: impl tonic::IntoRequest<super::HelloRequest>,
        ) -> std::result::Result<tonic::Response<super::HelloResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/geode.GeodeService/Handshake");
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("geode.GeodeService", "Handshake"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn execute(
            &mut self,
            request: impl tonic::IntoRequest<super::ExecuteRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::ExecutionResponse>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/geode.GeodeService/Execute");
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("geode.GeodeService", "Execute"));
            self.inner.server_streaming(req, path, codec).await
        }
        pub async fn ping(
            &mut self,
            request: impl tonic::IntoRequest<super::PingRequest>,
        ) -> std::result::Result<tonic::Response<super::PingResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/geode.GeodeService/Ping");
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("geode.GeodeService", "Ping"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn begin(
            &mut self,
            request: impl tonic::IntoRequest<super::BeginRequest>,
        ) -> std::result::Result<tonic::Response<super::BeginResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/geode.GeodeService/Begin");
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("geode.GeodeService", "Begin"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn commit(
            &mut self,
            request: impl tonic::IntoRequest<super::CommitRequest>,
        ) -> std::result::Result<tonic::Response<super::CommitResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/geode.GeodeService/Commit");
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("geode.GeodeService", "Commit"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn rollback(
            &mut self,
            request: impl tonic::IntoRequest<super::RollbackRequest>,
        ) -> std::result::Result<tonic::Response<super::RollbackResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/geode.GeodeService/Rollback");
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("geode.GeodeService", "Rollback"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_cdc_diagnostics(
            &mut self,
            request: impl tonic::IntoRequest<super::CdcDiagnosticsRequest>,
        ) -> std::result::Result<tonic::Response<super::CdcDiagnosticsResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path =
                http::uri::PathAndQuery::from_static("/geode.GeodeService/GetCdcDiagnostics");
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("geode.GeodeService", "GetCdcDiagnostics"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn control_cdc(
            &mut self,
            request: impl tonic::IntoRequest<super::CdcControlRequest>,
        ) -> std::result::Result<tonic::Response<super::CdcControlResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/geode.GeodeService/ControlCdc");
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("geode.GeodeService", "ControlCdc"));
            self.inner.unary(req, path, codec).await
        }
    }
}