nominal_api_proto/proto/

nominal.compute.v1.rs

// This file is @generated by prost-build.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TimeSeriesReference {
    #[prost(string, tag = "1")]
    pub variable_name: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ComputeDuration {
    #[prost(int64, tag = "1")]
    pub seconds: i64,
    #[prost(int64, tag = "2")]
    pub nanos: i64,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ComputeTimestamp {
    #[prost(int64, tag = "1")]
    pub seconds: i64,
    #[prost(int64, tag = "2")]
    pub nanos: i64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DoubleConstant {
    #[prost(oneof = "double_constant::Kind", tags = "1, 2, 3")]
    pub kind: ::core::option::Option<double_constant::Kind>,
}
/// Nested message and enum types in `DoubleConstant`.
pub mod double_constant {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(double, tag = "1")]
        Literal(f64),
        #[prost(string, tag = "2")]
        VariableName(::prost::alloc::string::String),
        #[prost(message, tag = "3")]
        Builtin(super::BuiltinConstant),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntegerConstant {
    #[prost(oneof = "integer_constant::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<integer_constant::Kind>,
}
/// Nested message and enum types in `IntegerConstant`.
pub mod integer_constant {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(int32, tag = "1")]
        Literal(i32),
        #[prost(string, tag = "2")]
        VariableName(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StringConstant {
    #[prost(oneof = "string_constant::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<string_constant::Kind>,
}
/// Nested message and enum types in `StringConstant`.
pub mod string_constant {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(string, tag = "1")]
        Literal(::prost::alloc::string::String),
        #[prost(string, tag = "2")]
        VariableName(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DurationConstant {
    #[prost(oneof = "duration_constant::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<duration_constant::Kind>,
}
/// Nested message and enum types in `DurationConstant`.
pub mod duration_constant {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Literal(super::ComputeDuration),
        #[prost(string, tag = "2")]
        VariableName(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TimestampConstant {
    #[prost(oneof = "timestamp_constant::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<timestamp_constant::Kind>,
}
/// Nested message and enum types in `TimestampConstant`.
pub mod timestamp_constant {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Literal(super::ComputeTimestamp),
        #[prost(string, tag = "2")]
        VariableName(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StringSetConstant {
    #[prost(oneof = "string_set_constant::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<string_set_constant::Kind>,
}
/// Nested message and enum types in `StringSetConstant`.
pub mod string_set_constant {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Literal(super::StringSetLiteral),
        #[prost(string, tag = "2")]
        VariableName(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StringSetLiteral {
    #[prost(string, repeated, tag = "1")]
    pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ParameterizedStringSet {
    #[prost(oneof = "parameterized_string_set::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<parameterized_string_set::Kind>,
}
/// Nested message and enum types in `ParameterizedStringSet`.
pub mod parameterized_string_set {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Literal(super::ParameterizedStringSetLiteral),
        #[prost(string, tag = "2")]
        VariableName(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ParameterizedStringSetLiteral {
    #[prost(message, repeated, tag = "1")]
    pub values: ::prost::alloc::vec::Vec<StringConstant>,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct BuiltinConstant {
    #[prost(oneof = "builtin_constant::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<builtin_constant::Kind>,
}
/// Nested message and enum types in `BuiltinConstant`.
pub mod builtin_constant {
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(enumeration = "super::MathConstant", tag = "1")]
        Math(i32),
        #[prost(enumeration = "super::PhysicalConstant", tag = "2")]
        Physical(i32),
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum MathConstant {
    Unspecified = 0,
    Pi = 1,
    Tau = 2,
    E = 3,
}
impl MathConstant {
    /// 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 => "MATH_CONSTANT_UNSPECIFIED",
            Self::Pi => "MATH_CONSTANT_PI",
            Self::Tau => "MATH_CONSTANT_TAU",
            Self::E => "MATH_CONSTANT_E",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "MATH_CONSTANT_UNSPECIFIED" => Some(Self::Unspecified),
            "MATH_CONSTANT_PI" => Some(Self::Pi),
            "MATH_CONSTANT_TAU" => Some(Self::Tau),
            "MATH_CONSTANT_E" => Some(Self::E),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PhysicalConstant {
    Unspecified = 0,
    SpeedOfLight = 1,
    Avogadro = 2,
    Boltzmann = 3,
    Planck = 4,
    ElementaryCharge = 5,
    GasConstant = 6,
    StandardGravity = 7,
    StandardAtmosphere = 8,
    AbsoluteZeroCelsius = 9,
    GravitationalConstant = 10,
    StefanBoltzmann = 11,
}
impl PhysicalConstant {
    /// 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 => "PHYSICAL_CONSTANT_UNSPECIFIED",
            Self::SpeedOfLight => "PHYSICAL_CONSTANT_SPEED_OF_LIGHT",
            Self::Avogadro => "PHYSICAL_CONSTANT_AVOGADRO",
            Self::Boltzmann => "PHYSICAL_CONSTANT_BOLTZMANN",
            Self::Planck => "PHYSICAL_CONSTANT_PLANCK",
            Self::ElementaryCharge => "PHYSICAL_CONSTANT_ELEMENTARY_CHARGE",
            Self::GasConstant => "PHYSICAL_CONSTANT_GAS_CONSTANT",
            Self::StandardGravity => "PHYSICAL_CONSTANT_STANDARD_GRAVITY",
            Self::StandardAtmosphere => "PHYSICAL_CONSTANT_STANDARD_ATMOSPHERE",
            Self::AbsoluteZeroCelsius => "PHYSICAL_CONSTANT_ABSOLUTE_ZERO_CELSIUS",
            Self::GravitationalConstant => "PHYSICAL_CONSTANT_GRAVITATIONAL_CONSTANT",
            Self::StefanBoltzmann => "PHYSICAL_CONSTANT_STEFAN_BOLTZMANN",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PHYSICAL_CONSTANT_UNSPECIFIED" => Some(Self::Unspecified),
            "PHYSICAL_CONSTANT_SPEED_OF_LIGHT" => Some(Self::SpeedOfLight),
            "PHYSICAL_CONSTANT_AVOGADRO" => Some(Self::Avogadro),
            "PHYSICAL_CONSTANT_BOLTZMANN" => Some(Self::Boltzmann),
            "PHYSICAL_CONSTANT_PLANCK" => Some(Self::Planck),
            "PHYSICAL_CONSTANT_ELEMENTARY_CHARGE" => Some(Self::ElementaryCharge),
            "PHYSICAL_CONSTANT_GAS_CONSTANT" => Some(Self::GasConstant),
            "PHYSICAL_CONSTANT_STANDARD_GRAVITY" => Some(Self::StandardGravity),
            "PHYSICAL_CONSTANT_STANDARD_ATMOSPHERE" => Some(Self::StandardAtmosphere),
            "PHYSICAL_CONSTANT_ABSOLUTE_ZERO_CELSIUS" => Some(Self::AbsoluteZeroCelsius),
            "PHYSICAL_CONSTANT_GRAVITATIONAL_CONSTANT" => {
                Some(Self::GravitationalConstant)
            }
            "PHYSICAL_CONSTANT_STEFAN_BOLTZMANN" => Some(Self::StefanBoltzmann),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScalingFactor {
    #[prost(message, optional, tag = "1")]
    pub value: ::core::option::Option<DoubleConstant>,
    #[prost(string, optional, tag = "2")]
    pub unit: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResampleFill {
    #[prost(oneof = "resample_fill::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<resample_fill::Kind>,
}
/// Nested message and enum types in `ResampleFill`.
pub mod resample_fill {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        ForwardFill(super::ForwardFillResample),
        #[prost(message, tag = "2")]
        Constant(super::DoubleConstant),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ForwardFillResample {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalReduction {
    #[prost(oneof = "categorical_reduction::Kind", tags = "1, 2, 3")]
    pub kind: ::core::option::Option<categorical_reduction::Kind>,
}
/// Nested message and enum types in `CategoricalReduction`.
pub mod categorical_reduction {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Min(super::CategoricalMinReduction),
        #[prost(message, tag = "2")]
        Max(super::CategoricalMaxReduction),
        #[prost(message, tag = "3")]
        Udf(super::super::super::modules::v1::UdfSource),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CategoricalMinReduction {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CategoricalMaxReduction {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalResampleFill {
    #[prost(oneof = "categorical_resample_fill::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<categorical_resample_fill::Kind>,
}
/// Nested message and enum types in `CategoricalResampleFill`.
pub mod categorical_resample_fill {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        ForwardFill(super::ForwardFillResample),
        #[prost(message, tag = "2")]
        Constant(super::StringConstant),
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CategoricalMergeOperation {
    Unspecified = 0,
    RejectDuplicates = 1,
    Max = 2,
    Min = 3,
}
impl CategoricalMergeOperation {
    /// 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 => "CATEGORICAL_MERGE_OPERATION_UNSPECIFIED",
            Self::RejectDuplicates => "CATEGORICAL_MERGE_OPERATION_REJECT_DUPLICATES",
            Self::Max => "CATEGORICAL_MERGE_OPERATION_MAX",
            Self::Min => "CATEGORICAL_MERGE_OPERATION_MIN",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "CATEGORICAL_MERGE_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
            "CATEGORICAL_MERGE_OPERATION_REJECT_DUPLICATES" => {
                Some(Self::RejectDuplicates)
            }
            "CATEGORICAL_MERGE_OPERATION_MAX" => Some(Self::Max),
            "CATEGORICAL_MERGE_OPERATION_MIN" => Some(Self::Min),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchCancelRequestsRequest {
    #[prost(string, repeated, tag = "1")]
    pub request_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct BatchCancelRequestsResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetRequestProgressRequest {
    #[prost(string, repeated, tag = "1")]
    pub request_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct RequestInProgress {
    #[prost(int64, tag = "1")]
    pub read_rows: i64,
    #[prost(int64, tag = "2")]
    pub total_rows_approx: i64,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct RequestInactive {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestProgress {
    #[prost(string, tag = "1")]
    pub request_id: ::prost::alloc::string::String,
    #[prost(oneof = "request_progress::State", tags = "2, 3")]
    pub state: ::core::option::Option<request_progress::State>,
}
/// Nested message and enum types in `RequestProgress`.
pub mod request_progress {
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum State {
        #[prost(message, tag = "2")]
        InProgress(super::RequestInProgress),
        #[prost(message, tag = "3")]
        Inactive(super::RequestInactive),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetRequestProgressResponse {
    #[prost(message, repeated, tag = "1")]
    pub progress: ::prost::alloc::vec::Vec<RequestProgress>,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct QuotaWindow {
    #[prost(message, optional, tag = "1")]
    pub start_time: ::core::option::Option<
        super::super::super::google::protobuf::Timestamp,
    >,
    #[prost(message, optional, tag = "2")]
    pub end_time: ::core::option::Option<
        super::super::super::google::protobuf::Timestamp,
    >,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct QuotaResourceUsage {
    #[prost(enumeration = "QuotaResourceType", tag = "1")]
    pub resource: i32,
    #[prost(double, tag = "2")]
    pub used: f64,
    #[prost(double, tag = "3")]
    pub limit: f64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QuotaIntervalUsage {
    #[prost(int64, tag = "1")]
    pub duration_seconds: i64,
    #[prost(message, optional, tag = "2")]
    pub current_window: ::core::option::Option<QuotaWindow>,
    #[prost(message, repeated, tag = "3")]
    pub resources: ::prost::alloc::vec::Vec<QuotaResourceUsage>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QuotaUsage {
    #[prost(message, repeated, tag = "1")]
    pub intervals: ::prost::alloc::vec::Vec<QuotaIntervalUsage>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListQuotaUsageIntervalsRequest {
    #[prost(int32, optional, tag = "1")]
    pub page_size: ::core::option::Option<i32>,
    #[prost(string, tag = "2")]
    pub page_token: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListQuotaUsageIntervalsResponse {
    #[prost(message, repeated, tag = "1")]
    pub intervals: ::prost::alloc::vec::Vec<QuotaIntervalUsage>,
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ComputeRequestControlError {
    Unspecified = 0,
    InvalidRequestId = 1,
    InvalidPageToken = 2,
    InvalidPageSize = 3,
}
impl ComputeRequestControlError {
    /// 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 => "COMPUTE_REQUEST_CONTROL_ERROR_UNSPECIFIED",
            Self::InvalidRequestId => "COMPUTE_REQUEST_CONTROL_ERROR_INVALID_REQUEST_ID",
            Self::InvalidPageToken => "COMPUTE_REQUEST_CONTROL_ERROR_INVALID_PAGE_TOKEN",
            Self::InvalidPageSize => "COMPUTE_REQUEST_CONTROL_ERROR_INVALID_PAGE_SIZE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "COMPUTE_REQUEST_CONTROL_ERROR_UNSPECIFIED" => Some(Self::Unspecified),
            "COMPUTE_REQUEST_CONTROL_ERROR_INVALID_REQUEST_ID" => {
                Some(Self::InvalidRequestId)
            }
            "COMPUTE_REQUEST_CONTROL_ERROR_INVALID_PAGE_TOKEN" => {
                Some(Self::InvalidPageToken)
            }
            "COMPUTE_REQUEST_CONTROL_ERROR_INVALID_PAGE_SIZE" => {
                Some(Self::InvalidPageSize)
            }
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum QuotaResourceType {
    Unspecified = 0,
    ReadRows = 1,
    ReadBytes = 2,
    Queries = 3,
    Errors = 4,
    ExecutionTime = 5,
}
impl QuotaResourceType {
    /// 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 => "QUOTA_RESOURCE_TYPE_UNSPECIFIED",
            Self::ReadRows => "QUOTA_RESOURCE_TYPE_READ_ROWS",
            Self::ReadBytes => "QUOTA_RESOURCE_TYPE_READ_BYTES",
            Self::Queries => "QUOTA_RESOURCE_TYPE_QUERIES",
            Self::Errors => "QUOTA_RESOURCE_TYPE_ERRORS",
            Self::ExecutionTime => "QUOTA_RESOURCE_TYPE_EXECUTION_TIME",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "QUOTA_RESOURCE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "QUOTA_RESOURCE_TYPE_READ_ROWS" => Some(Self::ReadRows),
            "QUOTA_RESOURCE_TYPE_READ_BYTES" => Some(Self::ReadBytes),
            "QUOTA_RESOURCE_TYPE_QUERIES" => Some(Self::Queries),
            "QUOTA_RESOURCE_TYPE_ERRORS" => Some(Self::Errors),
            "QUOTA_RESOURCE_TYPE_EXECUTION_TIME" => Some(Self::ExecutionTime),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod compute_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct ComputeServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ComputeServiceClient<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> ComputeServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        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,
        ) -> ComputeServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            ComputeServiceClient::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 batch_cancel_requests(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchCancelRequestsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::BatchCancelRequestsResponse>,
            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(
                "/nominal.compute.v1.ComputeService/BatchCancelRequests",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.compute.v1.ComputeService",
                        "BatchCancelRequests",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn batch_get_request_progress(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchGetRequestProgressRequest>,
        ) -> std::result::Result<
            tonic::Response<super::BatchGetRequestProgressResponse>,
            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(
                "/nominal.compute.v1.ComputeService/BatchGetRequestProgress",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.compute.v1.ComputeService",
                        "BatchGetRequestProgress",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn list_quota_usage_intervals(
            &mut self,
            request: impl tonic::IntoRequest<super::ListQuotaUsageIntervalsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListQuotaUsageIntervalsResponse>,
            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(
                "/nominal.compute.v1.ComputeService/ListQuotaUsageIntervals",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "nominal.compute.v1.ComputeService",
                        "ListQuotaUsageIntervals",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ComputeModelConversionError {
    Unspecified = 0,
    UnsupportedExpression = 1,
    TimeComponentOutOfRange = 2,
    IntegerOperandOutOfRange = 3,
}
impl ComputeModelConversionError {
    /// 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 => "COMPUTE_MODEL_CONVERSION_ERROR_UNSPECIFIED",
            Self::UnsupportedExpression => {
                "COMPUTE_MODEL_CONVERSION_ERROR_UNSUPPORTED_EXPRESSION"
            }
            Self::TimeComponentOutOfRange => {
                "COMPUTE_MODEL_CONVERSION_ERROR_TIME_COMPONENT_OUT_OF_RANGE"
            }
            Self::IntegerOperandOutOfRange => {
                "COMPUTE_MODEL_CONVERSION_ERROR_INTEGER_OPERAND_OUT_OF_RANGE"
            }
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "COMPUTE_MODEL_CONVERSION_ERROR_UNSPECIFIED" => Some(Self::Unspecified),
            "COMPUTE_MODEL_CONVERSION_ERROR_UNSUPPORTED_EXPRESSION" => {
                Some(Self::UnsupportedExpression)
            }
            "COMPUTE_MODEL_CONVERSION_ERROR_TIME_COMPONENT_OUT_OF_RANGE" => {
                Some(Self::TimeComponentOutOfRange)
            }
            "COMPUTE_MODEL_CONVERSION_ERROR_INTEGER_OPERAND_OUT_OF_RANGE" => {
                Some(Self::IntegerOperandOutOfRange)
            }
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatasetReference {
    #[prost(message, optional, tag = "1")]
    pub name: ::core::option::Option<StringConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DurationExpression {
    #[prost(oneof = "duration_expression::Kind", tags = "1, 2, 3, 4")]
    pub kind: ::core::option::Option<duration_expression::Kind>,
}
/// Nested message and enum types in `DurationExpression`.
pub mod duration_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(string, tag = "1")]
        VariableName(::prost::alloc::string::String),
        #[prost(message, tag = "2")]
        Amount(super::DurationAmount),
        #[prost(message, tag = "3")]
        Binary(::prost::alloc::boxed::Box<super::BinaryDurationExpression>),
        #[prost(message, tag = "4")]
        Negated(::prost::alloc::boxed::Box<super::DurationExpression>),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DurationAmount {
    #[prost(message, optional, tag = "1")]
    pub count: ::core::option::Option<IntegerConstant>,
    #[prost(enumeration = "super::super::types::time::TimeUnit", tag = "2")]
    pub unit: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BinaryDurationExpression {
    #[prost(enumeration = "DurationOperation", tag = "1")]
    pub operation: i32,
    #[prost(message, optional, boxed, tag = "2")]
    pub left: ::core::option::Option<::prost::alloc::boxed::Box<DurationExpression>>,
    #[prost(message, optional, boxed, tag = "3")]
    pub right: ::core::option::Option<::prost::alloc::boxed::Box<DurationExpression>>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DurationOperation {
    Unspecified = 0,
    Add = 1,
    Subtract = 2,
}
impl DurationOperation {
    /// 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 => "DURATION_OPERATION_UNSPECIFIED",
            Self::Add => "DURATION_OPERATION_ADD",
            Self::Subtract => "DURATION_OPERATION_SUBTRACT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DURATION_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
            "DURATION_OPERATION_ADD" => Some(Self::Add),
            "DURATION_OPERATION_SUBTRACT" => Some(Self::Subtract),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TagPredicateExpression {
    #[prost(oneof = "tag_predicate_expression::Kind", tags = "1, 2, 3")]
    pub kind: ::core::option::Option<tag_predicate_expression::Kind>,
}
/// Nested message and enum types in `TagPredicateExpression`.
pub mod tag_predicate_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        In(super::TagMembershipExpression),
        #[prost(message, tag = "2")]
        NotIn(super::TagMembershipExpression),
        #[prost(message, tag = "3")]
        And(::prost::alloc::boxed::Box<super::TagConjunctionExpression>),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TagMembershipExpression {
    #[prost(message, optional, tag = "1")]
    pub key: ::core::option::Option<StringConstant>,
    #[prost(message, optional, tag = "2")]
    pub values: ::core::option::Option<ParameterizedStringSet>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TagConjunctionExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub left: ::core::option::Option<::prost::alloc::boxed::Box<TagPredicateExpression>>,
    #[prost(message, optional, boxed, tag = "2")]
    pub right: ::core::option::Option<
        ::prost::alloc::boxed::Box<TagPredicateExpression>,
    >,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TagKeySet {
    #[prost(message, optional, tag = "1")]
    pub keys: ::core::option::Option<ParameterizedStringSet>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AssetReferenceExpression {
    #[prost(oneof = "asset_reference_expression::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<asset_reference_expression::Kind>,
}
/// Nested message and enum types in `AssetReferenceExpression`.
pub mod asset_reference_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(string, tag = "1")]
        Literal(::prost::alloc::string::String),
        #[prost(string, tag = "2")]
        VariableName(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunReferenceExpression {
    #[prost(oneof = "run_reference_expression::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<run_reference_expression::Kind>,
}
/// Nested message and enum types in `RunReferenceExpression`.
pub mod run_reference_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(string, tag = "1")]
        Literal(::prost::alloc::string::String),
        #[prost(string, tag = "2")]
        VariableName(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataSourceReferenceExpression {
    #[prost(oneof = "data_source_reference_expression::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<data_source_reference_expression::Kind>,
}
/// Nested message and enum types in `DataSourceReferenceExpression`.
pub mod data_source_reference_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(string, tag = "1")]
        Literal(::prost::alloc::string::String),
        #[prost(string, tag = "2")]
        VariableName(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResourceTypeReferenceExpression {
    #[prost(oneof = "resource_type_reference_expression::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<resource_type_reference_expression::Kind>,
}
/// Nested message and enum types in `ResourceTypeReferenceExpression`.
pub mod resource_type_reference_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(string, tag = "1")]
        Literal(::prost::alloc::string::String),
        #[prost(string, tag = "2")]
        VariableName(::prost::alloc::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ChannelSelection {
    #[prost(oneof = "channel_selection::Source", tags = "1, 2, 3")]
    pub source: ::core::option::Option<channel_selection::Source>,
}
/// Nested message and enum types in `ChannelSelection`.
pub mod channel_selection {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        #[prost(message, tag = "1")]
        DataSource(super::DataSourceChannelSelection),
        #[prost(message, tag = "2")]
        Asset(super::AssetChannelSelection),
        #[prost(message, tag = "3")]
        Run(super::RunChannelSelection),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataSourceChannelSelection {
    #[prost(message, optional, tag = "1")]
    pub data_source: ::core::option::Option<DataSourceReferenceExpression>,
    #[prost(message, optional, tag = "2")]
    pub channel: ::core::option::Option<StringConstant>,
    #[prost(message, optional, tag = "3")]
    pub tags: ::core::option::Option<ChannelTagConstraints>,
    #[prost(message, optional, tag = "4")]
    pub grouping_keys: ::core::option::Option<TagKeySet>,
    #[prost(enumeration = "SeriesStorageEngine", optional, tag = "5")]
    pub storage: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AssetChannelSelection {
    #[prost(message, optional, tag = "1")]
    pub asset: ::core::option::Option<AssetReferenceExpression>,
    #[prost(message, optional, tag = "2")]
    pub data_scope: ::core::option::Option<StringConstant>,
    #[prost(message, optional, tag = "3")]
    pub channel: ::core::option::Option<StringConstant>,
    #[prost(message, optional, tag = "4")]
    pub tags: ::core::option::Option<ChannelTagConstraints>,
    #[prost(message, optional, tag = "5")]
    pub grouping_keys: ::core::option::Option<TagKeySet>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunChannelSelection {
    #[prost(message, optional, tag = "1")]
    pub run: ::core::option::Option<RunReferenceExpression>,
    #[prost(message, optional, tag = "2")]
    pub asset: ::core::option::Option<AssetReferenceExpression>,
    #[prost(message, optional, tag = "3")]
    pub data_scope: ::core::option::Option<StringConstant>,
    #[prost(message, optional, tag = "4")]
    pub channel: ::core::option::Option<StringConstant>,
    #[prost(message, optional, tag = "5")]
    pub tags: ::core::option::Option<ChannelTagConstraints>,
    #[prost(message, optional, tag = "6")]
    pub grouping_keys: ::core::option::Option<TagKeySet>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ChannelTagConstraints {
    #[prost(oneof = "channel_tag_constraints::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<channel_tag_constraints::Kind>,
}
/// Nested message and enum types in `ChannelTagConstraints`.
pub mod channel_tag_constraints {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        ExactValues(super::ExactTagValues),
        #[prost(message, tag = "2")]
        Predicate(super::TagPredicateExpression),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExactTagValues {
    #[prost(map = "string, message", tag = "1")]
    pub values: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        StringConstant,
    >,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SeriesSampling {
    #[prost(oneof = "series_sampling::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<series_sampling::Kind>,
}
/// Nested message and enum types in `SeriesSampling`.
pub mod series_sampling {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        EveryNthPerSeries(super::IntegerConstant),
        #[prost(message, tag = "2")]
        HashSubsample(super::IntegerConstant),
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SeriesStorageEngine {
    Unspecified = 0,
    Iceberg = 1,
    Clickhouse = 2,
}
impl SeriesStorageEngine {
    /// 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 => "SERIES_STORAGE_ENGINE_UNSPECIFIED",
            Self::Iceberg => "SERIES_STORAGE_ENGINE_ICEBERG",
            Self::Clickhouse => "SERIES_STORAGE_ENGINE_CLICKHOUSE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SERIES_STORAGE_ENGINE_UNSPECIFIED" => Some(Self::Unspecified),
            "SERIES_STORAGE_ENGINE_ICEBERG" => Some(Self::Iceberg),
            "SERIES_STORAGE_ENGINE_CLICKHOUSE" => Some(Self::Clickhouse),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventPredicateExpression {
    #[prost(
        oneof = "event_predicate_expression::Kind",
        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24"
    )]
    pub kind: ::core::option::Option<event_predicate_expression::Kind>,
}
/// Nested message and enum types in `EventPredicateExpression`.
pub mod event_predicate_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        SearchText(super::StringConstant),
        #[prost(message, tag = "2")]
        After(super::TimestampConstant),
        #[prost(message, tag = "3")]
        Before(super::TimestampConstant),
        #[prost(message, tag = "4")]
        TimestampCondition(super::EventTimestampCondition),
        #[prost(message, tag = "5")]
        Asset(super::AssetReferenceExpression),
        #[prost(message, tag = "6")]
        TemplateRid(super::StringConstant),
        #[prost(message, tag = "7")]
        WorkbookRid(super::StringConstant),
        #[prost(message, tag = "8")]
        DataReviewRid(super::StringConstant),
        #[prost(
            enumeration = "super::super::super::event::v2::SearchEventOriginType",
            tag = "9"
        )]
        OriginType(i32),
        #[prost(message, tag = "10")]
        DataReviewCheckRid(super::StringConstant),
        #[prost(
            enumeration = "super::super::super::event::v2::EventDispositionStatus",
            tag = "11"
        )]
        Disposition(i32),
        #[prost(message, tag = "12")]
        Priority(super::StringConstant),
        #[prost(message, tag = "13")]
        AssigneeRid(super::StringConstant),
        #[prost(enumeration = "super::super::super::event::v2::EventType", tag = "14")]
        EventType(i32),
        #[prost(message, tag = "15")]
        CreatedByRid(super::StringConstant),
        #[prost(message, tag = "16")]
        Label(super::StringConstant),
        #[prost(message, tag = "17")]
        Property(super::EventPropertyPredicate),
        #[prost(message, tag = "18")]
        All(super::EventPredicateGroup),
        #[prost(message, tag = "19")]
        Any(super::EventPredicateGroup),
        #[prost(message, tag = "20")]
        Negation(::prost::alloc::boxed::Box<super::EventPredicateExpression>),
        #[prost(message, tag = "21")]
        WorkspaceRid(super::StringConstant),
        #[prost(message, tag = "22")]
        ProcedureRid(super::StringConstant),
        #[prost(message, tag = "23")]
        ProcedureExecutionRid(super::StringConstant),
        #[prost(message, tag = "24")]
        StepId(super::StringConstant),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventTimestampCondition {
    #[prost(message, optional, tag = "1")]
    pub timestamp: ::core::option::Option<TimestampConstant>,
    #[prost(
        enumeration = "super::super::event::v2::EventTimeFilterCondition",
        tag = "2"
    )]
    pub condition: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventPropertyPredicate {
    #[prost(message, optional, tag = "1")]
    pub name: ::core::option::Option<StringConstant>,
    #[prost(message, optional, tag = "2")]
    pub value: ::core::option::Option<StringConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventPredicateGroup {
    #[prost(message, repeated, tag = "1")]
    pub predicates: ::prost::alloc::vec::Vec<EventPredicateExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogPredicate {
    #[prost(oneof = "log_predicate::Kind", tags = "1, 2, 3, 4, 5, 6")]
    pub kind: ::core::option::Option<log_predicate::Kind>,
}
/// Nested message and enum types in `LogPredicate`.
pub mod log_predicate {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(string, tag = "1")]
        MessageRegex(::prost::alloc::string::String),
        #[prost(string, tag = "2")]
        MessageContainsCaseInsensitive(::prost::alloc::string::String),
        #[prost(message, tag = "3")]
        AttributeRegex(super::LogAttributeRegex),
        #[prost(message, tag = "4")]
        All(super::LogPredicateGroup),
        #[prost(message, tag = "5")]
        Any(super::LogPredicateGroup),
        #[prost(message, tag = "6")]
        Negation(::prost::alloc::boxed::Box<super::LogPredicate>),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogAttributeRegex {
    #[prost(message, optional, tag = "1")]
    pub key: ::core::option::Option<StringConstant>,
    #[prost(string, tag = "2")]
    pub regex: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogPredicateGroup {
    #[prost(message, repeated, tag = "1")]
    pub predicates: ::prost::alloc::vec::Vec<LogPredicate>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericReduction {
    #[prost(oneof = "numeric_reduction::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9")]
    pub kind: ::core::option::Option<numeric_reduction::Kind>,
}
/// Nested message and enum types in `NumericReduction`.
pub mod numeric_reduction {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Sum(super::SumReduction),
        #[prost(message, tag = "2")]
        Average(super::AverageReduction),
        #[prost(message, tag = "3")]
        Min(super::MinReduction),
        #[prost(message, tag = "4")]
        Max(super::MaxReduction),
        #[prost(message, tag = "5")]
        Count(super::CountReduction),
        #[prost(message, tag = "6")]
        StandardDeviation(super::StandardDeviationReduction),
        #[prost(message, tag = "7")]
        RootMeanSquare(super::RootMeanSquareReduction),
        #[prost(message, tag = "8")]
        Percentile(super::DoubleConstant),
        #[prost(message, tag = "9")]
        Udf(super::super::super::modules::v1::UdfSource),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SumReduction {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct AverageReduction {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct MinReduction {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct MaxReduction {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CountReduction {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct StandardDeviationReduction {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct RootMeanSquareReduction {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DurationInput {
    #[prost(oneof = "duration_input::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<duration_input::Kind>,
}
/// Nested message and enum types in `DurationInput`.
pub mod duration_input {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Components(super::DurationConstant),
        #[prost(message, tag = "2")]
        Arithmetic(super::DurationExpression),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RangePersistence {
    #[prost(message, optional, tag = "1")]
    pub min_points: ::core::option::Option<IntegerConstant>,
    #[prost(message, optional, tag = "2")]
    pub min_duration: ::core::option::Option<DurationInput>,
    #[prost(enumeration = "RangeStartSelection", optional, tag = "3")]
    pub start: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SpreadThreshold {
    #[prost(oneof = "spread_threshold::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<spread_threshold::Kind>,
}
/// Nested message and enum types in `SpreadThreshold`.
pub mod spread_threshold {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Absolute(super::DoubleConstant),
        #[prost(message, tag = "2")]
        Percentage(super::DoubleConstant),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TagGrouping {
    #[prost(map = "string, string", tag = "1")]
    pub tags: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RangeStartSelection {
    Unspecified = 0,
    ConditionStart = 1,
    PersistenceStart = 2,
}
impl RangeStartSelection {
    /// 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 => "RANGE_START_SELECTION_UNSPECIFIED",
            Self::ConditionStart => "RANGE_START_SELECTION_CONDITION_START",
            Self::PersistenceStart => "RANGE_START_SELECTION_PERSISTENCE_START",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "RANGE_START_SELECTION_UNSPECIFIED" => Some(Self::Unspecified),
            "RANGE_START_SELECTION_CONDITION_START" => Some(Self::ConditionStart),
            "RANGE_START_SELECTION_PERSISTENCE_START" => Some(Self::PersistenceStart),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum UnboundedDurationComparison {
    Unspecified = 0,
    Infinity = 1,
    WindowBound = 2,
}
impl UnboundedDurationComparison {
    /// 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 => "UNBOUNDED_DURATION_COMPARISON_UNSPECIFIED",
            Self::Infinity => "UNBOUNDED_DURATION_COMPARISON_INFINITY",
            Self::WindowBound => "UNBOUNDED_DURATION_COMPARISON_WINDOW_BOUND",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "UNBOUNDED_DURATION_COMPARISON_UNSPECIFIED" => Some(Self::Unspecified),
            "UNBOUNDED_DURATION_COMPARISON_INFINITY" => Some(Self::Infinity),
            "UNBOUNDED_DURATION_COMPARISON_WINDOW_BOUND" => Some(Self::WindowBound),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum NumericBoundsCondition {
    Unspecified = 0,
    Outside = 1,
    OutsideOrEqual = 2,
    Inside = 3,
    InsideOrEqual = 4,
}
impl NumericBoundsCondition {
    /// 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 => "NUMERIC_BOUNDS_CONDITION_UNSPECIFIED",
            Self::Outside => "NUMERIC_BOUNDS_CONDITION_OUTSIDE",
            Self::OutsideOrEqual => "NUMERIC_BOUNDS_CONDITION_OUTSIDE_OR_EQUAL",
            Self::Inside => "NUMERIC_BOUNDS_CONDITION_INSIDE",
            Self::InsideOrEqual => "NUMERIC_BOUNDS_CONDITION_INSIDE_OR_EQUAL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NUMERIC_BOUNDS_CONDITION_UNSPECIFIED" => Some(Self::Unspecified),
            "NUMERIC_BOUNDS_CONDITION_OUTSIDE" => Some(Self::Outside),
            "NUMERIC_BOUNDS_CONDITION_OUTSIDE_OR_EQUAL" => Some(Self::OutsideOrEqual),
            "NUMERIC_BOUNDS_CONDITION_INSIDE" => Some(Self::Inside),
            "NUMERIC_BOUNDS_CONDITION_INSIDE_OR_EQUAL" => Some(Self::InsideOrEqual),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SeriesEqualityMode {
    Unspecified = 0,
    AllEqual = 1,
    NotAllEqual = 2,
}
impl SeriesEqualityMode {
    /// 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 => "SERIES_EQUALITY_MODE_UNSPECIFIED",
            Self::AllEqual => "SERIES_EQUALITY_MODE_ALL_EQUAL",
            Self::NotAllEqual => "SERIES_EQUALITY_MODE_NOT_ALL_EQUAL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SERIES_EQUALITY_MODE_UNSPECIFIED" => Some(Self::Unspecified),
            "SERIES_EQUALITY_MODE_ALL_EQUAL" => Some(Self::AllEqual),
            "SERIES_EQUALITY_MODE_NOT_ALL_EQUAL" => Some(Self::NotAllEqual),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CategoricalMembershipOperation {
    Unspecified = 0,
    In = 1,
    NotIn = 2,
    MatchesAnyRegex = 3,
}
impl CategoricalMembershipOperation {
    /// 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 => "CATEGORICAL_MEMBERSHIP_OPERATION_UNSPECIFIED",
            Self::In => "CATEGORICAL_MEMBERSHIP_OPERATION_IN",
            Self::NotIn => "CATEGORICAL_MEMBERSHIP_OPERATION_NOT_IN",
            Self::MatchesAnyRegex => "CATEGORICAL_MEMBERSHIP_OPERATION_MATCHES_ANY_REGEX",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "CATEGORICAL_MEMBERSHIP_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
            "CATEGORICAL_MEMBERSHIP_OPERATION_IN" => Some(Self::In),
            "CATEGORICAL_MEMBERSHIP_OPERATION_NOT_IN" => Some(Self::NotIn),
            "CATEGORICAL_MEMBERSHIP_OPERATION_MATCHES_ANY_REGEX" => {
                Some(Self::MatchesAnyRegex)
            }
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ExtremaSelection {
    Unspecified = 0,
    Peaks = 1,
    Troughs = 2,
    Both = 3,
}
impl ExtremaSelection {
    /// 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 => "EXTREMA_SELECTION_UNSPECIFIED",
            Self::Peaks => "EXTREMA_SELECTION_PEAKS",
            Self::Troughs => "EXTREMA_SELECTION_TROUGHS",
            Self::Both => "EXTREMA_SELECTION_BOTH",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "EXTREMA_SELECTION_UNSPECIFIED" => Some(Self::Unspecified),
            "EXTREMA_SELECTION_PEAKS" => Some(Self::Peaks),
            "EXTREMA_SELECTION_TROUGHS" => Some(Self::Troughs),
            "EXTREMA_SELECTION_BOTH" => Some(Self::Both),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RangePaddingSides {
    Unspecified = 0,
    Start = 1,
    End = 2,
    Both = 3,
}
impl RangePaddingSides {
    /// 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 => "RANGE_PADDING_SIDES_UNSPECIFIED",
            Self::Start => "RANGE_PADDING_SIDES_START",
            Self::End => "RANGE_PADDING_SIDES_END",
            Self::Both => "RANGE_PADDING_SIDES_BOTH",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "RANGE_PADDING_SIDES_UNSPECIFIED" => Some(Self::Unspecified),
            "RANGE_PADDING_SIDES_START" => Some(Self::Start),
            "RANGE_PADDING_SIDES_END" => Some(Self::End),
            "RANGE_PADDING_SIDES_BOTH" => Some(Self::Both),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RefpropSubstance {
    Unspecified = 0,
    Nitrogen = 1,
    Oxygen = 2,
    Helium = 3,
    Hydrogen = 4,
    Methane = 5,
    Propane = 6,
    Butane = 7,
    Water = 8,
    Xenon = 9,
    Air = 10,
    CarbonDioxide = 11,
    Argon = 12,
    CarbonMonoxide = 13,
    JetA4658 = 14,
    JetA3638 = 15,
}
impl RefpropSubstance {
    /// 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 => "REFPROP_SUBSTANCE_UNSPECIFIED",
            Self::Nitrogen => "REFPROP_SUBSTANCE_NITROGEN",
            Self::Oxygen => "REFPROP_SUBSTANCE_OXYGEN",
            Self::Helium => "REFPROP_SUBSTANCE_HELIUM",
            Self::Hydrogen => "REFPROP_SUBSTANCE_HYDROGEN",
            Self::Methane => "REFPROP_SUBSTANCE_METHANE",
            Self::Propane => "REFPROP_SUBSTANCE_PROPANE",
            Self::Butane => "REFPROP_SUBSTANCE_BUTANE",
            Self::Water => "REFPROP_SUBSTANCE_WATER",
            Self::Xenon => "REFPROP_SUBSTANCE_XENON",
            Self::Air => "REFPROP_SUBSTANCE_AIR",
            Self::CarbonDioxide => "REFPROP_SUBSTANCE_CARBON_DIOXIDE",
            Self::Argon => "REFPROP_SUBSTANCE_ARGON",
            Self::CarbonMonoxide => "REFPROP_SUBSTANCE_CARBON_MONOXIDE",
            Self::JetA4658 => "REFPROP_SUBSTANCE_JET_A_4658",
            Self::JetA3638 => "REFPROP_SUBSTANCE_JET_A_3638",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "REFPROP_SUBSTANCE_UNSPECIFIED" => Some(Self::Unspecified),
            "REFPROP_SUBSTANCE_NITROGEN" => Some(Self::Nitrogen),
            "REFPROP_SUBSTANCE_OXYGEN" => Some(Self::Oxygen),
            "REFPROP_SUBSTANCE_HELIUM" => Some(Self::Helium),
            "REFPROP_SUBSTANCE_HYDROGEN" => Some(Self::Hydrogen),
            "REFPROP_SUBSTANCE_METHANE" => Some(Self::Methane),
            "REFPROP_SUBSTANCE_PROPANE" => Some(Self::Propane),
            "REFPROP_SUBSTANCE_BUTANE" => Some(Self::Butane),
            "REFPROP_SUBSTANCE_WATER" => Some(Self::Water),
            "REFPROP_SUBSTANCE_XENON" => Some(Self::Xenon),
            "REFPROP_SUBSTANCE_AIR" => Some(Self::Air),
            "REFPROP_SUBSTANCE_CARBON_DIOXIDE" => Some(Self::CarbonDioxide),
            "REFPROP_SUBSTANCE_ARGON" => Some(Self::Argon),
            "REFPROP_SUBSTANCE_CARBON_MONOXIDE" => Some(Self::CarbonMonoxide),
            "REFPROP_SUBSTANCE_JET_A_4658" => Some(Self::JetA4658),
            "REFPROP_SUBSTANCE_JET_A_3638" => Some(Self::JetA3638),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RefpropProperty {
    Unspecified = 0,
    Temperature = 1,
    Pressure = 2,
    MassDensity = 3,
    MassSpecificEnthalpy = 4,
    MassSpecificInternalEnergy = 5,
    MassSpecificEntropy = 6,
    Viscosity = 7,
}
impl RefpropProperty {
    /// 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 => "REFPROP_PROPERTY_UNSPECIFIED",
            Self::Temperature => "REFPROP_PROPERTY_TEMPERATURE",
            Self::Pressure => "REFPROP_PROPERTY_PRESSURE",
            Self::MassDensity => "REFPROP_PROPERTY_MASS_DENSITY",
            Self::MassSpecificEnthalpy => "REFPROP_PROPERTY_MASS_SPECIFIC_ENTHALPY",
            Self::MassSpecificInternalEnergy => {
                "REFPROP_PROPERTY_MASS_SPECIFIC_INTERNAL_ENERGY"
            }
            Self::MassSpecificEntropy => "REFPROP_PROPERTY_MASS_SPECIFIC_ENTROPY",
            Self::Viscosity => "REFPROP_PROPERTY_VISCOSITY",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "REFPROP_PROPERTY_UNSPECIFIED" => Some(Self::Unspecified),
            "REFPROP_PROPERTY_TEMPERATURE" => Some(Self::Temperature),
            "REFPROP_PROPERTY_PRESSURE" => Some(Self::Pressure),
            "REFPROP_PROPERTY_MASS_DENSITY" => Some(Self::MassDensity),
            "REFPROP_PROPERTY_MASS_SPECIFIC_ENTHALPY" => Some(Self::MassSpecificEnthalpy),
            "REFPROP_PROPERTY_MASS_SPECIFIC_INTERNAL_ENERGY" => {
                Some(Self::MassSpecificInternalEnergy)
            }
            "REFPROP_PROPERTY_MASS_SPECIFIC_ENTROPY" => Some(Self::MassSpecificEntropy),
            "REFPROP_PROPERTY_VISCOSITY" => Some(Self::Viscosity),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResourcePredicate {
    #[prost(oneof = "resource_predicate::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8")]
    pub kind: ::core::option::Option<resource_predicate::Kind>,
}
/// Nested message and enum types in `ResourcePredicate`.
pub mod resource_predicate {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Properties(super::super::super::types::PropertiesFilter),
        #[prost(message, tag = "2")]
        NumericProperty(super::super::super::types::NumericPropertyPredicate),
        #[prost(message, tag = "3")]
        NumericPropertyRange(super::super::super::types::NumericPropertyRangePredicate),
        #[prost(message, tag = "4")]
        Labels(super::super::super::types::LabelsFilter),
        #[prost(message, tag = "5")]
        Workspace(super::StringConstant),
        #[prost(message, tag = "6")]
        All(super::ResourcePredicateGroup),
        #[prost(message, tag = "7")]
        Any(super::ResourcePredicateGroup),
        #[prost(message, tag = "8")]
        Negation(::prost::alloc::boxed::Box<super::ResourcePredicate>),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResourcePredicateGroup {
    #[prost(message, repeated, tag = "1")]
    pub predicates: ::prost::alloc::vec::Vec<ResourcePredicate>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatasetResourceSearch {
    #[prost(int32, optional, tag = "3")]
    pub max_results: ::core::option::Option<i32>,
    #[prost(oneof = "dataset_resource_search::Target", tags = "1, 2")]
    pub target: ::core::option::Option<dataset_resource_search::Target>,
}
/// Nested message and enum types in `DatasetResourceSearch`.
pub mod dataset_resource_search {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Target {
        #[prost(message, tag = "1")]
        Assets(super::ResourcePredicate),
        #[prost(message, tag = "2")]
        Runs(super::ResourcePredicate),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SignalFilterConfiguration {
    #[prost(oneof = "signal_filter_configuration::Kind", tags = "1, 2, 3, 4")]
    pub kind: ::core::option::Option<signal_filter_configuration::Kind>,
}
/// Nested message and enum types in `SignalFilterConfiguration`.
pub mod signal_filter_configuration {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        LowPass(super::SingleCutoffFilter),
        #[prost(message, tag = "2")]
        HighPass(super::SingleCutoffFilter),
        #[prost(message, tag = "3")]
        BandPass(super::FrequencyBandFilter),
        #[prost(message, tag = "4")]
        BandStop(super::FrequencyBandFilter),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SingleCutoffFilter {
    #[prost(message, optional, tag = "1")]
    pub cutoff_frequency: ::core::option::Option<DoubleConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FrequencyBandFilter {
    #[prost(message, optional, tag = "1")]
    pub lower_frequency: ::core::option::Option<DoubleConstant>,
    #[prost(message, optional, tag = "2")]
    pub upper_frequency: ::core::option::Option<DoubleConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericExpression {
    #[prost(
        oneof = "numeric_expression::Kind",
        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 57, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56"
    )]
    pub kind: ::core::option::Option<numeric_expression::Kind>,
}
/// Nested message and enum types in `NumericExpression`.
pub mod numeric_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Reference(super::TimeSeriesReference),
        #[prost(message, tag = "2")]
        Constant(super::DoubleConstant),
        #[prost(message, tag = "3")]
        Unary(::prost::alloc::boxed::Box<super::NumericUnaryExpression>),
        #[prost(message, tag = "4")]
        Binary(::prost::alloc::boxed::Box<super::NumericBinaryExpression>),
        #[prost(message, tag = "5")]
        Nary(super::NumericNaryExpression),
        #[prost(message, tag = "6")]
        Bitwise(::prost::alloc::boxed::Box<super::NumericBitwiseExpression>),
        #[prost(message, tag = "7")]
        Conditional(::prost::alloc::boxed::Box<super::NumericConditionalExpression>),
        #[prost(message, tag = "8")]
        CumulativeSum(::prost::alloc::boxed::Box<super::NumericCumulativeSumExpression>),
        #[prost(message, tag = "9")]
        Derivative(::prost::alloc::boxed::Box<super::NumericDerivativeExpression>),
        #[prost(message, tag = "10")]
        Integral(::prost::alloc::boxed::Box<super::NumericIntegralExpression>),
        #[prost(message, tag = "11")]
        TimeRangeFilter(
            ::prost::alloc::boxed::Box<super::NumericTimeRangeFilterExpression>,
        ),
        #[prost(message, tag = "12")]
        TimeShift(::prost::alloc::boxed::Box<super::NumericTimeShiftExpression>),
        #[prost(message, tag = "13")]
        ValueDifference(
            ::prost::alloc::boxed::Box<super::NumericValueDifferenceExpression>,
        ),
        #[prost(message, tag = "14")]
        PhaseUnwrap(::prost::alloc::boxed::Box<super::NumericPhaseUnwrapExpression>),
        #[prost(message, tag = "15")]
        PointLimit(::prost::alloc::boxed::Box<super::NumericPointLimitExpression>),
        #[prost(message, tag = "16")]
        NthPointDownsample(
            ::prost::alloc::boxed::Box<super::NumericNthPointDownsampleExpression>,
        ),
        #[prost(message, tag = "17")]
        LargestTriangleThreeBuckets(
            ::prost::alloc::boxed::Box<
                super::NumericLargestTriangleThreeBucketsExpression,
            >,
        ),
        #[prost(message, tag = "18")]
        ConditionFilter(
            ::prost::alloc::boxed::Box<super::NumericConditionFilterExpression>,
        ),
        #[prost(message, tag = "19")]
        ThresholdFilter(
            ::prost::alloc::boxed::Box<super::NumericThresholdFilterExpression>,
        ),
        #[prost(message, tag = "57")]
        DropNan(::prost::alloc::boxed::Box<super::NumericDropNanExpression>),
        #[prost(message, tag = "20")]
        ApproximateFilter(
            ::prost::alloc::boxed::Box<super::NumericApproximateFilterExpression>,
        ),
        #[prost(message, tag = "21")]
        SignalFilter(::prost::alloc::boxed::Box<super::NumericSignalFilterExpression>),
        #[prost(message, tag = "22")]
        UnitConversion(
            ::prost::alloc::boxed::Box<super::NumericUnitConversionExpression>,
        ),
        #[prost(message, tag = "23")]
        UnitOverride(::prost::alloc::boxed::Box<super::NumericUnitOverrideExpression>),
        #[prost(message, tag = "24")]
        ZScore(::prost::alloc::boxed::Box<super::NumericZScoreExpression>),
        #[prost(message, tag = "25")]
        Union(super::NumericUnionExpression),
        #[prost(message, tag = "26")]
        TimeShiftV2(::prost::alloc::boxed::Box<super::NumericTimeShiftV2Expression>),
        #[prost(message, tag = "27")]
        ResampleV2(::prost::alloc::boxed::Box<super::NumericResampleV2Expression>),
        #[prost(message, tag = "28")]
        ToStartOfInterval(
            ::prost::alloc::boxed::Box<super::NumericToStartOfIntervalExpression>,
        ),
        #[prost(message, tag = "29")]
        ScalarTransform(
            ::prost::alloc::boxed::Box<super::NumericScalarTransformExpression>,
        ),
        #[prost(message, tag = "30")]
        Arithmetic(super::NumericArithmeticExpression),
        #[prost(message, tag = "31")]
        FormulaFilter(super::NumericFormulaFilterExpression),
        #[prost(message, tag = "32")]
        LiteralBitwise(
            ::prost::alloc::boxed::Box<super::NumericLiteralBitwiseExpression>,
        ),
        #[prost(message, tag = "33")]
        Resample(::prost::alloc::boxed::Box<super::NumericResampleExpression>),
        #[prost(message, tag = "34")]
        Refprop(super::NumericRefpropExpression),
        #[prost(message, tag = "35")]
        RollingAggregation(
            ::prost::alloc::boxed::Box<super::NumericRollingAggregationExpression>,
        ),
        #[prost(message, tag = "36")]
        DuplicateTimestampAggregation(
            ::prost::alloc::boxed::Box<
                super::NumericDuplicateTimestampAggregationExpression,
            >,
        ),
        #[prost(message, tag = "37")]
        TagFilter(::prost::alloc::boxed::Box<super::NumericTagFilterExpression>),
        #[prost(message, tag = "38")]
        TagSelection(::prost::alloc::boxed::Box<super::NumericTagSelectionExpression>),
        #[prost(message, tag = "39")]
        AbsoluteTimestamp(
            ::prost::alloc::boxed::Box<super::NumericAbsoluteTimestampExpression>,
        ),
        #[prost(message, tag = "40")]
        ReduceUnderRanges(
            ::prost::alloc::boxed::Box<super::NumericReduceUnderRangesExpression>,
        ),
        #[prost(message, tag = "41")]
        ChannelSelection(super::ChannelSelection),
        #[prost(message, tag = "42")]
        LogMatches(::prost::alloc::boxed::Box<super::NumericLogMatchesExpression>),
        #[prost(message, tag = "43")]
        CountDuplicates(super::NumericCountDuplicatesExpression),
        #[prost(message, tag = "44")]
        ModuleFunction(super::ModuleFunctionExpression),
        #[prost(message, tag = "45")]
        CategoricalMapping(
            ::prost::alloc::boxed::Box<super::NumericCategoricalMappingExpression>,
        ),
        #[prost(message, tag = "46")]
        StructField(::prost::alloc::boxed::Box<super::NumericStructFieldExpression>),
        #[prost(message, tag = "47")]
        RangeFilter(::prost::alloc::boxed::Box<super::NumericRangeFilterExpression>),
        #[prost(message, tag = "48")]
        GroupWithinRanges(
            ::prost::alloc::boxed::Box<super::NumericGroupWithinRangesExpression>,
        ),
        #[prost(message, tag = "49")]
        Aggregation(::prost::alloc::boxed::Box<super::NumericAggregationExpression>),
        #[prost(message, tag = "50")]
        RangeDuration(::prost::alloc::boxed::Box<super::NumericRangeDurationExpression>),
        #[prost(message, tag = "51")]
        ScalarUdf(super::ScalarUdfExpression),
        #[prost(message, tag = "52")]
        ArrayIndex(::prost::alloc::boxed::Box<super::NumericArrayIndexExpression>),
        #[prost(message, tag = "53")]
        SeriesSelection(::prost::alloc::boxed::Box<super::SeriesSelection>),
        #[prost(message, tag = "54")]
        ResourceProperty(::prost::alloc::boxed::Box<super::ResourcePropertySelection>),
        #[prost(message, tag = "55")]
        IntervalTags(::prost::alloc::boxed::Box<super::NumericIntervalTagsExpression>),
        #[prost(message, tag = "56")]
        TimeDifference(
            ::prost::alloc::boxed::Box<super::NumericTimeDifferenceExpression>,
        ),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ComputeContext {
    #[prost(map = "string, message", tag = "1")]
    pub variables: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        VariableValue,
    >,
    #[prost(map = "string, message", tag = "2")]
    pub datasets: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        DatasetExpression,
    >,
    #[prost(message, optional, tag = "3")]
    pub default_fill: ::core::option::Option<ComputeFillStrategy>,
    #[prost(enumeration = "ComputeAlignmentStrategy", optional, tag = "4")]
    pub default_alignment: ::core::option::Option<i32>,
    #[prost(bool, optional, tag = "5")]
    pub apply_data_scope_offsets: ::core::option::Option<bool>,
    #[prost(bool, optional, tag = "6")]
    pub resolve_assets_through_datasets: ::core::option::Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ComputeFillStrategy {
    #[prost(oneof = "compute_fill_strategy::Kind", tags = "1")]
    pub kind: ::core::option::Option<compute_fill_strategy::Kind>,
}
/// Nested message and enum types in `ComputeFillStrategy`.
pub mod compute_fill_strategy {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        ForwardFill(super::DurationConstant),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VariableValue {
    #[prost(oneof = "variable_value::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10")]
    pub kind: ::core::option::Option<variable_value::Kind>,
}
/// Nested message and enum types in `VariableValue`.
pub mod variable_value {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(double, tag = "1")]
        DoubleValue(f64),
        #[prost(int32, tag = "2")]
        IntegerValue(i32),
        #[prost(string, tag = "3")]
        StringValue(::prost::alloc::string::String),
        #[prost(message, tag = "4")]
        StringSet(super::StringSetLiteral),
        #[prost(message, tag = "5")]
        Duration(super::ComputeDuration),
        #[prost(message, tag = "6")]
        Timestamp(super::ComputeTimestamp),
        #[prost(message, tag = "7")]
        Expression(super::BoundExpression),
        #[prost(message, tag = "8")]
        Channel(super::ChannelSelection),
        #[prost(message, tag = "9")]
        Series(super::SeriesBinding),
        #[prost(message, tag = "10")]
        ModuleFunction(super::ModuleFunctionExpression),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoundExpression {
    #[prost(message, optional, tag = "1")]
    pub expression: ::core::option::Option<ExpressionNode>,
    #[prost(message, optional, tag = "2")]
    pub context: ::core::option::Option<ComputeContext>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SeriesBinding {
    #[prost(message, optional, tag = "1")]
    pub series_selection: ::core::option::Option<SeriesSelection>,
    #[prost(message, optional, tag = "2")]
    pub grouping_keys: ::core::option::Option<TagKeySet>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ModuleFunctionExpression {
    #[prost(message, optional, tag = "1")]
    pub module: ::core::option::Option<StringConstant>,
    #[prost(message, optional, tag = "2")]
    pub function_name: ::core::option::Option<StringConstant>,
    #[prost(message, optional, tag = "3")]
    pub version: ::core::option::Option<StringConstant>,
    #[prost(map = "string, message", tag = "4")]
    pub arguments: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        FunctionArgument,
    >,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FunctionArgument {
    #[prost(oneof = "function_argument::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<function_argument::Kind>,
}
/// Nested message and enum types in `FunctionArgument`.
pub mod function_argument {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(string, tag = "1")]
        VariableName(::prost::alloc::string::String),
        #[prost(message, tag = "2")]
        Value(super::VariableValue),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatasetExpression {
    #[prost(
        oneof = "dataset_expression::Kind",
        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13"
    )]
    pub kind: ::core::option::Option<dataset_expression::Kind>,
}
/// Nested message and enum types in `DatasetExpression`.
pub mod dataset_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Asset(super::AssetReferenceExpression),
        #[prost(message, tag = "2")]
        Run(super::RunReferenceExpression),
        #[prost(message, tag = "3")]
        DataSource(super::DataSourceReferenceExpression),
        #[prost(message, tag = "4")]
        ResourceSearch(super::DatasetResourceSearch),
        #[prost(message, tag = "5")]
        Concatenate(super::DatasetConcatenation),
        #[prost(message, tag = "6")]
        Tag(::prost::alloc::boxed::Box<super::DatasetTagInjection>),
        #[prost(message, tag = "7")]
        Filter(::prost::alloc::boxed::Box<super::DatasetTagFilter>),
        #[prost(message, tag = "8")]
        TimeShift(::prost::alloc::boxed::Box<super::DatasetTimeShift>),
        #[prost(message, tag = "9")]
        AnchorAlignment(::prost::alloc::boxed::Box<super::DatasetAnchorAlignment>),
        #[prost(message, tag = "10")]
        AddSeries(::prost::alloc::boxed::Box<super::DatasetSeriesAddition>),
        #[prost(message, tag = "11")]
        RemoveSeries(::prost::alloc::boxed::Box<super::DatasetSeriesRemoval>),
        #[prost(message, tag = "12")]
        Reference(super::DatasetReference),
        #[prost(message, tag = "13")]
        Dimensions(::prost::alloc::boxed::Box<super::DatasetDimensions>),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatasetConcatenation {
    #[prost(message, repeated, tag = "1")]
    pub inputs: ::prost::alloc::vec::Vec<DatasetExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatasetTagInjection {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
    #[prost(message, optional, tag = "2")]
    pub key: ::core::option::Option<StringConstant>,
    #[prost(message, optional, tag = "3")]
    pub value: ::core::option::Option<StringConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatasetTagFilter {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
    #[prost(message, optional, tag = "2")]
    pub predicate: ::core::option::Option<TagPredicateExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatasetTimeShift {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
    #[prost(message, optional, tag = "2")]
    pub offset: ::core::option::Option<DurationExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatasetSeriesAddition {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
    #[prost(message, repeated, tag = "2")]
    pub series: ::prost::alloc::vec::Vec<NamedSeriesExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NamedSeriesExpression {
    #[prost(message, optional, tag = "1")]
    pub name: ::core::option::Option<StringConstant>,
    #[prost(message, optional, tag = "2")]
    pub definition: ::core::option::Option<SeriesExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatasetSeriesRemoval {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
    #[prost(message, repeated, tag = "2")]
    pub names: ::prost::alloc::vec::Vec<StringConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatasetDimensions {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
    #[prost(message, repeated, tag = "2")]
    pub dimensions: ::prost::alloc::vec::Vec<ResourceDimension>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResourceDimension {
    #[prost(message, optional, tag = "1")]
    pub tag_key: ::core::option::Option<StringConstant>,
    #[prost(oneof = "resource_dimension::Value", tags = "2, 3")]
    pub value: ::core::option::Option<resource_dimension::Value>,
}
/// Nested message and enum types in `ResourceDimension`.
pub mod resource_dimension {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(message, tag = "2")]
        StringProperty(super::StringConstant),
        #[prost(message, tag = "3")]
        Identity(super::ResourceTypeReferenceExpression),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SeriesSelection {
    #[prost(message, optional, tag = "1")]
    pub name: ::core::option::Option<StringConstant>,
    #[prost(message, optional, boxed, tag = "2")]
    pub dataset: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
    #[prost(message, optional, tag = "3")]
    pub sampling: ::core::option::Option<SeriesSampling>,
    #[prost(enumeration = "SeriesStorageEngine", optional, tag = "4")]
    pub storage: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResourcePropertySelection {
    #[prost(string, tag = "1")]
    pub property: ::prost::alloc::string::String,
    #[prost(message, optional, boxed, tag = "2")]
    pub dataset: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExpressionNode {
    #[prost(oneof = "expression_node::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9")]
    pub kind: ::core::option::Option<expression_node::Kind>,
}
/// Nested message and enum types in `ExpressionNode`.
pub mod expression_node {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Numeric(super::NumericExpression),
        #[prost(message, tag = "2")]
        Categorical(super::CategoricalExpression),
        #[prost(message, tag = "3")]
        Log(super::LogExpression),
        #[prost(message, tag = "4")]
        Ranges(super::RangeExpression),
        #[prost(message, tag = "5")]
        Array(super::ArrayExpression),
        #[prost(message, tag = "6")]
        Structure(super::StructExpression),
        #[prost(message, tag = "7")]
        CurveFit(super::CurveFitExpression),
        #[prost(message, tag = "8")]
        Video(super::TimeSeriesReference),
        #[prost(message, tag = "9")]
        Reference(super::TimeSeriesReference),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SeriesExpression {
    #[prost(oneof = "series_expression::Kind", tags = "1, 2, 3, 4, 5, 6, 7")]
    pub kind: ::core::option::Option<series_expression::Kind>,
}
/// Nested message and enum types in `SeriesExpression`.
pub mod series_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Numeric(::prost::alloc::boxed::Box<super::NumericExpression>),
        #[prost(message, tag = "2")]
        Categorical(::prost::alloc::boxed::Box<super::CategoricalExpression>),
        #[prost(message, tag = "3")]
        Log(::prost::alloc::boxed::Box<super::LogExpression>),
        #[prost(message, tag = "4")]
        Array(::prost::alloc::boxed::Box<super::ArrayExpression>),
        #[prost(message, tag = "5")]
        Structure(::prost::alloc::boxed::Box<super::StructExpression>),
        #[prost(message, tag = "6")]
        Video(super::TimeSeriesReference),
        #[prost(message, tag = "7")]
        Reference(super::TimeSeriesReference),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArrayExpression {
    #[prost(oneof = "array_expression::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<array_expression::Kind>,
}
/// Nested message and enum types in `ArrayExpression`.
pub mod array_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Numeric(::prost::alloc::boxed::Box<super::NumericArrayExpression>),
        #[prost(message, tag = "2")]
        Categorical(::prost::alloc::boxed::Box<super::CategoricalArrayExpression>),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CurveFitExpression {
    #[prost(message, optional, tag = "1")]
    pub target: ::core::option::Option<CurveSeriesVariable>,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<CurveFitInterval>,
    #[prost(message, optional, tag = "3")]
    pub model: ::core::option::Option<CurveModel>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CurveFitInterval {
    #[prost(message, optional, tag = "1")]
    pub start: ::core::option::Option<TimestampConstant>,
    #[prost(message, optional, tag = "2")]
    pub end: ::core::option::Option<TimestampConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CurveSeriesVariable {
    #[prost(message, optional, tag = "1")]
    pub series: ::core::option::Option<NumericExpression>,
    #[prost(message, optional, tag = "2")]
    pub bounds: ::core::option::Option<CurveVariableBounds>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CurveVariableBounds {
    #[prost(message, optional, tag = "1")]
    pub min: ::core::option::Option<DoubleConstant>,
    #[prost(message, optional, tag = "2")]
    pub max: ::core::option::Option<DoubleConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CurveVariable {
    #[prost(oneof = "curve_variable::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<curve_variable::Kind>,
}
/// Nested message and enum types in `CurveVariable`.
pub mod curve_variable {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Series(super::CurveSeriesVariable),
        #[prost(message, tag = "2")]
        Time(super::CurveTimeVariable),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CurveTimeVariable {
    #[prost(enumeration = "super::super::types::time::TimeUnit", optional, tag = "1")]
    pub unit: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CurveModel {
    #[prost(oneof = "curve_model::Kind", tags = "1, 2, 3")]
    pub kind: ::core::option::Option<curve_model::Kind>,
}
/// Nested message and enum types in `CurveModel`.
pub mod curve_model {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Builtin(super::BuiltinCurveModel),
        #[prost(message, tag = "2")]
        Polynomial(super::PolynomialCurveModel),
        #[prost(message, tag = "3")]
        Custom(super::CustomCurveModel),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BuiltinCurveModel {
    #[prost(enumeration = "BuiltinCurveForm", tag = "1")]
    pub form: i32,
    #[prost(message, optional, tag = "2")]
    pub independent_variable: ::core::option::Option<CurveVariable>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PolynomialCurveModel {
    #[prost(message, optional, tag = "1")]
    pub independent_variable: ::core::option::Option<CurveVariable>,
    #[prost(message, optional, tag = "2")]
    pub degree: ::core::option::Option<IntegerConstant>,
    #[prost(message, optional, tag = "3")]
    pub intercept: ::core::option::Option<DoubleConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomCurveModel {
    #[prost(message, optional, tag = "1")]
    pub formula: ::core::option::Option<StringConstant>,
    #[prost(map = "string, message", tag = "2")]
    pub variables: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        CurveVariable,
    >,
    #[prost(map = "string, message", tag = "3")]
    pub parameters: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        DoubleConstant,
    >,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericAbsoluteTimestampExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
    #[prost(enumeration = "super::super::types::time::TimeUnit", tag = "2")]
    pub unit: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericTimeDifferenceExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
    #[prost(enumeration = "super::super::types::time::TimeUnit", optional, tag = "2")]
    pub unit: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericReduceUnderRangesExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, boxed, tag = "2")]
    pub ranges: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
    #[prost(message, optional, tag = "3")]
    pub reduction: ::core::option::Option<NumericReduction>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericLogMatchesExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogExpression>>,
    #[prost(message, optional, tag = "2")]
    pub predicate: ::core::option::Option<LogPredicate>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericCountDuplicatesExpression {
    #[prost(message, repeated, tag = "1")]
    pub inputs: ::prost::alloc::vec::Vec<CategoricalExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericCategoricalMappingExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
    #[prost(map = "string, message", tag = "2")]
    pub mapping: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        DoubleConstant,
    >,
    #[prost(message, optional, tag = "3")]
    pub default_value: ::core::option::Option<DoubleConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericStructFieldExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
    #[prost(message, repeated, tag = "2")]
    pub path: ::prost::alloc::vec::Vec<StringConstant>,
    #[prost(
        enumeration = "super::super::types::series::SeriesDataType",
        optional,
        tag = "3"
    )]
    pub numeric_type: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericRangeFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, boxed, tag = "2")]
    pub ranges: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericGroupWithinRangesExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, boxed, tag = "2")]
    pub ranges: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
    #[prost(message, optional, tag = "3")]
    pub reduction: ::core::option::Option<NumericReduction>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericAggregationExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<AggregationInput>>,
    #[prost(message, optional, tag = "2")]
    pub reduction: ::core::option::Option<NumericReduction>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AggregationInput {
    #[prost(oneof = "aggregation_input::Kind", tags = "1, 2, 3")]
    pub kind: ::core::option::Option<aggregation_input::Kind>,
}
/// Nested message and enum types in `AggregationInput`.
pub mod aggregation_input {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        TimeWindow(::prost::alloc::boxed::Box<super::TimeWindowAggregation>),
        #[prost(message, tag = "2")]
        PointWindow(::prost::alloc::boxed::Box<super::PointWindowAggregation>),
        #[prost(message, tag = "3")]
        Grouping(::prost::alloc::boxed::Box<super::GroupedSeriesAggregation>),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TimeWindowAggregation {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
    #[prost(message, optional, tag = "2")]
    pub window: ::core::option::Option<DurationExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PointWindowAggregation {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
    #[prost(message, optional, tag = "2")]
    pub points: ::core::option::Option<IntegerConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GroupedSeriesAggregation {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
    #[prost(message, optional, tag = "2")]
    pub keys: ::core::option::Option<AggregationGroupingKeys>,
    #[prost(message, optional, tag = "3")]
    pub timestamp: ::core::option::Option<AggregationTimestamp>,
    #[prost(bool, tag = "4")]
    pub use_context_alignment: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AggregationGroupingKeys {
    #[prost(oneof = "aggregation_grouping_keys::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<aggregation_grouping_keys::Kind>,
}
/// Nested message and enum types in `AggregationGroupingKeys`.
pub mod aggregation_grouping_keys {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Current(super::CurrentGroupingKeys),
        #[prost(message, tag = "2")]
        Subset(super::TagKeySet),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CurrentGroupingKeys {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AggregationTimestamp {
    #[prost(oneof = "aggregation_timestamp::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<aggregation_timestamp::Kind>,
}
/// Nested message and enum types in `AggregationTimestamp`.
pub mod aggregation_timestamp {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Current(super::CurrentTimestamps),
        #[prost(message, tag = "2")]
        Every(super::DurationExpression),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CurrentTimestamps {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericRangeDurationExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
    #[prost(enumeration = "UnboundedRangePolicy", tag = "2")]
    pub unbounded: i32,
    #[prost(enumeration = "super::super::types::time::TimeUnit", optional, tag = "3")]
    pub unit: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScalarUdfExpression {
    #[prost(message, repeated, tag = "1")]
    pub inputs: ::prost::alloc::vec::Vec<SeriesExpression>,
    #[prost(message, optional, tag = "2")]
    pub source: ::core::option::Option<super::super::modules::v1::UdfSource>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericArrayIndexExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<
        ::prost::alloc::boxed::Box<NumericArrayExpression>,
    >,
    #[prost(message, optional, tag = "2")]
    pub index: ::core::option::Option<IntegerConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericIntervalTagsExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, boxed, tag = "2")]
    pub intervals: ::core::option::Option<
        ::prost::alloc::boxed::Box<IntervalSourceExpression>,
    >,
    #[prost(message, optional, tag = "3")]
    pub time_shift: ::core::option::Option<IntervalTimeShift>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntervalSourceExpression {
    #[prost(oneof = "interval_source_expression::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<interval_source_expression::Kind>,
}
/// Nested message and enum types in `IntervalSourceExpression`.
pub mod interval_source_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Events(super::EventIntervals),
        #[prost(message, tag = "2")]
        Ranges(::prost::alloc::boxed::Box<super::RangeIntervals>),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventIntervals {
    #[prost(message, optional, tag = "1")]
    pub query: ::core::option::Option<EventPredicateExpression>,
    #[prost(message, repeated, tag = "2")]
    pub tags: ::prost::alloc::vec::Vec<EventIntervalTag>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RangeIntervals {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
    #[prost(message, repeated, tag = "2")]
    pub tags: ::prost::alloc::vec::Vec<RangeIntervalTag>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventIntervalTag {
    #[prost(oneof = "event_interval_tag::Kind", tags = "1, 2, 3, 4, 5")]
    pub kind: ::core::option::Option<event_interval_tag::Kind>,
}
/// Nested message and enum types in `EventIntervalTag`.
pub mod event_interval_tag {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        IntervalIndex(super::IntervalIndexTag),
        #[prost(message, tag = "2")]
        IntervalStart(super::IntervalStartTag),
        #[prost(message, tag = "3")]
        EventLevel(super::EventLevelTag),
        #[prost(message, tag = "4")]
        EventProperty(super::StringConstant),
        #[prost(message, tag = "5")]
        EventLabel(super::StringConstant),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct RangeIntervalTag {
    #[prost(oneof = "range_interval_tag::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<range_interval_tag::Kind>,
}
/// Nested message and enum types in `RangeIntervalTag`.
pub mod range_interval_tag {
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        IntervalIndex(super::IntervalIndexTag),
        #[prost(message, tag = "2")]
        IntervalStart(super::IntervalStartTag),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct IntervalIndexTag {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct IntervalStartTag {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct EventLevelTag {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntervalTimeShift {
    #[prost(oneof = "interval_time_shift::Kind", tags = "1, 2, 3")]
    pub kind: ::core::option::Option<interval_time_shift::Kind>,
}
/// Nested message and enum types in `IntervalTimeShift`.
pub mod interval_time_shift {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        IntervalStart(super::IntervalStartAnchor),
        #[prost(message, tag = "2")]
        IntervalEnd(super::IntervalEndAnchor),
        #[prost(message, tag = "3")]
        Event(super::EventOrdinalSelection),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct IntervalStartAnchor {}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct IntervalEndAnchor {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventOrdinalSelection {
    #[prost(message, optional, tag = "1")]
    pub query: ::core::option::Option<EventPredicateExpression>,
    #[prost(message, optional, tag = "2")]
    pub index: ::core::option::Option<IntegerConstant>,
    #[prost(enumeration = "ChronologicalOrder", optional, tag = "3")]
    pub order: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RangeOrdinalSelection {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
    #[prost(message, optional, tag = "2")]
    pub index: ::core::option::Option<IntegerConstant>,
    #[prost(enumeration = "ChronologicalOrder", optional, tag = "3")]
    pub order: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunAnchorExpression {
    #[prost(oneof = "run_anchor_expression::Kind", tags = "1, 2, 3, 4")]
    pub kind: ::core::option::Option<run_anchor_expression::Kind>,
}
/// Nested message and enum types in `RunAnchorExpression`.
pub mod run_anchor_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        IntervalStart(super::IntervalStartAnchor),
        #[prost(message, tag = "2")]
        IntervalEnd(super::IntervalEndAnchor),
        #[prost(message, tag = "3")]
        Event(super::EventOrdinalSelection),
        #[prost(message, tag = "4")]
        Ranges(::prost::alloc::boxed::Box<super::RangeOrdinalSelection>),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatasetAnchorAlignment {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
    #[prost(message, optional, boxed, tag = "2")]
    pub anchor: ::core::option::Option<::prost::alloc::boxed::Box<RunAnchorExpression>>,
    #[prost(bool, tag = "3")]
    pub align_to_earliest: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalExpression {
    #[prost(
        oneof = "categorical_expression::Kind",
        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23"
    )]
    pub kind: ::core::option::Option<categorical_expression::Kind>,
}
/// Nested message and enum types in `CategoricalExpression`.
pub mod categorical_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Reference(super::TimeSeriesReference),
        #[prost(message, tag = "2")]
        ChannelSelection(super::ChannelSelection),
        #[prost(message, tag = "3")]
        ModuleFunction(super::ModuleFunctionExpression),
        #[prost(message, tag = "4")]
        SeriesSelection(::prost::alloc::boxed::Box<super::SeriesSelection>),
        #[prost(message, tag = "5")]
        ResourceProperty(::prost::alloc::boxed::Box<super::ResourcePropertySelection>),
        #[prost(message, tag = "6")]
        DuplicateTimestampAggregation(
            ::prost::alloc::boxed::Box<
                super::CategoricalDuplicateTimestampAggregationExpression,
            >,
        ),
        #[prost(message, tag = "7")]
        Resample(::prost::alloc::boxed::Box<super::CategoricalResampleExpression>),
        #[prost(message, tag = "8")]
        ResampleV2(::prost::alloc::boxed::Box<super::CategoricalResampleV2Expression>),
        #[prost(message, tag = "9")]
        NthPointDownsample(
            ::prost::alloc::boxed::Box<super::CategoricalNthPointDownsampleExpression>,
        ),
        #[prost(message, tag = "10")]
        TimeRangeFilter(
            ::prost::alloc::boxed::Box<super::CategoricalTimeRangeFilterExpression>,
        ),
        #[prost(message, tag = "11")]
        TimeShift(::prost::alloc::boxed::Box<super::CategoricalTimeShiftExpression>),
        #[prost(message, tag = "12")]
        TimeShiftV2(::prost::alloc::boxed::Box<super::CategoricalTimeShiftV2Expression>),
        #[prost(message, tag = "13")]
        Union(super::CategoricalUnionExpression),
        #[prost(message, tag = "14")]
        RangeFilter(::prost::alloc::boxed::Box<super::CategoricalRangeFilterExpression>),
        #[prost(message, tag = "15")]
        NumericMapping(
            ::prost::alloc::boxed::Box<super::CategoricalNumericMappingExpression>,
        ),
        #[prost(message, tag = "16")]
        ArrayIndex(::prost::alloc::boxed::Box<super::CategoricalArrayIndexExpression>),
        #[prost(message, tag = "17")]
        StructField(::prost::alloc::boxed::Box<super::CategoricalStructFieldExpression>),
        #[prost(message, tag = "18")]
        Events(super::CategoricalEventsExpression),
        #[prost(message, tag = "19")]
        Aggregation(::prost::alloc::boxed::Box<super::CategoricalAggregationExpression>),
        #[prost(message, tag = "20")]
        TagFilter(::prost::alloc::boxed::Box<super::CategoricalTagFilterExpression>),
        #[prost(message, tag = "21")]
        TagSelection(
            ::prost::alloc::boxed::Box<super::CategoricalTagSelectionExpression>,
        ),
        #[prost(message, tag = "22")]
        ScalarUdf(super::ScalarUdfExpression),
        #[prost(message, tag = "23")]
        ToStartOfInterval(
            ::prost::alloc::boxed::Box<super::CategoricalToStartOfIntervalExpression>,
        ),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalDuplicateTimestampAggregationExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
    #[prost(message, optional, tag = "2")]
    pub reduction: ::core::option::Option<CategoricalReduction>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalResampleExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<DurationConstant>,
    #[prost(message, optional, tag = "3")]
    pub fill: ::core::option::Option<CategoricalResampleFill>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalResampleV2Expression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<DurationExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalNthPointDownsampleExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
    #[prost(message, optional, tag = "2")]
    pub every_nth: ::core::option::Option<IntegerConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalTimeRangeFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
    #[prost(message, optional, tag = "2")]
    pub start: ::core::option::Option<TimestampConstant>,
    #[prost(message, optional, tag = "3")]
    pub end: ::core::option::Option<TimestampConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalTimeShiftExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
    #[prost(message, optional, tag = "2")]
    pub duration: ::core::option::Option<DurationConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalTimeShiftV2Expression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
    #[prost(message, optional, tag = "2")]
    pub duration: ::core::option::Option<DurationExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalUnionExpression {
    #[prost(message, repeated, tag = "1")]
    pub inputs: ::prost::alloc::vec::Vec<CategoricalExpression>,
    #[prost(enumeration = "CategoricalMergeOperation", tag = "2")]
    pub operation: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalRangeFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
    #[prost(message, optional, boxed, tag = "2")]
    pub ranges: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalNumericMappingExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, repeated, tag = "2")]
    pub mapping: ::prost::alloc::vec::Vec<NumericCategoricalInterval>,
    #[prost(message, optional, tag = "3")]
    pub default_value: ::core::option::Option<StringConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericCategoricalInterval {
    #[prost(message, optional, tag = "1")]
    pub start: ::core::option::Option<DoubleConstant>,
    #[prost(message, optional, tag = "2")]
    pub end: ::core::option::Option<DoubleConstant>,
    #[prost(message, optional, tag = "3")]
    pub value: ::core::option::Option<StringConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalArrayIndexExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<
        ::prost::alloc::boxed::Box<CategoricalArrayExpression>,
    >,
    #[prost(message, optional, tag = "2")]
    pub index: ::core::option::Option<IntegerConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalStructFieldExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
    #[prost(message, repeated, tag = "2")]
    pub path: ::prost::alloc::vec::Vec<StringConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalEventsExpression {
    #[prost(message, optional, tag = "1")]
    pub query: ::core::option::Option<EventPredicateExpression>,
    #[prost(oneof = "categorical_events_expression::Value", tags = "2, 3")]
    pub value: ::core::option::Option<categorical_events_expression::Value>,
}
/// Nested message and enum types in `CategoricalEventsExpression`.
pub mod categorical_events_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(message, tag = "2")]
        Property(super::StringConstant),
        #[prost(message, tag = "3")]
        Level(super::EventLevelValue),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct EventLevelValue {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalAggregationExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<AggregationInput>>,
    #[prost(message, optional, tag = "2")]
    pub reduction: ::core::option::Option<CategoricalReduction>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalTagFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
    #[prost(message, optional, tag = "2")]
    pub predicate: ::core::option::Option<TagPredicateExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalTagSelectionExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
    #[prost(message, optional, tag = "2")]
    pub keys: ::core::option::Option<TagKeySet>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalToStartOfIntervalExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<DurationExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BooleanExpression {
    #[prost(oneof = "boolean_expression::Kind", tags = "1, 2")]
    pub kind: ::core::option::Option<boolean_expression::Kind>,
}
/// Nested message and enum types in `BooleanExpression`.
pub mod boolean_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Comparison(::prost::alloc::boxed::Box<super::ComparisonExpression>),
        #[prost(message, tag = "2")]
        Logical(::prost::alloc::boxed::Box<super::LogicalExpression>),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericUnaryExpression {
    #[prost(enumeration = "UnaryNumericOperation", tag = "1")]
    pub operation: i32,
    #[prost(message, optional, boxed, tag = "2")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericBinaryExpression {
    #[prost(enumeration = "BinaryNumericOperation", tag = "1")]
    pub operation: i32,
    #[prost(message, optional, boxed, tag = "2")]
    pub left: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, boxed, tag = "3")]
    pub right: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[deprecated]
    #[prost(message, optional, tag = "4")]
    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericNaryExpression {
    #[prost(enumeration = "NaryNumericOperation", tag = "1")]
    pub operation: i32,
    #[prost(message, repeated, tag = "2")]
    pub inputs: ::prost::alloc::vec::Vec<NumericExpression>,
    #[deprecated]
    #[prost(message, optional, tag = "3")]
    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericBitwiseExpression {
    #[prost(enumeration = "BitwiseOperation", tag = "1")]
    pub operation: i32,
    #[prost(message, optional, boxed, tag = "2")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "3")]
    pub operand: ::core::option::Option<IntegerConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericConditionalExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub condition: ::core::option::Option<::prost::alloc::boxed::Box<BooleanExpression>>,
    #[prost(message, optional, boxed, tag = "2")]
    pub true_value: ::core::option::Option<
        ::prost::alloc::boxed::Box<NumericExpression>,
    >,
    #[prost(message, optional, boxed, tag = "3")]
    pub false_value: ::core::option::Option<
        ::prost::alloc::boxed::Box<NumericExpression>,
    >,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ComparisonExpression {
    #[prost(enumeration = "ComparisonOperation", tag = "1")]
    pub operation: i32,
    #[prost(message, optional, boxed, tag = "2")]
    pub left: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, boxed, tag = "3")]
    pub right: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogicalExpression {
    #[prost(enumeration = "LogicalOperation", tag = "1")]
    pub operation: i32,
    #[prost(message, optional, boxed, tag = "2")]
    pub left: ::core::option::Option<::prost::alloc::boxed::Box<BooleanExpression>>,
    #[prost(message, optional, boxed, tag = "3")]
    pub right: ::core::option::Option<::prost::alloc::boxed::Box<BooleanExpression>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InterpolationConfiguration {
    #[prost(oneof = "interpolation_configuration::Kind", tags = "1")]
    pub kind: ::core::option::Option<interpolation_configuration::Kind>,
}
/// Nested message and enum types in `InterpolationConfiguration`.
pub mod interpolation_configuration {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        ForwardFill(super::ForwardFillInterpolation),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ForwardFillInterpolation {
    #[prost(message, optional, tag = "1")]
    pub max_fill_duration: ::core::option::Option<DurationConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericCumulativeSumExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub start: ::core::option::Option<TimestampConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericDerivativeExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(enumeration = "super::super::types::time::TimeUnit", optional, tag = "2")]
    pub time_unit: ::core::option::Option<i32>,
    #[prost(enumeration = "NegativeValuePolicy", optional, tag = "3")]
    pub negative_value_policy: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericIntegralExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub start: ::core::option::Option<TimestampConstant>,
    #[prost(enumeration = "super::super::types::time::TimeUnit", optional, tag = "3")]
    pub time_unit: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericTimeRangeFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub start: ::core::option::Option<TimestampConstant>,
    #[prost(message, optional, tag = "3")]
    pub end: ::core::option::Option<TimestampConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericTimeShiftExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub duration: ::core::option::Option<DurationConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericValueDifferenceExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(enumeration = "NegativeValuePolicy", optional, tag = "2")]
    pub negative_value_policy: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericPhaseUnwrapExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub period: ::core::option::Option<DoubleConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericPointLimitExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub count: ::core::option::Option<IntegerConstant>,
    #[prost(enumeration = "PointLimitOrder", tag = "3")]
    pub order: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericNthPointDownsampleExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub n: ::core::option::Option<IntegerConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericLargestTriangleThreeBucketsExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub max_points: ::core::option::Option<IntegerConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericConditionFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, boxed, tag = "2")]
    pub condition: ::core::option::Option<::prost::alloc::boxed::Box<BooleanExpression>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericThresholdFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub threshold: ::core::option::Option<DoubleConstant>,
    #[prost(enumeration = "ComparisonOperation", tag = "3")]
    pub operation: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericApproximateFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub threshold: ::core::option::Option<DoubleConstant>,
    #[prost(message, optional, tag = "3")]
    pub tolerance: ::core::option::Option<DoubleConstant>,
    #[prost(enumeration = "ApproximateComparisonOperation", tag = "4")]
    pub operation: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericSignalFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub configuration: ::core::option::Option<SignalFilterConfiguration>,
    #[prost(message, optional, tag = "3")]
    pub order: ::core::option::Option<IntegerConstant>,
    #[prost(message, optional, tag = "4")]
    pub sampling_frequency: ::core::option::Option<DoubleConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericUnitConversionExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(string, tag = "2")]
    pub output_unit: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericUnitOverrideExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(string, optional, tag = "2")]
    pub unit: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericZScoreExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, repeated, tag = "2")]
    pub group_by_tags: ::prost::alloc::vec::Vec<StringConstant>,
    #[deprecated]
    #[prost(message, optional, tag = "3")]
    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericUnionExpression {
    #[prost(message, repeated, tag = "1")]
    pub inputs: ::prost::alloc::vec::Vec<NumericExpression>,
    #[deprecated]
    #[prost(enumeration = "DuplicateMergeOperation", optional, tag = "2")]
    pub duplicate_merge_operation: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericDropNanExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericTimeShiftV2Expression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub duration: ::core::option::Option<DurationExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericResampleV2Expression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<DurationExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericToStartOfIntervalExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<DurationExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericScalarTransformExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(oneof = "numeric_scalar_transform_expression::Transform", tags = "2, 3")]
    pub transform: ::core::option::Option<
        numeric_scalar_transform_expression::Transform,
    >,
}
/// Nested message and enum types in `NumericScalarTransformExpression`.
pub mod numeric_scalar_transform_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Transform {
        #[prost(message, tag = "2")]
        Offset(super::DoubleConstant),
        #[prost(message, tag = "3")]
        Scale(super::ScalingFactor),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericArithmeticExpression {
    #[prost(map = "string, message", tag = "1")]
    pub inputs: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        NumericExpression,
    >,
    #[prost(string, tag = "2")]
    pub formula: ::prost::alloc::string::String,
    #[deprecated]
    #[prost(message, optional, tag = "3")]
    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericFormulaFilterExpression {
    #[prost(string, tag = "1")]
    pub filtered_input_name: ::prost::alloc::string::String,
    #[prost(map = "string, message", tag = "2")]
    pub inputs: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        NumericExpression,
    >,
    #[prost(string, tag = "3")]
    pub formula: ::prost::alloc::string::String,
    #[deprecated]
    #[prost(message, optional, tag = "4")]
    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericLiteralBitwiseExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub function: ::core::option::Option<LiteralBitFunction>,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct LiteralBitFunction {
    #[prost(oneof = "literal_bit_function::Kind", tags = "1, 2, 3")]
    pub kind: ::core::option::Option<literal_bit_function::Kind>,
}
/// Nested message and enum types in `LiteralBitFunction`.
pub mod literal_bit_function {
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Bitwise(super::LiteralBitwiseFunction),
        #[prost(message, tag = "2")]
        Shift(super::LiteralShiftFunction),
        #[prost(message, tag = "3")]
        BitTest(super::BitTestIndex),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct LiteralBitwiseFunction {
    #[prost(enumeration = "LiteralBitwiseOperation", tag = "1")]
    pub operation: i32,
    #[prost(int64, tag = "2")]
    pub operand: i64,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct LiteralShiftFunction {
    #[prost(enumeration = "ShiftDirection", tag = "1")]
    pub direction: i32,
    #[prost(int32, tag = "2")]
    pub distance: i32,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct BitTestIndex {
    #[prost(int32, tag = "1")]
    pub index: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericResampleExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<DurationConstant>,
    #[prost(message, optional, tag = "3")]
    pub fill: ::core::option::Option<ResampleFill>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericRefpropExpression {
    #[prost(message, repeated, tag = "1")]
    pub inputs: ::prost::alloc::vec::Vec<RefpropInput>,
    #[prost(enumeration = "RefpropProperty", tag = "2")]
    pub output_property: i32,
    #[prost(enumeration = "RefpropSubstance", tag = "3")]
    pub substance: i32,
    #[deprecated]
    #[prost(message, optional, tag = "4")]
    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RefpropInput {
    #[prost(enumeration = "RefpropProperty", tag = "1")]
    pub property: i32,
    #[prost(message, optional, tag = "2")]
    pub value: ::core::option::Option<NumericExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericRollingAggregationExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub window: ::core::option::Option<DurationConstant>,
    #[prost(message, optional, tag = "3")]
    pub reduction: ::core::option::Option<NumericReduction>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericDuplicateTimestampAggregationExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub reduction: ::core::option::Option<NumericReduction>,
    #[prost(message, repeated, tag = "3")]
    pub grouping_keys: ::prost::alloc::vec::Vec<StringConstant>,
    #[prost(bool, optional, tag = "4")]
    pub aggregate_across_all_series: ::core::option::Option<bool>,
    #[deprecated]
    #[prost(message, optional, tag = "5")]
    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericTagFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub predicate: ::core::option::Option<TagPredicateExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericTagSelectionExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, repeated, tag = "2")]
    pub retained_tag_keys: ::prost::alloc::vec::Vec<StringConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericArrayExpression {
    #[prost(
        oneof = "numeric_array_expression::Kind",
        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9"
    )]
    pub kind: ::core::option::Option<numeric_array_expression::Kind>,
}
/// Nested message and enum types in `NumericArrayExpression`.
pub mod numeric_array_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Reference(super::TimeSeriesReference),
        #[prost(message, tag = "2")]
        ChannelSelection(super::ChannelSelection),
        #[prost(message, tag = "3")]
        ModuleFunction(super::ModuleFunctionExpression),
        #[prost(message, tag = "4")]
        SeriesSelection(::prost::alloc::boxed::Box<super::SeriesSelection>),
        #[prost(message, tag = "5")]
        StructField(
            ::prost::alloc::boxed::Box<super::NumericArrayStructFieldExpression>,
        ),
        #[prost(message, tag = "6")]
        TimeShift(::prost::alloc::boxed::Box<super::NumericArrayTimeShiftExpression>),
        #[prost(message, tag = "7")]
        ToStartOfInterval(
            ::prost::alloc::boxed::Box<super::NumericArrayToStartOfIntervalExpression>,
        ),
        #[prost(message, tag = "8")]
        TagFilter(::prost::alloc::boxed::Box<super::NumericArrayTagFilterExpression>),
        #[prost(message, tag = "9")]
        TagSelection(
            ::prost::alloc::boxed::Box<super::NumericArrayTagSelectionExpression>,
        ),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericArrayStructFieldExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
    #[prost(message, repeated, tag = "2")]
    pub path: ::prost::alloc::vec::Vec<StringConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericArrayTimeShiftExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<
        ::prost::alloc::boxed::Box<NumericArrayExpression>,
    >,
    #[prost(message, optional, tag = "2")]
    pub duration: ::core::option::Option<DurationConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericArrayToStartOfIntervalExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<
        ::prost::alloc::boxed::Box<NumericArrayExpression>,
    >,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<DurationExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericArrayTagFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<
        ::prost::alloc::boxed::Box<NumericArrayExpression>,
    >,
    #[prost(message, optional, tag = "2")]
    pub predicate: ::core::option::Option<TagPredicateExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericArrayTagSelectionExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<
        ::prost::alloc::boxed::Box<NumericArrayExpression>,
    >,
    #[prost(message, optional, tag = "2")]
    pub keys: ::core::option::Option<TagKeySet>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalArrayExpression {
    #[prost(
        oneof = "categorical_array_expression::Kind",
        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9"
    )]
    pub kind: ::core::option::Option<categorical_array_expression::Kind>,
}
/// Nested message and enum types in `CategoricalArrayExpression`.
pub mod categorical_array_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Reference(super::TimeSeriesReference),
        #[prost(message, tag = "2")]
        ChannelSelection(super::ChannelSelection),
        #[prost(message, tag = "3")]
        ModuleFunction(super::ModuleFunctionExpression),
        #[prost(message, tag = "4")]
        SeriesSelection(::prost::alloc::boxed::Box<super::SeriesSelection>),
        #[prost(message, tag = "5")]
        StructField(
            ::prost::alloc::boxed::Box<super::CategoricalArrayStructFieldExpression>,
        ),
        #[prost(message, tag = "6")]
        TimeShift(
            ::prost::alloc::boxed::Box<super::CategoricalArrayTimeShiftExpression>,
        ),
        #[prost(message, tag = "7")]
        ToStartOfInterval(
            ::prost::alloc::boxed::Box<
                super::CategoricalArrayToStartOfIntervalExpression,
            >,
        ),
        #[prost(message, tag = "8")]
        TagFilter(
            ::prost::alloc::boxed::Box<super::CategoricalArrayTagFilterExpression>,
        ),
        #[prost(message, tag = "9")]
        TagSelection(
            ::prost::alloc::boxed::Box<super::CategoricalArrayTagSelectionExpression>,
        ),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalArrayStructFieldExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
    #[prost(message, repeated, tag = "2")]
    pub path: ::prost::alloc::vec::Vec<StringConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalArrayTimeShiftExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<
        ::prost::alloc::boxed::Box<CategoricalArrayExpression>,
    >,
    #[prost(message, optional, tag = "2")]
    pub duration: ::core::option::Option<DurationConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalArrayToStartOfIntervalExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<
        ::prost::alloc::boxed::Box<CategoricalArrayExpression>,
    >,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<DurationExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalArrayTagFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<
        ::prost::alloc::boxed::Box<CategoricalArrayExpression>,
    >,
    #[prost(message, optional, tag = "2")]
    pub predicate: ::core::option::Option<TagPredicateExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalArrayTagSelectionExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<
        ::prost::alloc::boxed::Box<CategoricalArrayExpression>,
    >,
    #[prost(message, optional, tag = "2")]
    pub keys: ::core::option::Option<TagKeySet>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StructExpression {
    #[prost(oneof = "struct_expression::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10")]
    pub kind: ::core::option::Option<struct_expression::Kind>,
}
/// Nested message and enum types in `StructExpression`.
pub mod struct_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Reference(super::TimeSeriesReference),
        #[prost(message, tag = "2")]
        ChannelSelection(super::ChannelSelection),
        #[prost(message, tag = "3")]
        ModuleFunction(super::ModuleFunctionExpression),
        #[prost(message, tag = "4")]
        SeriesSelection(::prost::alloc::boxed::Box<super::SeriesSelection>),
        #[prost(message, tag = "5")]
        Combine(super::StructCombineExpression),
        #[prost(message, tag = "6")]
        StructField(::prost::alloc::boxed::Box<super::StructFieldExpression>),
        #[prost(message, tag = "7")]
        TimeShift(::prost::alloc::boxed::Box<super::StructTimeShiftExpression>),
        #[prost(message, tag = "8")]
        ToStartOfInterval(
            ::prost::alloc::boxed::Box<super::StructToStartOfIntervalExpression>,
        ),
        #[prost(message, tag = "9")]
        TagFilter(::prost::alloc::boxed::Box<super::StructTagFilterExpression>),
        #[prost(message, tag = "10")]
        TagSelection(::prost::alloc::boxed::Box<super::StructTagSelectionExpression>),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StructFieldExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
    #[prost(message, repeated, tag = "2")]
    pub path: ::prost::alloc::vec::Vec<StringConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StructTimeShiftExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
    #[prost(message, optional, tag = "2")]
    pub duration: ::core::option::Option<DurationConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StructToStartOfIntervalExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<DurationExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StructTagFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
    #[prost(message, optional, tag = "2")]
    pub predicate: ::core::option::Option<TagPredicateExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StructTagSelectionExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
    #[prost(message, optional, tag = "2")]
    pub keys: ::core::option::Option<TagKeySet>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogExpression {
    #[prost(oneof = "log_expression::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10")]
    pub kind: ::core::option::Option<log_expression::Kind>,
}
/// Nested message and enum types in `LogExpression`.
pub mod log_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(message, tag = "1")]
        Reference(super::TimeSeriesReference),
        #[prost(message, tag = "2")]
        ChannelSelection(super::ChannelSelection),
        #[prost(message, tag = "3")]
        ModuleFunction(super::ModuleFunctionExpression),
        #[prost(message, tag = "4")]
        SeriesSelection(::prost::alloc::boxed::Box<super::SeriesSelection>),
        #[prost(message, tag = "5")]
        Concatenate(super::LogConcatenateExpression),
        #[prost(message, tag = "6")]
        Filter(::prost::alloc::boxed::Box<super::LogFilterExpression>),
        #[prost(message, tag = "7")]
        TimeShift(::prost::alloc::boxed::Box<super::LogTimeShiftExpression>),
        #[prost(message, tag = "8")]
        ToStartOfInterval(
            ::prost::alloc::boxed::Box<super::LogToStartOfIntervalExpression>,
        ),
        #[prost(message, tag = "9")]
        TagFilter(::prost::alloc::boxed::Box<super::LogTagFilterExpression>),
        #[prost(message, tag = "10")]
        TagSelection(::prost::alloc::boxed::Box<super::LogTagSelectionExpression>),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogTimeShiftExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogExpression>>,
    #[prost(message, optional, tag = "2")]
    pub duration: ::core::option::Option<DurationConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogToStartOfIntervalExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogExpression>>,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<DurationExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogTagFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogExpression>>,
    #[prost(message, optional, tag = "2")]
    pub predicate: ::core::option::Option<TagPredicateExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogTagSelectionExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogExpression>>,
    #[prost(message, optional, tag = "2")]
    pub keys: ::core::option::Option<TagKeySet>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StructCombineExpression {
    #[prost(map = "string, message", tag = "1")]
    pub fields: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        SeriesExpression,
    >,
    #[prost(message, optional, tag = "2")]
    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogConcatenateExpression {
    #[prost(message, repeated, tag = "1")]
    pub inputs: ::prost::alloc::vec::Vec<LogExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogFilterExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogExpression>>,
    #[prost(message, optional, tag = "2")]
    pub predicate: ::core::option::Option<LogPredicate>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RangeExpression {
    #[prost(
        oneof = "range_expression::Kind",
        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21"
    )]
    pub kind: ::core::option::Option<range_expression::Kind>,
}
/// Nested message and enum types in `RangeExpression`.
pub mod range_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(string, tag = "1")]
        VariableName(::prost::alloc::string::String),
        #[prost(message, tag = "2")]
        ModuleFunction(super::ModuleFunctionExpression),
        #[prost(message, tag = "3")]
        Literal(super::LiteralRangeCollection),
        #[prost(message, tag = "4")]
        Events(super::EventPredicateExpression),
        #[prost(message, tag = "5")]
        BooleanCondition(::prost::alloc::boxed::Box<super::BooleanRangeExpression>),
        #[prost(message, tag = "6")]
        NumericThreshold(::prost::alloc::boxed::Box<super::NumericThresholdRanges>),
        #[prost(message, tag = "7")]
        NumericBounds(::prost::alloc::boxed::Box<super::NumericBoundsRanges>),
        #[prost(message, tag = "8")]
        CategoricalMembership(
            ::prost::alloc::boxed::Box<super::CategoricalMembershipRanges>,
        ),
        #[prost(message, tag = "9")]
        NumericEquality(super::NumericEqualityRanges),
        #[prost(message, tag = "10")]
        CategoricalEquality(super::CategoricalEqualityRanges),
        #[prost(message, tag = "11")]
        NumericCrossover(::prost::alloc::boxed::Box<super::NumericCrossoverRanges>),
        #[prost(message, tag = "12")]
        OnChange(::prost::alloc::boxed::Box<super::SeriesChangeRanges>),
        #[prost(message, tag = "13")]
        Staleness(::prost::alloc::boxed::Box<super::SeriesStalenessRanges>),
        #[prost(message, tag = "14")]
        DurationFilter(::prost::alloc::boxed::Box<super::RangeDurationFilter>),
        #[prost(message, tag = "15")]
        Stability(::prost::alloc::boxed::Box<super::NumericStabilityRanges>),
        #[prost(message, tag = "16")]
        Extrema(::prost::alloc::boxed::Box<super::NumericExtremaRanges>),
        #[prost(message, tag = "17")]
        Intersection(super::RangeExpressionCollection),
        #[prost(message, tag = "18")]
        Union(super::RangeExpressionCollection),
        #[prost(message, tag = "19")]
        Complement(::prost::alloc::boxed::Box<super::RangeExpression>),
        #[prost(message, tag = "20")]
        Padding(::prost::alloc::boxed::Box<super::RangePaddingExpression>),
        #[prost(message, tag = "21")]
        Statistics(::prost::alloc::boxed::Box<super::RangeStatisticsExpression>),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LiteralRangeCollection {
    #[prost(message, repeated, tag = "1")]
    pub ranges: ::prost::alloc::vec::Vec<LiteralRange>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LiteralRange {
    #[prost(message, optional, tag = "1")]
    pub start: ::core::option::Option<TimestampConstant>,
    #[prost(message, optional, tag = "2")]
    pub end: ::core::option::Option<TimestampConstant>,
    #[prost(message, optional, tag = "3")]
    pub grouping: ::core::option::Option<TagGrouping>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BooleanRangeExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<BooleanExpression>>,
    #[prost(message, optional, tag = "2")]
    pub persistence: ::core::option::Option<RangePersistence>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericThresholdRanges {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(enumeration = "ComparisonOperation", tag = "2")]
    pub comparison: i32,
    #[prost(message, optional, tag = "3")]
    pub threshold: ::core::option::Option<DoubleConstant>,
    #[prost(message, optional, tag = "4")]
    pub tolerance: ::core::option::Option<DoubleConstant>,
    #[prost(message, optional, tag = "5")]
    pub persistence: ::core::option::Option<RangePersistence>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericBoundsRanges {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub lower: ::core::option::Option<DoubleConstant>,
    #[prost(message, optional, tag = "3")]
    pub upper: ::core::option::Option<DoubleConstant>,
    #[prost(enumeration = "NumericBoundsCondition", tag = "4")]
    pub condition: i32,
    #[prost(message, optional, tag = "5")]
    pub persistence: ::core::option::Option<RangePersistence>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalMembershipRanges {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
    #[prost(message, optional, tag = "2")]
    pub values: ::core::option::Option<ParameterizedStringSet>,
    #[prost(enumeration = "CategoricalMembershipOperation", tag = "3")]
    pub operation: i32,
    #[prost(message, optional, tag = "4")]
    pub persistence: ::core::option::Option<RangePersistence>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericEqualityRanges {
    #[prost(message, repeated, tag = "1")]
    pub inputs: ::prost::alloc::vec::Vec<NumericExpression>,
    #[prost(enumeration = "SeriesEqualityMode", tag = "2")]
    pub mode: i32,
    #[prost(message, optional, tag = "3")]
    pub tolerance: ::core::option::Option<DoubleConstant>,
    #[prost(message, optional, tag = "4")]
    pub persistence: ::core::option::Option<RangePersistence>,
    #[deprecated]
    #[prost(message, optional, tag = "5")]
    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CategoricalEqualityRanges {
    #[prost(message, repeated, tag = "1")]
    pub inputs: ::prost::alloc::vec::Vec<CategoricalExpression>,
    #[prost(enumeration = "SeriesEqualityMode", tag = "2")]
    pub mode: i32,
    #[prost(message, optional, tag = "3")]
    pub persistence: ::core::option::Option<RangePersistence>,
    #[deprecated]
    #[prost(message, optional, tag = "4")]
    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericCrossoverRanges {
    #[prost(message, optional, boxed, tag = "1")]
    pub left: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, boxed, tag = "2")]
    pub right: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SeriesChangeRanges {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SeriesStalenessRanges {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
    #[prost(message, optional, tag = "2")]
    pub threshold: ::core::option::Option<DurationInput>,
    #[prost(message, optional, tag = "3")]
    pub start: ::core::option::Option<TimestampConstant>,
    #[deprecated]
    #[prost(message, optional, tag = "4")]
    pub end: ::core::option::Option<TimestampConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RangeDurationFilter {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
    #[prost(message, optional, tag = "2")]
    pub threshold: ::core::option::Option<DurationInput>,
    #[prost(enumeration = "ComparisonOperation", tag = "3")]
    pub comparison: i32,
    #[prost(enumeration = "UnboundedDurationComparison", optional, tag = "4")]
    pub unbounded: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericStabilityRanges {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(message, optional, tag = "2")]
    pub window: ::core::option::Option<DurationInput>,
    #[prost(message, optional, tag = "3")]
    pub min_points: ::core::option::Option<IntegerConstant>,
    #[prost(message, optional, tag = "4")]
    pub threshold: ::core::option::Option<SpreadThreshold>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NumericExtremaRanges {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(enumeration = "ExtremaSelection", tag = "2")]
    pub selection: i32,
    #[prost(message, optional, tag = "3")]
    pub min_prominence: ::core::option::Option<DoubleConstant>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RangeExpressionCollection {
    #[prost(message, repeated, tag = "1")]
    pub inputs: ::prost::alloc::vec::Vec<RangeExpression>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RangePaddingExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
    #[prost(message, optional, tag = "2")]
    pub padding: ::core::option::Option<DurationInput>,
    #[prost(enumeration = "RangePaddingSides", optional, tag = "3")]
    pub sides: ::core::option::Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RangeStatisticsExpression {
    #[prost(message, optional, boxed, tag = "1")]
    pub ranges: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
    #[prost(message, optional, boxed, tag = "2")]
    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
    #[prost(oneof = "range_statistics_expression::Statistics", tags = "3, 4")]
    pub statistics: ::core::option::Option<range_statistics_expression::Statistics>,
}
/// Nested message and enum types in `RangeStatisticsExpression`.
pub mod range_statistics_expression {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Statistics {
        #[prost(message, tag = "3")]
        Reduction(super::NumericReduction),
        #[prost(message, tag = "4")]
        All(super::AllStatistics),
    }
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct AllStatistics {}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ComputeAlignmentStrategy {
    Unspecified = 0,
    DriverSeries = 1,
    Union = 2,
}
impl ComputeAlignmentStrategy {
    /// 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 => "COMPUTE_ALIGNMENT_STRATEGY_UNSPECIFIED",
            Self::DriverSeries => "COMPUTE_ALIGNMENT_STRATEGY_DRIVER_SERIES",
            Self::Union => "COMPUTE_ALIGNMENT_STRATEGY_UNION",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "COMPUTE_ALIGNMENT_STRATEGY_UNSPECIFIED" => Some(Self::Unspecified),
            "COMPUTE_ALIGNMENT_STRATEGY_DRIVER_SERIES" => Some(Self::DriverSeries),
            "COMPUTE_ALIGNMENT_STRATEGY_UNION" => Some(Self::Union),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum BuiltinCurveForm {
    Unspecified = 0,
    Exponential = 1,
    Logarithmic = 2,
    Power = 3,
}
impl BuiltinCurveForm {
    /// 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 => "BUILTIN_CURVE_FORM_UNSPECIFIED",
            Self::Exponential => "BUILTIN_CURVE_FORM_EXPONENTIAL",
            Self::Logarithmic => "BUILTIN_CURVE_FORM_LOGARITHMIC",
            Self::Power => "BUILTIN_CURVE_FORM_POWER",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "BUILTIN_CURVE_FORM_UNSPECIFIED" => Some(Self::Unspecified),
            "BUILTIN_CURVE_FORM_EXPONENTIAL" => Some(Self::Exponential),
            "BUILTIN_CURVE_FORM_LOGARITHMIC" => Some(Self::Logarithmic),
            "BUILTIN_CURVE_FORM_POWER" => Some(Self::Power),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum UnboundedRangePolicy {
    Unspecified = 0,
    ClampToWindow = 1,
    Drop = 2,
}
impl UnboundedRangePolicy {
    /// 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 => "UNBOUNDED_RANGE_POLICY_UNSPECIFIED",
            Self::ClampToWindow => "UNBOUNDED_RANGE_POLICY_CLAMP_TO_WINDOW",
            Self::Drop => "UNBOUNDED_RANGE_POLICY_DROP",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "UNBOUNDED_RANGE_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
            "UNBOUNDED_RANGE_POLICY_CLAMP_TO_WINDOW" => Some(Self::ClampToWindow),
            "UNBOUNDED_RANGE_POLICY_DROP" => Some(Self::Drop),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ChronologicalOrder {
    Unspecified = 0,
    Ascending = 1,
    Descending = 2,
}
impl ChronologicalOrder {
    /// 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 => "CHRONOLOGICAL_ORDER_UNSPECIFIED",
            Self::Ascending => "CHRONOLOGICAL_ORDER_ASCENDING",
            Self::Descending => "CHRONOLOGICAL_ORDER_DESCENDING",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "CHRONOLOGICAL_ORDER_UNSPECIFIED" => Some(Self::Unspecified),
            "CHRONOLOGICAL_ORDER_ASCENDING" => Some(Self::Ascending),
            "CHRONOLOGICAL_ORDER_DESCENDING" => Some(Self::Descending),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum UnaryNumericOperation {
    Unspecified = 0,
    Abs = 1,
    Negate = 2,
    Cos = 3,
    Sin = 4,
    Tan = 5,
    Acos = 6,
    Asin = 7,
    Ln = 8,
    Log10 = 9,
    Sqrt = 10,
}
impl UnaryNumericOperation {
    /// 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 => "UNARY_NUMERIC_OPERATION_UNSPECIFIED",
            Self::Abs => "UNARY_NUMERIC_OPERATION_ABS",
            Self::Negate => "UNARY_NUMERIC_OPERATION_NEGATE",
            Self::Cos => "UNARY_NUMERIC_OPERATION_COS",
            Self::Sin => "UNARY_NUMERIC_OPERATION_SIN",
            Self::Tan => "UNARY_NUMERIC_OPERATION_TAN",
            Self::Acos => "UNARY_NUMERIC_OPERATION_ACOS",
            Self::Asin => "UNARY_NUMERIC_OPERATION_ASIN",
            Self::Ln => "UNARY_NUMERIC_OPERATION_LN",
            Self::Log10 => "UNARY_NUMERIC_OPERATION_LOG10",
            Self::Sqrt => "UNARY_NUMERIC_OPERATION_SQRT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "UNARY_NUMERIC_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
            "UNARY_NUMERIC_OPERATION_ABS" => Some(Self::Abs),
            "UNARY_NUMERIC_OPERATION_NEGATE" => Some(Self::Negate),
            "UNARY_NUMERIC_OPERATION_COS" => Some(Self::Cos),
            "UNARY_NUMERIC_OPERATION_SIN" => Some(Self::Sin),
            "UNARY_NUMERIC_OPERATION_TAN" => Some(Self::Tan),
            "UNARY_NUMERIC_OPERATION_ACOS" => Some(Self::Acos),
            "UNARY_NUMERIC_OPERATION_ASIN" => Some(Self::Asin),
            "UNARY_NUMERIC_OPERATION_LN" => Some(Self::Ln),
            "UNARY_NUMERIC_OPERATION_LOG10" => Some(Self::Log10),
            "UNARY_NUMERIC_OPERATION_SQRT" => Some(Self::Sqrt),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum BinaryNumericOperation {
    Unspecified = 0,
    Add = 1,
    Subtract = 2,
    Multiply = 3,
    Divide = 4,
    FloorDivide = 5,
    Power = 6,
    Modulo = 7,
    Atan2 = 8,
}
impl BinaryNumericOperation {
    /// 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 => "BINARY_NUMERIC_OPERATION_UNSPECIFIED",
            Self::Add => "BINARY_NUMERIC_OPERATION_ADD",
            Self::Subtract => "BINARY_NUMERIC_OPERATION_SUBTRACT",
            Self::Multiply => "BINARY_NUMERIC_OPERATION_MULTIPLY",
            Self::Divide => "BINARY_NUMERIC_OPERATION_DIVIDE",
            Self::FloorDivide => "BINARY_NUMERIC_OPERATION_FLOOR_DIVIDE",
            Self::Power => "BINARY_NUMERIC_OPERATION_POWER",
            Self::Modulo => "BINARY_NUMERIC_OPERATION_MODULO",
            Self::Atan2 => "BINARY_NUMERIC_OPERATION_ATAN2",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "BINARY_NUMERIC_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
            "BINARY_NUMERIC_OPERATION_ADD" => Some(Self::Add),
            "BINARY_NUMERIC_OPERATION_SUBTRACT" => Some(Self::Subtract),
            "BINARY_NUMERIC_OPERATION_MULTIPLY" => Some(Self::Multiply),
            "BINARY_NUMERIC_OPERATION_DIVIDE" => Some(Self::Divide),
            "BINARY_NUMERIC_OPERATION_FLOOR_DIVIDE" => Some(Self::FloorDivide),
            "BINARY_NUMERIC_OPERATION_POWER" => Some(Self::Power),
            "BINARY_NUMERIC_OPERATION_MODULO" => Some(Self::Modulo),
            "BINARY_NUMERIC_OPERATION_ATAN2" => Some(Self::Atan2),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum NaryNumericOperation {
    Unspecified = 0,
    Max = 1,
    Mean = 2,
    Min = 3,
    Sum = 4,
    Product = 5,
}
impl NaryNumericOperation {
    /// 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 => "NARY_NUMERIC_OPERATION_UNSPECIFIED",
            Self::Max => "NARY_NUMERIC_OPERATION_MAX",
            Self::Mean => "NARY_NUMERIC_OPERATION_MEAN",
            Self::Min => "NARY_NUMERIC_OPERATION_MIN",
            Self::Sum => "NARY_NUMERIC_OPERATION_SUM",
            Self::Product => "NARY_NUMERIC_OPERATION_PRODUCT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NARY_NUMERIC_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
            "NARY_NUMERIC_OPERATION_MAX" => Some(Self::Max),
            "NARY_NUMERIC_OPERATION_MEAN" => Some(Self::Mean),
            "NARY_NUMERIC_OPERATION_MIN" => Some(Self::Min),
            "NARY_NUMERIC_OPERATION_SUM" => Some(Self::Sum),
            "NARY_NUMERIC_OPERATION_PRODUCT" => Some(Self::Product),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum BitwiseOperation {
    Unspecified = 0,
    And = 1,
    Or = 2,
    Xor = 3,
    ShiftRight = 4,
    ShiftLeft = 5,
    Test = 6,
}
impl BitwiseOperation {
    /// 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 => "BITWISE_OPERATION_UNSPECIFIED",
            Self::And => "BITWISE_OPERATION_AND",
            Self::Or => "BITWISE_OPERATION_OR",
            Self::Xor => "BITWISE_OPERATION_XOR",
            Self::ShiftRight => "BITWISE_OPERATION_SHIFT_RIGHT",
            Self::ShiftLeft => "BITWISE_OPERATION_SHIFT_LEFT",
            Self::Test => "BITWISE_OPERATION_TEST",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "BITWISE_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
            "BITWISE_OPERATION_AND" => Some(Self::And),
            "BITWISE_OPERATION_OR" => Some(Self::Or),
            "BITWISE_OPERATION_XOR" => Some(Self::Xor),
            "BITWISE_OPERATION_SHIFT_RIGHT" => Some(Self::ShiftRight),
            "BITWISE_OPERATION_SHIFT_LEFT" => Some(Self::ShiftLeft),
            "BITWISE_OPERATION_TEST" => Some(Self::Test),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ComparisonOperation {
    Unspecified = 0,
    GreaterThan = 1,
    LessThan = 2,
    EqualTo = 3,
    NotEqualTo = 4,
    GreaterThanOrEqualTo = 5,
    LessThanOrEqualTo = 6,
}
impl ComparisonOperation {
    /// 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 => "COMPARISON_OPERATION_UNSPECIFIED",
            Self::GreaterThan => "COMPARISON_OPERATION_GREATER_THAN",
            Self::LessThan => "COMPARISON_OPERATION_LESS_THAN",
            Self::EqualTo => "COMPARISON_OPERATION_EQUAL_TO",
            Self::NotEqualTo => "COMPARISON_OPERATION_NOT_EQUAL_TO",
            Self::GreaterThanOrEqualTo => "COMPARISON_OPERATION_GREATER_THAN_OR_EQUAL_TO",
            Self::LessThanOrEqualTo => "COMPARISON_OPERATION_LESS_THAN_OR_EQUAL_TO",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "COMPARISON_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
            "COMPARISON_OPERATION_GREATER_THAN" => Some(Self::GreaterThan),
            "COMPARISON_OPERATION_LESS_THAN" => Some(Self::LessThan),
            "COMPARISON_OPERATION_EQUAL_TO" => Some(Self::EqualTo),
            "COMPARISON_OPERATION_NOT_EQUAL_TO" => Some(Self::NotEqualTo),
            "COMPARISON_OPERATION_GREATER_THAN_OR_EQUAL_TO" => {
                Some(Self::GreaterThanOrEqualTo)
            }
            "COMPARISON_OPERATION_LESS_THAN_OR_EQUAL_TO" => Some(Self::LessThanOrEqualTo),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LogicalOperation {
    Unspecified = 0,
    And = 1,
    Or = 2,
}
impl LogicalOperation {
    /// 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 => "LOGICAL_OPERATION_UNSPECIFIED",
            Self::And => "LOGICAL_OPERATION_AND",
            Self::Or => "LOGICAL_OPERATION_OR",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "LOGICAL_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
            "LOGICAL_OPERATION_AND" => Some(Self::And),
            "LOGICAL_OPERATION_OR" => Some(Self::Or),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum NegativeValuePolicy {
    Unspecified = 0,
    Allow = 1,
    ClampToZero = 2,
    Exclude = 3,
}
impl NegativeValuePolicy {
    /// 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 => "NEGATIVE_VALUE_POLICY_UNSPECIFIED",
            Self::Allow => "NEGATIVE_VALUE_POLICY_ALLOW",
            Self::ClampToZero => "NEGATIVE_VALUE_POLICY_CLAMP_TO_ZERO",
            Self::Exclude => "NEGATIVE_VALUE_POLICY_EXCLUDE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NEGATIVE_VALUE_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
            "NEGATIVE_VALUE_POLICY_ALLOW" => Some(Self::Allow),
            "NEGATIVE_VALUE_POLICY_CLAMP_TO_ZERO" => Some(Self::ClampToZero),
            "NEGATIVE_VALUE_POLICY_EXCLUDE" => Some(Self::Exclude),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PointLimitOrder {
    Unspecified = 0,
    Newest = 1,
    Oldest = 2,
}
impl PointLimitOrder {
    /// 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 => "POINT_LIMIT_ORDER_UNSPECIFIED",
            Self::Newest => "POINT_LIMIT_ORDER_NEWEST",
            Self::Oldest => "POINT_LIMIT_ORDER_OLDEST",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "POINT_LIMIT_ORDER_UNSPECIFIED" => Some(Self::Unspecified),
            "POINT_LIMIT_ORDER_NEWEST" => Some(Self::Newest),
            "POINT_LIMIT_ORDER_OLDEST" => Some(Self::Oldest),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ApproximateComparisonOperation {
    Unspecified = 0,
    EqualTo = 1,
    NotEqualTo = 2,
}
impl ApproximateComparisonOperation {
    /// 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 => "APPROXIMATE_COMPARISON_OPERATION_UNSPECIFIED",
            Self::EqualTo => "APPROXIMATE_COMPARISON_OPERATION_EQUAL_TO",
            Self::NotEqualTo => "APPROXIMATE_COMPARISON_OPERATION_NOT_EQUAL_TO",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "APPROXIMATE_COMPARISON_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
            "APPROXIMATE_COMPARISON_OPERATION_EQUAL_TO" => Some(Self::EqualTo),
            "APPROXIMATE_COMPARISON_OPERATION_NOT_EQUAL_TO" => Some(Self::NotEqualTo),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DuplicateMergeOperation {
    Unspecified = 0,
    Min = 1,
    Max = 2,
    Mean = 3,
    Sum = 4,
    Count = 5,
    StandardDeviation = 6,
    RootMeanSquare = 7,
    Reject = 8,
}
impl DuplicateMergeOperation {
    /// 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 => "DUPLICATE_MERGE_OPERATION_UNSPECIFIED",
            Self::Min => "DUPLICATE_MERGE_OPERATION_MIN",
            Self::Max => "DUPLICATE_MERGE_OPERATION_MAX",
            Self::Mean => "DUPLICATE_MERGE_OPERATION_MEAN",
            Self::Sum => "DUPLICATE_MERGE_OPERATION_SUM",
            Self::Count => "DUPLICATE_MERGE_OPERATION_COUNT",
            Self::StandardDeviation => "DUPLICATE_MERGE_OPERATION_STANDARD_DEVIATION",
            Self::RootMeanSquare => "DUPLICATE_MERGE_OPERATION_ROOT_MEAN_SQUARE",
            Self::Reject => "DUPLICATE_MERGE_OPERATION_REJECT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DUPLICATE_MERGE_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
            "DUPLICATE_MERGE_OPERATION_MIN" => Some(Self::Min),
            "DUPLICATE_MERGE_OPERATION_MAX" => Some(Self::Max),
            "DUPLICATE_MERGE_OPERATION_MEAN" => Some(Self::Mean),
            "DUPLICATE_MERGE_OPERATION_SUM" => Some(Self::Sum),
            "DUPLICATE_MERGE_OPERATION_COUNT" => Some(Self::Count),
            "DUPLICATE_MERGE_OPERATION_STANDARD_DEVIATION" => {
                Some(Self::StandardDeviation)
            }
            "DUPLICATE_MERGE_OPERATION_ROOT_MEAN_SQUARE" => Some(Self::RootMeanSquare),
            "DUPLICATE_MERGE_OPERATION_REJECT" => Some(Self::Reject),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LiteralBitwiseOperation {
    Unspecified = 0,
    And = 1,
    Or = 2,
    Xor = 3,
}
impl LiteralBitwiseOperation {
    /// 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 => "LITERAL_BITWISE_OPERATION_UNSPECIFIED",
            Self::And => "LITERAL_BITWISE_OPERATION_AND",
            Self::Or => "LITERAL_BITWISE_OPERATION_OR",
            Self::Xor => "LITERAL_BITWISE_OPERATION_XOR",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "LITERAL_BITWISE_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
            "LITERAL_BITWISE_OPERATION_AND" => Some(Self::And),
            "LITERAL_BITWISE_OPERATION_OR" => Some(Self::Or),
            "LITERAL_BITWISE_OPERATION_XOR" => Some(Self::Xor),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ShiftDirection {
    Unspecified = 0,
    Left = 1,
    Right = 2,
}
impl ShiftDirection {
    /// 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 => "SHIFT_DIRECTION_UNSPECIFIED",
            Self::Left => "SHIFT_DIRECTION_LEFT",
            Self::Right => "SHIFT_DIRECTION_RIGHT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SHIFT_DIRECTION_UNSPECIFIED" => Some(Self::Unspecified),
            "SHIFT_DIRECTION_LEFT" => Some(Self::Left),
            "SHIFT_DIRECTION_RIGHT" => Some(Self::Right),
            _ => None,
        }
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScalarValue {
    #[prost(oneof = "scalar_value::Kind", tags = "1, 2, 3")]
    pub kind: ::core::option::Option<scalar_value::Kind>,
}
/// Nested message and enum types in `ScalarValue`.
pub mod scalar_value {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        #[prost(string, tag = "1")]
        StringValue(::prost::alloc::string::String),
        #[prost(double, tag = "2")]
        Float64Value(f64),
        #[prost(int64, tag = "3")]
        Int64Value(i64),
    }
}