chore: add generated rpc code

1 files changed, 480 insertions, 0 deletions

diff --git a/src/rpc/envoy.data.accesslog.v2.rs b/src/rpc/envoy.data.accesslog.v2.rs
new file mode 100644
index 00000000..41e26ef3
--- /dev/null
+++ b/src/rpc/envoy.data.accesslog.v2.rs
@@ -0,0 +1,480 @@
+// @generated
+// This file is @generated by prost-build.
+// \[#protodoc-title: gRPC access logs\]
+// Envoy access logs describe incoming interaction with Envoy over a fixed
+// period of time, and typically cover a single request/response exchange,
+// (e.g. HTTP), stream (e.g. over HTTP/gRPC), or proxied connection (e.g. TCP).
+// Access logs contain fields defined in protocol-specific protobuf messages.
+//
+// Except where explicitly declared otherwise, all fields describe
+// *downstream* interaction between Envoy and a connected client.
+// Fields describing *upstream* interaction will explicitly include ``upstream``
+// in their name.
+
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct TcpAccessLogEntry {
+    /// Common properties shared by all Envoy access logs.
+    #[prost(message, optional, tag="1")]
+    pub common_properties: ::core::option::Option<AccessLogCommon>,
+    /// Properties of the TCP connection.
+    #[prost(message, optional, tag="2")]
+    pub connection_properties: ::core::option::Option<ConnectionProperties>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct HttpAccessLogEntry {
+    /// Common properties shared by all Envoy access logs.
+    #[prost(message, optional, tag="1")]
+    pub common_properties: ::core::option::Option<AccessLogCommon>,
+    #[prost(enumeration="http_access_log_entry::HttpVersion", tag="2")]
+    pub protocol_version: i32,
+    /// Description of the incoming HTTP request.
+    #[prost(message, optional, tag="3")]
+    pub request: ::core::option::Option<HttpRequestProperties>,
+    /// Description of the outgoing HTTP response.
+    #[prost(message, optional, tag="4")]
+    pub response: ::core::option::Option<HttpResponseProperties>,
+}
+/// Nested message and enum types in `HTTPAccessLogEntry`.
+pub mod http_access_log_entry {
+    /// HTTP version
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+    #[repr(i32)]
+    pub enum HttpVersion {
+        ProtocolUnspecified = 0,
+        Http10 = 1,
+        Http11 = 2,
+        Http2 = 3,
+        Http3 = 4,
+    }
+    impl HttpVersion {
+        /// 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 {
+                HttpVersion::ProtocolUnspecified => "PROTOCOL_UNSPECIFIED",
+                HttpVersion::Http10 => "HTTP10",
+                HttpVersion::Http11 => "HTTP11",
+                HttpVersion::Http2 => "HTTP2",
+                HttpVersion::Http3 => "HTTP3",
+            }
+        }
+        /// Creates an enum from field names used in the ProtoBuf definition.
+        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+            match value {
+                "PROTOCOL_UNSPECIFIED" => Some(Self::ProtocolUnspecified),
+                "HTTP10" => Some(Self::Http10),
+                "HTTP11" => Some(Self::Http11),
+                "HTTP2" => Some(Self::Http2),
+                "HTTP3" => Some(Self::Http3),
+                _ => None,
+            }
+        }
+    }
+}
+/// Defines fields for a connection
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct ConnectionProperties {
+    /// Number of bytes received from downstream.
+    #[prost(uint64, tag="1")]
+    pub received_bytes: u64,
+    /// Number of bytes sent to downstream.
+    #[prost(uint64, tag="2")]
+    pub sent_bytes: u64,
+}
+/// Defines fields that are shared by all Envoy access logs.
+/// \[#next-free-field: 22\]
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AccessLogCommon {
+    /// \[#not-implemented-hide:\]
+    /// This field indicates the rate at which this log entry was sampled.
+    /// Valid range is (0.0, 1.0].
+    #[prost(double, tag="1")]
+    pub sample_rate: f64,
+    /// This field is the remote/origin address on which the request from the user was received.
+    /// Note: This may not be the physical peer. E.g, if the remote address is inferred from for
+    /// example the x-forwarder-for header, proxy protocol, etc.
+    #[prost(message, optional, tag="2")]
+    pub downstream_remote_address: ::core::option::Option<super::super::super::api::v2::core::Address>,
+    /// This field is the local/destination address on which the request from the user was received.
+    #[prost(message, optional, tag="3")]
+    pub downstream_local_address: ::core::option::Option<super::super::super::api::v2::core::Address>,
+    /// If the connection is secure,S this field will contain TLS properties.
+    #[prost(message, optional, tag="4")]
+    pub tls_properties: ::core::option::Option<TlsProperties>,
+    /// The time that Envoy started servicing this request. This is effectively the time that the first
+    /// downstream byte is received.
+    #[prost(message, optional, tag="5")]
+    pub start_time: ::core::option::Option<super::super::super::super::google::protobuf::Timestamp>,
+    /// Interval between the first downstream byte received and the last
+    /// downstream byte received (i.e. time it takes to receive a request).
+    #[prost(message, optional, tag="6")]
+    pub time_to_last_rx_byte: ::core::option::Option<super::super::super::super::google::protobuf::Duration>,
+    /// Interval between the first downstream byte received and the first upstream byte sent. There may
+    /// by considerable delta between *time_to_last_rx_byte* and this value due to filters.
+    /// Additionally, the same caveats apply as documented in *time_to_last_downstream_tx_byte* about
+    /// not accounting for kernel socket buffer time, etc.
+    #[prost(message, optional, tag="7")]
+    pub time_to_first_upstream_tx_byte: ::core::option::Option<super::super::super::super::google::protobuf::Duration>,
+    /// Interval between the first downstream byte received and the last upstream byte sent. There may
+    /// by considerable delta between *time_to_last_rx_byte* and this value due to filters.
+    /// Additionally, the same caveats apply as documented in *time_to_last_downstream_tx_byte* about
+    /// not accounting for kernel socket buffer time, etc.
+    #[prost(message, optional, tag="8")]
+    pub time_to_last_upstream_tx_byte: ::core::option::Option<super::super::super::super::google::protobuf::Duration>,
+    /// Interval between the first downstream byte received and the first upstream
+    /// byte received (i.e. time it takes to start receiving a response).
+    #[prost(message, optional, tag="9")]
+    pub time_to_first_upstream_rx_byte: ::core::option::Option<super::super::super::super::google::protobuf::Duration>,
+    /// Interval between the first downstream byte received and the last upstream
+    /// byte received (i.e. time it takes to receive a complete response).
+    #[prost(message, optional, tag="10")]
+    pub time_to_last_upstream_rx_byte: ::core::option::Option<super::super::super::super::google::protobuf::Duration>,
+    /// Interval between the first downstream byte received and the first downstream byte sent.
+    /// There may be a considerable delta between the *time_to_first_upstream_rx_byte* and this field
+    /// due to filters. Additionally, the same caveats apply as documented in
+    /// *time_to_last_downstream_tx_byte* about not accounting for kernel socket buffer time, etc.
+    #[prost(message, optional, tag="11")]
+    pub time_to_first_downstream_tx_byte: ::core::option::Option<super::super::super::super::google::protobuf::Duration>,
+    /// Interval between the first downstream byte received and the last downstream byte sent.
+    /// Depending on protocol, buffering, windowing, filters, etc. there may be a considerable delta
+    /// between *time_to_last_upstream_rx_byte* and this field. Note also that this is an approximate
+    /// time. In the current implementation it does not include kernel socket buffer time. In the
+    /// current implementation it also does not include send window buffering inside the HTTP/2 codec.
+    /// In the future it is likely that work will be done to make this duration more accurate.
+    #[prost(message, optional, tag="12")]
+    pub time_to_last_downstream_tx_byte: ::core::option::Option<super::super::super::super::google::protobuf::Duration>,
+    /// The upstream remote/destination address that handles this exchange. This does not include
+    /// retries.
+    #[prost(message, optional, tag="13")]
+    pub upstream_remote_address: ::core::option::Option<super::super::super::api::v2::core::Address>,
+    /// The upstream local/origin address that handles this exchange. This does not include retries.
+    #[prost(message, optional, tag="14")]
+    pub upstream_local_address: ::core::option::Option<super::super::super::api::v2::core::Address>,
+    /// The upstream cluster that *upstream_remote_address* belongs to.
+    #[prost(string, tag="15")]
+    pub upstream_cluster: ::prost::alloc::string::String,
+    /// Flags indicating occurrences during request/response processing.
+    #[prost(message, optional, tag="16")]
+    pub response_flags: ::core::option::Option<ResponseFlags>,
+    /// All metadata encountered during request processing, including endpoint
+    /// selection.
+    ///
+    /// This can be used to associate IDs attached to the various configurations
+    /// used to process this request with the access log entry. For example, a
+    /// route created from a higher level forwarding rule with some ID can place
+    /// that ID in this field and cross reference later. It can also be used to
+    /// determine if a canary endpoint was used or not.
+    #[prost(message, optional, tag="17")]
+    pub metadata: ::core::option::Option<super::super::super::api::v2::core::Metadata>,
+    /// If upstream connection failed due to transport socket (e.g. TLS handshake), provides the
+    /// failure reason from the transport socket. The format of this field depends on the configured
+    /// upstream transport socket. Common TLS failures are in
+    /// :ref:`TLS trouble shooting <arch_overview_ssl_trouble_shooting>`.
+    #[prost(string, tag="18")]
+    pub upstream_transport_failure_reason: ::prost::alloc::string::String,
+    /// The name of the route
+    #[prost(string, tag="19")]
+    pub route_name: ::prost::alloc::string::String,
+    /// This field is the downstream direct remote address on which the request from the user was
+    /// received. Note: This is always the physical peer, even if the remote address is inferred from
+    /// for example the x-forwarder-for header, proxy protocol, etc.
+    #[prost(message, optional, tag="20")]
+    pub downstream_direct_remote_address: ::core::option::Option<super::super::super::api::v2::core::Address>,
+    /// Map of filter state in stream info that have been configured to be logged. If the filter
+    /// state serialized to any message other than `google.protobuf.Any` it will be packed into
+    /// `google.protobuf.Any`.
+    #[prost(map="string, message", tag="21")]
+    pub filter_state_objects: ::std::collections::HashMap<::prost::alloc::string::String, super::super::super::super::google::protobuf::Any>,
+}
+/// Flags indicating occurrences during request/response processing.
+/// \[#next-free-field: 20\]
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct ResponseFlags {
+    /// Indicates local server healthcheck failed.
+    #[prost(bool, tag="1")]
+    pub failed_local_healthcheck: bool,
+    /// Indicates there was no healthy upstream.
+    #[prost(bool, tag="2")]
+    pub no_healthy_upstream: bool,
+    /// Indicates an there was an upstream request timeout.
+    #[prost(bool, tag="3")]
+    pub upstream_request_timeout: bool,
+    /// Indicates local codec level reset was sent on the stream.
+    #[prost(bool, tag="4")]
+    pub local_reset: bool,
+    /// Indicates remote codec level reset was received on the stream.
+    #[prost(bool, tag="5")]
+    pub upstream_remote_reset: bool,
+    /// Indicates there was a local reset by a connection pool due to an initial connection failure.
+    #[prost(bool, tag="6")]
+    pub upstream_connection_failure: bool,
+    /// Indicates the stream was reset due to an upstream connection termination.
+    #[prost(bool, tag="7")]
+    pub upstream_connection_termination: bool,
+    /// Indicates the stream was reset because of a resource overflow.
+    #[prost(bool, tag="8")]
+    pub upstream_overflow: bool,
+    /// Indicates no route was found for the request.
+    #[prost(bool, tag="9")]
+    pub no_route_found: bool,
+    /// Indicates that the request was delayed before proxying.
+    #[prost(bool, tag="10")]
+    pub delay_injected: bool,
+    /// Indicates that the request was aborted with an injected error code.
+    #[prost(bool, tag="11")]
+    pub fault_injected: bool,
+    /// Indicates that the request was rate-limited locally.
+    #[prost(bool, tag="12")]
+    pub rate_limited: bool,
+    /// Indicates if the request was deemed unauthorized and the reason for it.
+    #[prost(message, optional, tag="13")]
+    pub unauthorized_details: ::core::option::Option<response_flags::Unauthorized>,
+    /// Indicates that the request was rejected because there was an error in rate limit service.
+    #[prost(bool, tag="14")]
+    pub rate_limit_service_error: bool,
+    /// Indicates the stream was reset due to a downstream connection termination.
+    #[prost(bool, tag="15")]
+    pub downstream_connection_termination: bool,
+    /// Indicates that the upstream retry limit was exceeded, resulting in a downstream error.
+    #[prost(bool, tag="16")]
+    pub upstream_retry_limit_exceeded: bool,
+    /// Indicates that the stream idle timeout was hit, resulting in a downstream 408.
+    #[prost(bool, tag="17")]
+    pub stream_idle_timeout: bool,
+    /// Indicates that the request was rejected because an envoy request header failed strict
+    /// validation.
+    #[prost(bool, tag="18")]
+    pub invalid_envoy_request_headers: bool,
+    /// Indicates there was an HTTP protocol error on the downstream request.
+    #[prost(bool, tag="19")]
+    pub downstream_protocol_error: bool,
+}
+/// Nested message and enum types in `ResponseFlags`.
+pub mod response_flags {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+    pub struct Unauthorized {
+        #[prost(enumeration="unauthorized::Reason", tag="1")]
+        pub reason: i32,
+    }
+    /// Nested message and enum types in `Unauthorized`.
+    pub mod unauthorized {
+        /// Reasons why the request was unauthorized
+        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+        #[repr(i32)]
+        pub enum Reason {
+            Unspecified = 0,
+            /// The request was denied by the external authorization service.
+            ExternalService = 1,
+        }
+        impl Reason {
+            /// 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 {
+                    Reason::Unspecified => "REASON_UNSPECIFIED",
+                    Reason::ExternalService => "EXTERNAL_SERVICE",
+                }
+            }
+            /// Creates an enum from field names used in the ProtoBuf definition.
+            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+                match value {
+                    "REASON_UNSPECIFIED" => Some(Self::Unspecified),
+                    "EXTERNAL_SERVICE" => Some(Self::ExternalService),
+                    _ => None,
+                }
+            }
+        }
+    }
+}
+/// Properties of a negotiated TLS connection.
+/// \[#next-free-field: 7\]
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct TlsProperties {
+    /// Version of TLS that was negotiated.
+    #[prost(enumeration="tls_properties::TlsVersion", tag="1")]
+    pub tls_version: i32,
+    /// TLS cipher suite negotiated during handshake. The value is a
+    /// four-digit hex code defined by the IANA TLS Cipher Suite Registry
+    /// (e.g. ``009C`` for ``TLS_RSA_WITH_AES_128_GCM_SHA256``).
+    ///
+    /// Here it is expressed as an integer.
+    #[prost(message, optional, tag="2")]
+    pub tls_cipher_suite: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>,
+    /// SNI hostname from handshake.
+    #[prost(string, tag="3")]
+    pub tls_sni_hostname: ::prost::alloc::string::String,
+    /// Properties of the local certificate used to negotiate TLS.
+    #[prost(message, optional, tag="4")]
+    pub local_certificate_properties: ::core::option::Option<tls_properties::CertificateProperties>,
+    /// Properties of the peer certificate used to negotiate TLS.
+    #[prost(message, optional, tag="5")]
+    pub peer_certificate_properties: ::core::option::Option<tls_properties::CertificateProperties>,
+    /// The TLS session ID.
+    #[prost(string, tag="6")]
+    pub tls_session_id: ::prost::alloc::string::String,
+}
+/// Nested message and enum types in `TLSProperties`.
+pub mod tls_properties {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct CertificateProperties {
+        /// SANs present in the certificate.
+        #[prost(message, repeated, tag="1")]
+        pub subject_alt_name: ::prost::alloc::vec::Vec<certificate_properties::SubjectAltName>,
+        /// The subject field of the certificate.
+        #[prost(string, tag="2")]
+        pub subject: ::prost::alloc::string::String,
+    }
+    /// Nested message and enum types in `CertificateProperties`.
+    pub mod certificate_properties {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct SubjectAltName {
+            #[prost(oneof="subject_alt_name::San", tags="1, 2")]
+            pub san: ::core::option::Option<subject_alt_name::San>,
+        }
+        /// Nested message and enum types in `SubjectAltName`.
+        pub mod subject_alt_name {
+            #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Oneof)]
+            pub enum San {
+                #[prost(string, tag="1")]
+                Uri(::prost::alloc::string::String),
+                /// \[#not-implemented-hide:\]
+                #[prost(string, tag="2")]
+                Dns(::prost::alloc::string::String),
+            }
+        }
+    }
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+    #[repr(i32)]
+    pub enum TlsVersion {
+        VersionUnspecified = 0,
+        TlSv1 = 1,
+        TlSv11 = 2,
+        TlSv12 = 3,
+        TlSv13 = 4,
+    }
+    impl TlsVersion {
+        /// 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 {
+                TlsVersion::VersionUnspecified => "VERSION_UNSPECIFIED",
+                TlsVersion::TlSv1 => "TLSv1",
+                TlsVersion::TlSv11 => "TLSv1_1",
+                TlsVersion::TlSv12 => "TLSv1_2",
+                TlsVersion::TlSv13 => "TLSv1_3",
+            }
+        }
+        /// Creates an enum from field names used in the ProtoBuf definition.
+        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+            match value {
+                "VERSION_UNSPECIFIED" => Some(Self::VersionUnspecified),
+                "TLSv1" => Some(Self::TlSv1),
+                "TLSv1_1" => Some(Self::TlSv11),
+                "TLSv1_2" => Some(Self::TlSv12),
+                "TLSv1_3" => Some(Self::TlSv13),
+                _ => None,
+            }
+        }
+    }
+}
+/// \[#next-free-field: 14\]
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct HttpRequestProperties {
+    /// The request method (RFC 7231/2616).
+    #[prost(enumeration="super::super::super::api::v2::core::RequestMethod", tag="1")]
+    pub request_method: i32,
+    /// The scheme portion of the incoming request URI.
+    #[prost(string, tag="2")]
+    pub scheme: ::prost::alloc::string::String,
+    /// HTTP/2 ``:authority`` or HTTP/1.1 ``Host`` header value.
+    #[prost(string, tag="3")]
+    pub authority: ::prost::alloc::string::String,
+    /// The port of the incoming request URI
+    /// (unused currently, as port is composed onto authority).
+    #[prost(message, optional, tag="4")]
+    pub port: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>,
+    /// The path portion from the incoming request URI.
+    #[prost(string, tag="5")]
+    pub path: ::prost::alloc::string::String,
+    /// Value of the ``User-Agent`` request header.
+    #[prost(string, tag="6")]
+    pub user_agent: ::prost::alloc::string::String,
+    /// Value of the ``Referer`` request header.
+    #[prost(string, tag="7")]
+    pub referer: ::prost::alloc::string::String,
+    /// Value of the ``X-Forwarded-For`` request header.
+    #[prost(string, tag="8")]
+    pub forwarded_for: ::prost::alloc::string::String,
+    /// Value of the ``X-Request-Id`` request header
+    ///
+    /// This header is used by Envoy to uniquely identify a request.
+    /// It will be generated for all external requests and internal requests that
+    /// do not already have a request ID.
+    #[prost(string, tag="9")]
+    pub request_id: ::prost::alloc::string::String,
+    /// Value of the ``X-Envoy-Original-Path`` request header.
+    #[prost(string, tag="10")]
+    pub original_path: ::prost::alloc::string::String,
+    /// Size of the HTTP request headers in bytes.
+    ///
+    /// This value is captured from the OSI layer 7 perspective, i.e. it does not
+    /// include overhead from framing or encoding at other networking layers.
+    #[prost(uint64, tag="11")]
+    pub request_headers_bytes: u64,
+    /// Size of the HTTP request body in bytes.
+    ///
+    /// This value is captured from the OSI layer 7 perspective, i.e. it does not
+    /// include overhead from framing or encoding at other networking layers.
+    #[prost(uint64, tag="12")]
+    pub request_body_bytes: u64,
+    /// Map of additional headers that have been configured to be logged.
+    #[prost(map="string, string", tag="13")]
+    pub request_headers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
+}
+/// \[#next-free-field: 7\]
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct HttpResponseProperties {
+    /// The HTTP response code returned by Envoy.
+    #[prost(message, optional, tag="1")]
+    pub response_code: ::core::option::Option<super::super::super::super::google::protobuf::UInt32Value>,
+    /// Size of the HTTP response headers in bytes.
+    ///
+    /// This value is captured from the OSI layer 7 perspective, i.e. it does not
+    /// include overhead from framing or encoding at other networking layers.
+    #[prost(uint64, tag="2")]
+    pub response_headers_bytes: u64,
+    /// Size of the HTTP response body in bytes.
+    ///
+    /// This value is captured from the OSI layer 7 perspective, i.e. it does not
+    /// include overhead from framing or encoding at other networking layers.
+    #[prost(uint64, tag="3")]
+    pub response_body_bytes: u64,
+    /// Map of additional headers configured to be logged.
+    #[prost(map="string, string", tag="4")]
+    pub response_headers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
+    /// Map of trailers configured to be logged.
+    #[prost(map="string, string", tag="5")]
+    pub response_trailers: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
+    /// The HTTP response code details.
+    #[prost(string, tag="6")]
+    pub response_code_details: ::prost::alloc::string::String,
+}
+// @@protoc_insertion_point(module)