#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BoolNull {
    #[prost(oneof="bool_null::Data", tags="1")]
    pub data: ::std::option::Option<bool_null::Data>,
}
pub mod bool_null {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Data {
        #[prost(bool, tag="1")]
        Option(bool),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct I64Null {
    #[prost(oneof="i64_null::Data", tags="1")]
    pub data: ::std::option::Option<i64_null::Data>,
}
pub mod i64_null {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Data {
        #[prost(int64, tag="1")]
        Option(i64),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct F64Null {
    #[prost(oneof="f64_null::Data", tags="1")]
    pub data: ::std::option::Option<f64_null::Data>,
}
pub mod f64_null {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Data {
        #[prost(double, tag="1")]
        Option(f64),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StrNull {
    #[prost(oneof="str_null::Data", tags="1")]
    pub data: ::std::option::Option<str_null::Data>,
}
pub mod str_null {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Data {
        #[prost(string, tag="1")]
        Option(std::string::String),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Array1dBoolNull {
    #[prost(message, repeated, tag="1")]
    pub data: ::std::vec::Vec<BoolNull>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Array1dI64Null {
    #[prost(message, repeated, tag="1")]
    pub data: ::std::vec::Vec<I64Null>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Array1dF64Null {
    #[prost(message, repeated, tag="1")]
    pub data: ::std::vec::Vec<F64Null>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Array1dStrNull {
    #[prost(message, repeated, tag="1")]
    pub data: ::std::vec::Vec<StrNull>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Array1dNull {
    #[prost(oneof="array1d_null::Data", tags="1, 2, 3, 4")]
    pub data: ::std::option::Option<array1d_null::Data>,
}
pub mod array1d_null {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Data {
        #[prost(message, tag="1")]
        Bool(super::Array1dBoolNull),
        #[prost(message, tag="2")]
        I64(super::Array1dI64Null),
        #[prost(message, tag="3")]
        F64(super::Array1dF64Null),
        #[prost(message, tag="4")]
        String(super::Array1dStrNull),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Array1dBool {
    #[prost(bool, repeated, tag="1")]
    pub data: ::std::vec::Vec<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Array1dI64 {
    #[prost(int64, repeated, tag="1")]
    pub data: ::std::vec::Vec<i64>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Array1dF64 {
    #[prost(double, repeated, tag="1")]
    pub data: ::std::vec::Vec<f64>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Array1dStr {
    #[prost(string, repeated, tag="1")]
    pub data: ::std::vec::Vec<std::string::String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Array1d {
    #[prost(oneof="array1d::Data", tags="1, 2, 3, 4")]
    pub data: ::std::option::Option<array1d::Data>,
}
pub mod array1d {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Data {
        #[prost(message, tag="1")]
        Bool(super::Array1dBool),
        #[prost(message, tag="2")]
        I64(super::Array1dI64),
        #[prost(message, tag="3")]
        F64(super::Array1dF64),
        #[prost(message, tag="4")]
        String(super::Array1dStr),
    }
}
/// N-dimensional homogeneously typed array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Array {
    #[prost(message, optional, tag="1")]
    pub flattened: ::std::option::Option<Array1d>,
    /// length of axes
    #[prost(uint64, repeated, tag="2")]
    pub shape: ::std::vec::Vec<u64>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Jagged {
    #[prost(message, repeated, tag="1")]
    pub data: ::std::vec::Vec<Array1d>,
    #[prost(enumeration="DataType", tag="2")]
    pub data_type: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PrivacyUsage {
    #[prost(oneof="privacy_usage::Distance", tags="1")]
    pub distance: ::std::option::Option<privacy_usage::Distance>,
}
pub mod privacy_usage {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DistanceApproximate {
        #[prost(double, tag="1")]
        pub epsilon: f64,
        #[prost(double, tag="2")]
        pub delta: f64,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Distance {
        #[prost(message, tag="1")]
        Approximate(DistanceApproximate),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PrivacyUsages {
    #[prost(message, repeated, tag="1")]
    pub values: ::std::vec::Vec<PrivacyUsage>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArgumentNodeIds {
    #[prost(message, repeated, tag="1")]
    pub keys: ::std::vec::Vec<IndexKey>,
    #[prost(uint32, repeated, tag="2")]
    pub values: ::std::vec::Vec<u32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IndexKey {
    #[prost(oneof="index_key::Key", tags="1, 2, 3, 4")]
    pub key: ::std::option::Option<index_key::Key>,
}
pub mod index_key {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Tuple {
        #[prost(message, repeated, tag="1")]
        pub values: ::std::vec::Vec<super::IndexKey>,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Key {
        #[prost(string, tag="1")]
        Str(std::string::String),
        #[prost(int64, tag="2")]
        I64(i64),
        #[prost(bool, tag="3")]
        Bool(bool),
        #[prost(message, tag="4")]
        Tuple(Tuple),
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DataType {
    Unknown = 0,
    Bool = 1,
    I64 = 2,
    F64 = 3,
    String = 4,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Component {
    #[prost(message, optional, tag="1")]
    pub arguments: ::std::option::Option<ArgumentNodeIds>,
    /// if true, then don't include the evaluation for this component in the release
    #[prost(bool, tag="2")]
    pub omit: bool,
    /// for interactive analyses
    #[prost(uint32, tag="3")]
    pub submission: u32,
    #[prost(oneof="component::Variant", tags="100, 101, 104, 105, 168, 106, 107, 119, 120, 108, 109, 166, 110, 167, 111, 112, 113, 114, 116, 115, 117, 118, 121, 122, 123, 124, 125, 126, 127, 128, 130, 131, 132, 133, 102, 144, 134, 135, 136, 137, 163, 139, 140, 141, 142, 143, 145, 146, 147, 129, 149, 150, 151, 152, 153, 164, 155, 156, 165, 157, 148, 158, 159, 160, 162, 161")]
    pub variant: ::std::option::Option<component::Variant>,
}
pub mod component {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Variant {
        #[prost(message, tag="100")]
        Abs(super::Abs),
        #[prost(message, tag="101")]
        Add(super::Add),
        #[prost(message, tag="104")]
        Cast(super::Cast),
        #[prost(message, tag="105")]
        Clamp(super::Clamp),
        #[prost(message, tag="168")]
        ColumnBind(super::ColumnBind),
        #[prost(message, tag="106")]
        Count(super::Count),
        #[prost(message, tag="107")]
        Covariance(super::Covariance),
        #[prost(message, tag="119")]
        Digitize(super::Digitize),
        #[prost(message, tag="120")]
        Divide(super::Divide),
        #[prost(message, tag="108")]
        DpCount(super::DpCount),
        #[prost(message, tag="109")]
        DpCovariance(super::DpCovariance),
        #[prost(message, tag="166")]
        DpGumbelMedian(super::DpGumbelMedian),
        #[prost(message, tag="110")]
        DpHistogram(super::DpHistogram),
        #[prost(message, tag="167")]
        DpLinearRegression(super::DpLinearRegression),
        #[prost(message, tag="111")]
        DpMaximum(super::DpMaximum),
        #[prost(message, tag="112")]
        DpMean(super::DpMean),
        #[prost(message, tag="113")]
        DpMedian(super::DpMedian),
        #[prost(message, tag="114")]
        DpMinimum(super::DpMinimum),
        #[prost(message, tag="116")]
        DpQuantile(super::DpQuantile),
        #[prost(message, tag="115")]
        DpRawMoment(super::DpRawMoment),
        #[prost(message, tag="117")]
        DpSum(super::DpSum),
        #[prost(message, tag="118")]
        DpVariance(super::DpVariance),
        #[prost(message, tag="121")]
        Equal(super::Equal),
        #[prost(message, tag="122")]
        ExponentialMechanism(super::ExponentialMechanism),
        #[prost(message, tag="123")]
        Filter(super::Filter),
        #[prost(message, tag="124")]
        GaussianMechanism(super::GaussianMechanism),
        #[prost(message, tag="125")]
        GreaterThan(super::GreaterThan),
        #[prost(message, tag="126")]
        Histogram(super::Histogram),
        #[prost(message, tag="127")]
        Impute(super::Impute),
        #[prost(message, tag="128")]
        Index(super::Index),
        #[prost(message, tag="130")]
        LaplaceMechanism(super::LaplaceMechanism),
        #[prost(message, tag="131")]
        LessThan(super::LessThan),
        #[prost(message, tag="132")]
        Literal(super::Literal),
        #[prost(message, tag="133")]
        Log(super::Log),
        #[prost(message, tag="102")]
        LogicalAnd(super::And),
        #[prost(message, tag="144")]
        LogicalOr(super::Or),
        #[prost(message, tag="134")]
        Map(Box<super::Map>),
        #[prost(message, tag="135")]
        Materialize(super::Materialize),
        #[prost(message, tag="136")]
        Maximum(super::Maximum),
        #[prost(message, tag="137")]
        Mean(super::Mean),
        #[prost(message, tag="163")]
        Median(super::Median),
        #[prost(message, tag="139")]
        Minimum(super::Minimum),
        #[prost(message, tag="140")]
        Modulo(super::Modulo),
        #[prost(message, tag="141")]
        Multiply(super::Multiply),
        #[prost(message, tag="142")]
        Negate(super::Negate),
        #[prost(message, tag="143")]
        Negative(super::Negative),
        #[prost(message, tag="145")]
        Partition(super::Partition),
        #[prost(message, tag="146")]
        Power(super::Power),
        #[prost(message, tag="147")]
        Quantile(super::Quantile),
        #[prost(message, tag="129")]
        RawMoment(super::RawMoment),
        #[prost(message, tag="149")]
        Reshape(super::Reshape),
        #[prost(message, tag="150")]
        Resize(super::Resize),
        #[prost(message, tag="151")]
        RowMax(super::RowMax),
        #[prost(message, tag="152")]
        RowMin(super::RowMin),
        #[prost(message, tag="153")]
        SimpleGeometricMechanism(super::SimpleGeometricMechanism),
        #[prost(message, tag="164")]
        SnappingMechanism(super::SnappingMechanism),
        #[prost(message, tag="155")]
        Subtract(super::Subtract),
        #[prost(message, tag="156")]
        Sum(super::Sum),
        #[prost(message, tag="165")]
        TheilSen(super::TheilSen),
        #[prost(message, tag="157")]
        ToBool(super::ToBool),
        #[prost(message, tag="148")]
        ToDataframe(super::ToDataframe),
        #[prost(message, tag="158")]
        ToFloat(super::ToFloat),
        #[prost(message, tag="159")]
        ToInt(super::ToInt),
        #[prost(message, tag="160")]
        ToString(super::ToString),
        #[prost(message, tag="162")]
        Union(super::Union),
        #[prost(message, tag="161")]
        Variance(super::Variance),
    }
}
/// Abs Component
/// 
/// Absolute value of data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the abs on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Atomic types must be of type float or integer.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Abs {
}
/// Add Component
/// 
/// Mathematical addition. Value types of arguments must match.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the add on the arguments.
/// 
/// # Arguments
/// * `left` - Array - Left value to add. Must be of type float or integer.
/// * `right` - Array - Right value to add. Must be of type float or integer.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Add {
}
/// Cast Component
/// 
/// Cast data to an atomic type.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the cast on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Data to be cast to another type.
/// * `true_label` - Array - Positive class (class to be mapped to `true`) for each column. Used only if casting to `bool`.
/// * `lower` - Array - Minimum allowable imputation value. Used only if casting to `i64`.
/// * `upper` - Array - Maximum allowable imputation value. Used only if casting to `i64`.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Cast {
    /// Type to which data should be cast. One of [`string`, `int`, `bool`, `float`]
    #[prost(string, tag="1")]
    pub atomic_type: std::string::String,
}
/// Clamp Component
/// 
/// Clamps data to the provided bounds.
/// 
/// If data are numeric, clamping maps elements outside of an interval `[lower, upper]` to the closer endpoint.
/// If data are categorical, clamping maps elements outside of the `categories` argument to the associated `null`.
/// Using clamp sets the `categories` property for the analysis with value `categories` plus `null_value` in the last position.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the clamp on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Data to be clamped.
/// * `lower` - Array - Desired lower bound for each column of the data. Used only if `categories` is `None`.
/// * `upper` - Array - Desired upper bound for each column of the data. Used only if `categories` is `None`.
/// * `categories` - Jagged - The set of categories you want to be represented for each column of the data, or `None`.
/// * `null_value` - Array - The value to which elements not included in `categories` will be mapped for each column of the data. Used only if `categories` is not `None`.
/// 
/// # Returns
/// * `Value` - Array - Clamped data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Clamp {
}
/// ColumnBind Component
/// 
/// Bind arguments as columns of an array to produce a larger array
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the column_bind on the arguments.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ColumnBind {
}
/// Count Component
/// 
/// Returns the number of rows in the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the count on the arguments.
/// 
/// # Arguments
/// * `data` - Array
/// 
/// # Returns
/// * `Value` - Array - Row count.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Count {
    /// Set to true for the number of unique members in the data.
    #[prost(bool, tag="1")]
    pub distinct: bool,
}
/// Covariance Component
/// 
/// Calculate covariance.
/// 
/// If `data` argument is provided as a 2D array, calculate covariance matrix. Otherwise, `left` and `right` 1D arrays are used to calculate a cross-covariance matrix between elements of the two arrays.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the covariance on the arguments.
/// 
/// # Arguments
/// * `data` - Array - 2D data array used to construct covariance matrix.
/// * `left` - Array - Left data array used to calculate cross-covariance matrix. Used only if `data` not provided.
/// * `right` - Array - Right data array used to calculate cross-covariance matrix. Used only if `data` not provided.
/// 
/// # Returns
/// * `Value` - Array - Flattened covariance or cross-covariance matrix.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Covariance {
    /// Whether or not to use the finite sample correction (Bessel's correction).
    #[prost(bool, tag="1")]
    pub finite_sample_correction: bool,
}
/// Digitize Component
/// 
/// Maps data to bins.
/// 
/// Bins will be of the form [lower, upper) or (lower, upper]. The null value is the final category.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the digitize on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Data to be binned.
/// * `edges` - Jagged - Values representing the edges of bins. Edges must be sorted, and may not contain duplicates.
/// * `null_value` - Array - Value to which to map if there is no valid bin (e.g. if the element falls outside the bin range). The null value is the final category.
/// * `inclusive_left` - Array - Whether or not the left edge of the bin is inclusive, i.e. the bins are of the form [lower, upper).
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Digitize {
}
/// Divide Component
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the divide on the arguments.
/// 
/// # Arguments
/// * `left` - Array - Atomic type must match right
/// * `right` - Array - Atomic type must match left
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Divide {
}
/// DPCount Component
/// 
/// Returns a differentially private row count.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the dp_count on the arguments.
/// 
/// # Arguments
/// * `data` - Array
/// * `lower` - Array - Estimated minimum possible value of the statistic. Useful to help bound elapsed time when sampling for the geometric mechanism. Required for the snapping mechanism.
/// * `upper` - Array - Estimated maximum possible value of the statistic. Useful to help bound elapsed time when sampling for the geometric mechanism. Required for the snapping mechanism.
/// 
/// # Returns
/// * `Value` - Array - Differentially private row count.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DpCount {
    /// Set to true for the number of unique members in the data.
    #[prost(bool, tag="1")]
    pub distinct: bool,
    /// Privatizing mechanism to use. One of [`SimpleGeometric`, `Laplace`, `Snapping`, `Gaussian`, `AnalyticGaussian`]. Only `SimpleGeometric` is accepted if floating-point protections are enabled.
    #[prost(string, tag="2")]
    pub mechanism: std::string::String,
    /// Object describing the type and amount of privacy to be used for the mechanism release. Atomic data type value must be float. Example value: {'epsilon': 0.5}
    #[prost(message, repeated, tag="3")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
}
/// DPCovariance Component
/// 
/// Calculate differentially private covariance.
/// 
/// If `data` argument is provided as a 2D array, calculate covariance matrix. Otherwise, `left` and `right` 1D arrays are used to calculate a cross-covariance matrix between elements of the two arrays.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the dp_covariance on the arguments.
/// 
/// # Arguments
/// * `left` - Array - Left data array used to calculate cross-covariance matrix. Used only if `data` not provided.
/// * `right` - Array - Right data array used to calculate cross-covariance matrix. Used only if `data` not provided.
/// * `data` - Array - 2D data array used to construct covariance matrix.
/// * `lower` - Array - Estimated minimum possible value of the statistic. Only useful for the snapping mechanism.
/// * `upper` - Array - Estimated maximum possible value of the statistic. Only useful for the snapping mechanism.
/// 
/// # Returns
/// * `Value` - Array - Flattened covariance or cross-covariance matrix.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DpCovariance {
    /// Privatizing mechanism to use. One of [`Laplace`, `Snapping`, `Gaussian`, `AnalyticGaussian`]
    #[prost(string, tag="1")]
    pub mechanism: std::string::String,
    /// Object describing the type and amount of privacy to be used for the mechanism release. Atomic data type value must be float. Example value: {'epsilon': 0.5}
    #[prost(message, repeated, tag="2")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
    /// Whether or not to use the finite sample correction (Bessel's correction).
    #[prost(bool, tag="3")]
    pub finite_sample_correction: bool,
}
/// DPGumbelMedian Component
/// 
/// Returns differentially private estimates of the median of each column of the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the dp_gumbel_median on the arguments.
/// 
/// # Arguments
/// * `data` - Array
/// * `lower` -  - Min candidate
/// * `upper` -  - Max candidate
/// * `enforce_constant_time` -  - Enforce constant time for median
/// 
/// # Returns
/// * `Value` - Array - Differentially private estimates of the median of each column of the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DpGumbelMedian {
    /// Object describing the type and amount of privacy to be used for the mechanism release.
    #[prost(message, repeated, tag="1")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
}
/// DPHistogram Component
/// 
/// Returns a differentially private histogram over user-defined categories. The final cell contains the counts for null values (outside the set of categories).
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the dp_histogram on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Atomic type must be numeric.
/// * `edges` - Jagged - Set of edges to bin continuous-valued data. Used only if data are of `continuous` nature.
/// * `categories` - Jagged - Set of categories in data. Used only if data are of `categorical` nature.
/// * `null_value` - Array - The value to which elements not included in `categories` will be mapped for each column of the data. Used only if `categories` is not `None`. The null value is the final category- counts for the null category are at the end of the vector of counts.
/// * `lower` - Array - Estimated minimum possible value of bin counts. Useful to help bound elapsed time when sampling for the geometric mechanism. Required for the snapping mechanism.
/// * `upper` - Array - Estimated maximum possible value of bin counts. Useful to help bound elapsed time when sampling for the geometric mechanism. Required for the snapping mechanism.
/// * `inclusive_left` - Array - Whether or not the left edge of the bin is inclusive. If `true` bins are of the form [lower, upper). Otherwise, bins are of the form (lower, upper]. Used only if data are of `continuous` nature.
/// 
/// # Returns
/// * `Value` - Array - Differentially private histogram.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DpHistogram {
    /// Privatizing mechanism to use. One of [`SimpleGeometric`, `Laplace`, `Snapping`, `Gaussian`, `AnalyticGaussian`]. Only `SimpleGeometric` is accepted if floating-point protections are enabled.
    #[prost(string, tag="1")]
    pub mechanism: std::string::String,
    /// Object describing the type and amount of privacy to be used for the mechanism release.
    #[prost(message, repeated, tag="2")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
}
/// DPLinearRegression Component
/// 
/// Returns differentially private estimates of the slope and intercept.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the dp_linear_regression on the arguments.
/// 
/// # Arguments
/// * `data_x` - Array - Predictor variable
/// * `data_y` - Array - Target variable
/// * `k` - Integer - Number of matchings. Memory usage is quadratic in K.
/// * `lower_slope` - Array - Estimated minimum possible value of the slope.
/// * `upper_slope` - Array - Estimated maximum possible value of the slope.
/// * `lower_intercept` - Array - Estimated minimum possible value of the intercept.
/// * `upper_intercept` - Array - Estimated maximum possible value of the intercept.
/// 
/// # Returns
/// * `Value` - Array - Differentially private estimate of the slope and intercept of the line fit to the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DpLinearRegression {
    /// Theil-Sen implementation to use. One of [`theil-sen`, `theil-sen-k-match`]
    #[prost(string, tag="1")]
    pub implementation: std::string::String,
    /// Object describing the type and amount of privacy to be used for the mechanism release.
    #[prost(message, repeated, tag="2")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
}
/// DPMaximum Component
/// 
/// Returns differentially private estimates of the maximum elements of each column of the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the dp_maximum on the arguments.
/// 
/// # Arguments
/// * `data` - Array
/// * `candidates` - Array - Set from which the Exponential mechanism will return an element. Type must match with atomic type of data. This value must be column-conformable with data. Only useful for Exponential mechanism.
/// * `lower` - Array - Estimated minimum possible value of the statistic. Only useful for the snapping mechanism.
/// * `upper` - Array - Estimated maximum possible value of the statistic. Only useful for the snapping mechanism.
/// 
/// # Returns
/// * `Value` - Array - Differentially private estimates of the maximum elements of the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DpMaximum {
    /// Privatizing mechanism to use. Value must be one of [`Automatic`, `Laplace`, `Snapping`, `Gaussian`, `AnalyticGaussian`]
    #[prost(string, tag="1")]
    pub mechanism: std::string::String,
    /// Object describing the type and amount of privacy to be used for the mechanism release. Atomic data type value must be float. Example value: {'epsilon': 0.5}
    #[prost(message, repeated, tag="2")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
}
/// DPMean Component
/// 
/// Returns differentially private estimates of the means of each column of the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the dp_mean on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Atomic type must be numeric.
/// * `lower` - Array - Estimated minimum possible value of the statistic. Only useful for the snapping mechanism.
/// * `upper` - Array - Estimated maximum possible value of the statistic. Only useful for the snapping mechanism.
/// 
/// # Returns
/// * `Value` - Array - Differentially private estimate of the mean of each column of the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DpMean {
    /// Privatizing algorithm to use. One of [`resize`, `plug-in`]
    #[prost(string, tag="1")]
    pub implementation: std::string::String,
    /// Privatizing mechanism to use. One of [`Laplace`, `Snapping`, `Gaussian`, `AnalyticGaussian`].
    #[prost(string, tag="2")]
    pub mechanism: std::string::String,
    /// Object describing the type and amount of privacy to be used for the mechanism release. Atomic data type value must be float. Example value: {'epsilon': 0.5}
    #[prost(message, repeated, tag="3")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
}
/// DPMedian Component
/// 
/// Returns differentially private estimates of the median of each column of the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the dp_median on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Atomic type must be numeric. For Gumbel mechanism, must be limited to a single column of data.
/// * `candidates` - Array - Set from which the Exponential mechanism will return an element. Type must match with atomic type of data. This value must be column-conformable with data. Only useful for Exponential mechanism.
/// * `lower` - Array - Estimated minimum possible value of the statistic. Only useful for the snapping mechanism.
/// * `upper` - Array - Estimated maximum possible value of the statistic. Only useful for the snapping mechanism.
/// 
/// # Returns
/// * `Value` - Array - Differentially private estimates of the median of each column of the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DpMedian {
    /// Privatizing mechanism to use. Value must be one of [`Exponential`, `Laplace`, `Snapping`, `Gaussian`, `AnalyticGaussian`, `Gumbel`]. `Automatic` chooses `Exponential` if candidates provided, otherwise chooses `Laplace`.
    #[prost(string, tag="1")]
    pub mechanism: std::string::String,
    /// Object describing the type and amount of privacy to be used for the mechanism release.  For Gumbel mechanism, must be limited to a single column of data. Atomic data type value must be float. Example value: {'epsilon': 0.5}
    #[prost(message, repeated, tag="2")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
    /// Interpolation strategy. One of [`lower`, `upper`, `midpoint`, `nearest`, `linear`]
    #[prost(string, tag="3")]
    pub interpolation: std::string::String,
}
/// DPMinimum Component
/// 
/// Returns differentially private estimates of the minimum elements of each column of the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the dp_minimum on the arguments.
/// 
/// # Arguments
/// * `data` - Array
/// * `candidates` - Array - Set from which the Exponential mechanism will return an element. Type must match with atomic type of data. This value must be column-conformable with data. Only useful for Exponential mechanism.
/// * `lower` - Array - Estimated minimum possible value of the statistic. Only useful for the snapping mechanism.
/// * `upper` - Array - Estimated maximum possible value of the statistic. Only useful for the snapping mechanism.
/// 
/// # Returns
/// * `Value` - Array - Differentially private estimates of the minimum elements of the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DpMinimum {
    /// Privatizing mechanism to use. Value must be one of [`Automatic`, `Exponential`, `Laplace`, `Snapping`, `Gaussian`, `AnalyticGaussian`]. `Automatic` chooses `Exponential` if candidates provided.
    #[prost(string, tag="1")]
    pub mechanism: std::string::String,
    /// Object describing the type and amount of privacy to be used for the mechanism release. Atomic data type value must be float. Example value: {'epsilon': 0.5}
    #[prost(message, repeated, tag="2")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
}
/// DPQuantile Component
/// 
/// Returns differentially private estimates of specified quantiles for each column of the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the dp_quantile on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Atomic type must be numeric.
/// * `candidates` - Array - Set from which the Exponential mechanism will return an element. Type must match with atomic type of data. This value must be column-conformable with data. Only useful for Exponential mechanism.
/// * `lower` - Array - Estimated minimum possible value of the statistic. Only useful for the snapping mechanism.
/// * `upper` - Array - Estimated maximum possible value of the statistic. Only useful for the snapping mechanism.
/// 
/// # Returns
/// * `Value` - Array - Differentially private estimate of the quantile.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DpQuantile {
    /// Desired quantiles, defined on `[0,1]`.
    #[prost(double, tag="1")]
    pub alpha: f64,
    /// Privatizing mechanism to use. Value must be one of [`Automatic`, `Exponential`, `Laplace`, `Snapping`, `Gaussian`, `AnalyticGaussian`]. `Automatic` chooses `Exponential` if candidates provided.
    #[prost(string, tag="2")]
    pub mechanism: std::string::String,
    /// Object describing the type and amount of privacy to be used for the mechanism release. Atomic data type value must be float. Example value: {'epsilon': 0.5}
    #[prost(message, repeated, tag="3")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
    /// Interpolation strategy. One of [`lower`, `upper`, `midpoint`, `nearest`, `linear`]
    #[prost(string, tag="4")]
    pub interpolation: std::string::String,
}
/// DPRawMoment Component
/// 
/// Returns differentially private sample estimate of a raw moment for each column of the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the dp_raw_moment on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Data for which you would like the kth raw moments. Atomic data type must be float.
/// * `lower` - Array - Estimated minimum possible value of the statistic. Only useful for the snapping mechanism.
/// * `upper` - Array - Estimated maximum possible value of the statistic. Only useful for the snapping mechanism.
/// 
/// # Returns
/// * `Value` - Array - Differentially private sample estimate of kth raw moment for each column of the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DpRawMoment {
    /// Integer statistical moment indicator.
    #[prost(uint32, tag="1")]
    pub order: u32,
    /// Privatizing mechanism to use. Value must be one of [`Automatic`, `Laplace`, `Snapping`, `Gaussian`, `AnalyticGaussian`].
    #[prost(string, tag="2")]
    pub mechanism: std::string::String,
    /// Object describing the type and amount of privacy to be used for the mechanism release. Atomic data type value must be float. Example value: {'epsilon': 0.5}
    #[prost(message, repeated, tag="3")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
}
/// DPSum Component
/// 
/// Returns differentially private estimates of the sums of each column of the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the dp_sum on the arguments.
/// 
/// # Arguments
/// * `data` - Array
/// * `lower` - Array - Estimated minimum possible value of the statistic, on integral data. Useful to help bound elapsed time when sampling for the geometric mechanism. Useful for the snapping mechanism.
/// * `upper` - Array - Estimated maximum possible value of the statistic, on integral data. Useful to help bound elapsed time when sampling for the geometric mechanism. Useful for the snapping mechanism.
/// 
/// # Returns
/// * `Value` - Array - Differentially private sum over elements for each column of the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DpSum {
    /// Privatizing mechanism to use. Value must be one of [`Automatic`, `Laplace`, `Gaussian`, `AnalyticGaussian`, `SimpleGeometric`]. `Automatic` chooses based on the input data type.
    #[prost(string, tag="1")]
    pub mechanism: std::string::String,
    /// Object describing the type and amount of privacy to be used for the mechanism release. Atomic data type value must be float. Example value: {'epsilon': 0.5}
    #[prost(message, repeated, tag="2")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
}
/// DPVariance Component
/// 
/// Returns a differentially private estimate of the variance for each column of the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the dp_variance on the arguments.
/// 
/// # Arguments
/// * `data` - Array
/// * `lower` - Array - Estimated minimum possible value of the statistic. Only useful for the snapping mechanism. Atomic data type must be float.
/// * `upper` - Array - Estimated maximum possible value of the statistic. Only useful for the snapping mechanism. Atomic data type must be float.
/// 
/// # Returns
/// * `Value` - Array - Differentially private sample variance for each column of the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DpVariance {
    /// Privatizing mechanism to use. Value must be one of [`Laplace`, `Snapping`, `Gaussian`, `AnalyticGaussian`].
    #[prost(string, tag="1")]
    pub mechanism: std::string::String,
    /// Object describing the type and amount of privacy to be used for the mechanism release. Atomic data type value must be float. Example value: {'epsilon': 0.5}
    #[prost(message, repeated, tag="2")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
    /// Whether or not to use the finite sample correction (Bessel's correction).
    #[prost(bool, tag="3")]
    pub finite_sample_correction: bool,
}
/// Equal Component
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the equal on the arguments.
/// 
/// # Arguments
/// * `left` - Array - Atomic type must match right
/// * `right` - Array - Atomic type must match left
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Equal {
}
/// ExponentialMechanism Component
/// 
/// Returns an element from a finite set with probability relative to its utility.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the exponential_mechanism on the arguments.
/// 
/// # Arguments
/// * `utilities` - Array - Respective scores for each candidate. Total number of records must match candidates.
/// * `candidates` - Array - Set from which the Exponential mechanism will return an element. Total number of records must match utilities.
/// * `sensitivity` - Array - Override the sensitivity computed by the library. Rejected unless `protect_sensitivity` is disabled.
/// 
/// # Returns
/// * `Value` - Array - Element from the candidate set selected via the Exponential mechanism.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExponentialMechanism {
    /// Object describing the type and amount of privacy to be used for the mechanism release. Length of privacy_usage must be exactly one.
    #[prost(message, repeated, tag="1")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
}
/// Filter Component
/// 
/// Filters data down into only the desired rows.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the filter on the arguments.
/// 
/// # Arguments
/// * `data` - Array
/// * `mask` - Array - Boolean mask giving whether or not each row should be kept. Example value: data['age'] == '4'
/// 
/// # Returns
/// * `Value` - Array - Data with only the desired rows.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Filter {
}
/// GaussianMechanism Component
/// 
/// Privatizes a result by returning it perturbed with Gaussian noise.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the gaussian_mechanism on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Result to be released privately via the Gaussian mechanism. Atomic type must be numeric.
/// * `sensitivity` - Array - Override the sensitivity computed by the library. Rejected unless `protect_sensitivity` is disabled.
/// 
/// # Returns
/// * `Value` - Array - Original data perturbed with Gaussian noise.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GaussianMechanism {
    /// Object describing the type and amount of privacy to be used for the mechanism release.
    #[prost(message, repeated, tag="1")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
    /// Set to enable use of the analytic gaussian mechanism.
    #[prost(bool, tag="2")]
    pub analytic: bool,
}
/// GreaterThan Component
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the greater_than on the arguments.
/// 
/// # Arguments
/// * `left` - Array - Atomic values must be numeric and of the same type. Type must match right.
/// * `right` - Array - Atomic values must be numeric and of the same type. Type must match left.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GreaterThan {
}
/// Histogram Component
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the histogram on the arguments.
/// 
/// # Arguments
/// * `data` - Array
/// * `edges` - Jagged - Set of edges to bin continuous-valued data. Used only if data are of `continuous` nature. Must have a value if categories not specified.
/// * `categories` - Jagged - Set of categories in data. Used only if data are of `categorical` nature. Must have a value if edges not specified.
/// * `null_value` - Array - The value to which elements not included in `categories` will be mapped for each column of the data. Used only if `categories` is not `None`.
/// * `inclusive_left` -  - Whether or not the left edge of the bin is inclusive. If `true` bins are of the form [lower, upper). Otherwise, bins are of the form (lower, upper]. Used only if data are of `continuous` nature.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Histogram {
}
/// Impute Component
/// 
/// Replaces null values with draws from a specified distribution.
/// 
/// If the `categories` argument is provided, the data are considered to be categorical regardless of atomic type and the elements provided in `null_value` will be replaced with those in `categories` according to `weights`.
/// 
/// If the `categories` argument is not provided, the data are considered to be numeric and elements that are `f64::NAN` will be replaced according to the specified distribution.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the impute on the arguments.
/// 
/// # Arguments
/// * `data` - Array - The data for which null values will be imputed.
/// * `lower` - Array - A lower bound on data elements for each column. Used only if `categories` is `None`.
/// * `upper` - Array - An upper bound on data elements for each column. Used only if `categories` is `None`.
/// * `categories` - Jagged - The set of categories you want to be represented for each column of the data, if the data is categorical. Atomic type must match atomic type of data.
/// * `null_values` - Jagged - The set of values that are considered null for each column of the data, if the data is categorical. Atomic type must match atomic type of data.
/// * `weights` - Jagged - Optional. The weight of each category when imputing. Uniform weights are used if not specified.
/// * `distribution` - String - The distribution to be used when imputing records. Used only if `categories` is `None`.
/// * `shift` - Array - The expectation of the Gaussian distribution to be used for imputation. Used only if `distribution` is `Gaussian`.
/// * `scale` - Array - The standard deviation of the Gaussian distribution to be used for imputation. Used only if `distribution` is `Gaussian`.
/// 
/// # Returns
/// * `Value` - Array - Data with null values replaced by imputed values.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Impute {
}
/// Index Component
/// 
/// Index into data frames, partitions and arrays to retrieve homogeneously typed contiguous arrays
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the index on the arguments.
/// 
/// # Arguments
/// * `data` - Indexmap
/// * `names` - Array
/// * `indices` - Array
/// * `mask` - Array
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Index {
}
/// LaplaceMechanism Component
/// 
/// Privatizes a result by returning it perturbed with Laplace noise.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the laplace_mechanism on the arguments.
/// 
/// # Arguments
/// * `data` - Array - True value to be released privately via the Laplace mechanism.
/// * `sensitivity` - Array - Override the sensitivity computed by the library. Rejected unless `protect_sensitivity` is disabled.
/// 
/// # Returns
/// * `Value` - Array - Original data perturbed with Laplace noise.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LaplaceMechanism {
    /// Object describing the type and amount of privacy to be used for the mechanism release.
    #[prost(message, repeated, tag="1")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
}
/// LessThan Component
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the less_than on the arguments.
/// 
/// # Arguments
/// * `left` - Array - Atomic type must be numeric, and match with atomic type of right.
/// * `right` - Array - Atomic type must be numeric, and match with atomic type of left.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LessThan {
}
/// Literal Component
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the literal on the arguments.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Literal {
}
/// Log Component
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the log on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Atomic type must be float.
/// * `base` - Array
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Log {
}
/// And Component
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the logical_and on the arguments.
/// 
/// # Arguments
/// * `left` - Array - Left argument for the logical AND.
/// * `right` - Array - Right argument for the logical AND.
/// 
/// # Returns
/// * `Value` - Array - Logical AND of left and right.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct And {
}
/// Or Component
/// 
/// left and right arguments must share the same data types
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the logical_or on the arguments.
/// 
/// # Arguments
/// * `left` - Array
/// * `right` - Array
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Or {
}
/// Map Component
/// 
/// Apply Component to each data partition.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the map on the arguments.
/// 
/// # Returns
/// * `Value` - Indexmap
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Map {
    #[prost(message, optional, boxed, tag="1")]
    pub component: ::std::option::Option<::std::boxed::Box<Component>>,
}
/// Materialize Component
/// 
/// Load a tabular frame from a data source
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the materialize on the arguments.
/// 
/// # Arguments
/// * `column_names` - Array
/// 
/// # Returns
/// * `Value` - Dataframe
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Materialize {
    #[prost(bool, tag="1")]
    pub public: bool,
    /// when set, skip the first line (header) in a csv
    #[prost(bool, tag="2")]
    pub skip_row: bool,
    /// Path to the file on the system.
    #[prost(string, tag="3")]
    pub file_path: std::string::String,
}
/// Maximum Component
/// 
/// Find the maximum value of each column in the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the maximum on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Data for which you want the maximum value in each column.
/// * `candidates` - Array - Set from which the Exponential mechanism will return an element.
/// 
/// # Returns
/// * `Value` - Array - Maximum of each column in the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Maximum {
}
/// Mean Component
/// 
/// Calculates the arithmetic mean of each column in the provided data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the mean on the arguments.
/// 
/// # Arguments
/// * `data` - Array
/// 
/// # Returns
/// * `Value` - Array - Arithmetic mean for each column of the data in question.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mean {
}
/// Median Component
/// 
/// Find the median value of each column in the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the median on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Data for which you want the median value in each column.
/// * `candidates` - Array - Set from which to compute scores for the Exponential mechanism.
/// 
/// # Returns
/// * `Value` - Array - Median of each column in the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Median {
}
/// Minimum Component
/// 
/// Find the minimum value of each column in the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the minimum on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Data for which you want the maximum value in each column.
/// * `candidates` - Array - Set from which the Exponential mechanism will return an element.
/// 
/// # Returns
/// * `Value` - Array - Maximum of each column in the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Minimum {
}
/// Modulo Component
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the modulo on the arguments.
/// 
/// # Arguments
/// * `left` - Array - Atomic type must be numeric. Atomic type must match right.
/// * `right` - Array - Atomic type must be numeric. Atomic type must match left.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Modulo {
}
/// Multiply Component
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the multiply on the arguments.
/// 
/// # Arguments
/// * `left` - Array - Atomic type must be numeric. Atomic type must match right.
/// * `right` - Array - Atomic type must be numeric. Atomic type must match left.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Multiply {
}
/// Negate Component
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the negate on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Atomic type must be boolean.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Negate {
}
/// Negative Component
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the negative on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Atomic type must be numeric.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Negative {
}
/// Partition Component
/// 
/// Split the rows of data into either k equally sized partitions, or by the categories of a vector
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the partition on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Must be a dataframe or an array
/// * `num_partitions` - Array
/// * `by` - Array
/// 
/// # Returns
/// * `Value` - Indexmap
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Partition {
}
/// Power Component
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the power on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Atomic types must be numeric and homogenous.
/// * `radical` - Array - Atomic values may not be negative.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Power {
}
/// Quantile Component
/// 
/// Get values corresponding to specified quantiles for each column of the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the quantile on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Atomic type must be numeric.
/// * `candidates` - Array - Set from which the Exponential mechanism will return an element. Type must match with atomic type of data. This value must be column-conformable with data.
/// 
/// # Returns
/// * `Value` - Array - Quantile values for each column.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Quantile {
    /// Desired quantiles, defined on `[0,1]`. Examples: 0: min, 0.5: median, 1: max
    #[prost(double, tag="1")]
    pub alpha: f64,
    /// Interpolation strategy. One of [`lower`, `upper`, `midpoint`, `nearest`, `linear`]
    #[prost(string, tag="2")]
    pub interpolation: std::string::String,
}
/// RawMoment Component
/// 
/// Returns sample estimate of kth raw moment for each column of the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the raw_moment on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Data for which you would like the kth raw moments. Atomic data type must be float.
/// 
/// # Returns
/// * `Value` - Array - kth raw sample moment for each column.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RawMoment {
    /// Indicate the kth integer statistical moment.
    #[prost(uint32, tag="1")]
    pub order: u32,
}
/// Reshape Component
/// 
/// Reshapes a row vector into a matrix.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the reshape on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Vector of data to stack into a matrix. A Indexmap of matrices will be emitted if multiple rows are provided.
/// 
/// # Returns
/// * `Value` - Array - Reshape of data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Reshape {
    /// Set if data are elements from the upper triangle of a symmetric matrix.
    #[prost(bool, tag="1")]
    pub symmetric: bool,
    /// Consecutive elements of either the `row` or `column` reside next to each other. Note that multi-row inputs are reshaped to partitional outputs, having one matrix per partition.
    #[prost(string, tag="2")]
    pub layout: std::string::String,
    /// The shape of the output matrix. Dimensionality may not be greater than 2.
    #[prost(uint32, repeated, tag="3")]
    pub shape: ::std::vec::Vec<u32>,
}
/// Resize Component
/// 
/// Resizes the data in question to be consistent with a provided sample size, `n`.
/// 
/// The library does not, in general, assume that the sample size of the data being analyzed is known. This introduces a number of problems around how to calculate statistics that are a function of the sample size.
/// 
/// To address this problem, the library asks the user to provide `n`, an estimate of the true sample size based on their own beliefs about the data or a previous differentially private count of the number of rows in the data. This component then either subsamples or appends to the data in order to make it consistent with the provided `n`.
/// 
/// Note that lower/upper/categorical arguments must be provided, or lower/upper/categorical properties must be known on data.
/// 
/// Note that if using categories constraint, data are treated as categorical regardless of atomic type.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the resize on the arguments.
/// 
/// # Arguments
/// * `data` - Array - The data to be resized. Atomic type of data must match atomic type of categories. If categories not populated, data are treated as numeric and any necessary imputation is done according to a continuous distribution.
/// * `number_rows` - Array - An estimate of the number of rows in the data. This could be the guess of the user, or the result of a DP release. Cannot be set with minimum_rows.
/// * `number_columns` - Array - An estimate of the number of columns in the data. This must be the guess of the user, if not previously known (optional). A non-empty value must be positive. A non-empty value is incompatiable with an attempt to resize number of columns and results in an error.
/// * `lower` - Array - A lower bound on data elements for each column. This value must be less than upper.
/// * `upper` - Array - An upper bound on data elements for each column. This value must be greater than lower.
/// * `categories` - Jagged - The set of categories you want to be represented for each column of the data, if the data is categorical. Atomic type of data must match atomic type of categories.
/// * `weights` - Jagged - Optional. The weight of each category when imputing. Uniform weights are used if not specified.
/// * `distribution` - String - The distribution to be used when imputing records.
/// * `shift` - Array - The expectation of the Gaussian distribution used for imputation (used only if `distribution = Gaussian`).
/// * `scale` - Array - The standard deviation of the Gaussian distribution used for imputation (used only if `distribution = Gaussian`).
/// * `sample_proportion` - Array - The proportion of underlying data that may be used to construct the new data. May be > 1.
/// * `minimum_rows` - Array - Only add synthetic data if the actual row count is less than this number. No sampling is performed. Cannot be set with `number_rows`
/// 
/// # Returns
/// * `Value` - Array - A resized version of data consistent with the provided `n`
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Resize {
}
/// RowMax Component
/// 
/// Returns the maximum of the left and right arguments, per row. Note that left and right arguments must share the same data types.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the row_max on the arguments.
/// 
/// # Arguments
/// * `left` - Array - Member data type must match that of right.
/// * `right` - Array - Member data type must match that of left.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RowMax {
}
/// RowMin Component
/// 
/// Returns the minimum of the left and right arguments, per row. Note that left and right arguments must share the same data types.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the row_min on the arguments.
/// 
/// # Arguments
/// * `left` - Array - Member data type must match that of right.
/// * `right` - Array - Member data type must match that of left.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RowMin {
}
/// SimpleGeometricMechanism Component
/// 
/// Privatizes a result by returning it perturbed with Geometric noise.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the simple_geometric_mechanism on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Result to be released privately via the Geometric mechanism. Member data type must be integer.
/// * `lower` - Array - Lower bound of the statistic to be privatized. Member data type must be integer.
/// * `upper` - Array - Upper bound of the statistic to be privatized. Member data type must be integer.
/// * `sensitivity` - Array - Override the sensitivity computed by the library. Rejected unless `protect_sensitivity` is disabled.
/// 
/// # Returns
/// * `Value` - Array - Original data perturbed with Geometric noise.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SimpleGeometricMechanism {
    /// Object describing the type and amount of privacy to be used for the mechanism release. Values of zero or less, and values of greater than one, will result in warnings.
    #[prost(message, repeated, tag="1")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
}
/// SnappingMechanism Component
/// 
/// Privatizes a result by returning it perturbed via the Snapping mechanism. This mechanism is generally intended for non-integer numerical data. Note that snapping may not operate on integers when floating-point protections are enabled. For this situation, use the geometric mechanism instead.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the snapping_mechanism on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Result to be released privately via the Snapping mechanism. Array members must be of type float or of type integer.
/// * `lower` - Array - Estimated minimum possible value of the data. Only useful for the snapping mechanism. This argument is required.
/// * `upper` - Array - Estimated maximum possible value of the statistic. Only useful for the snapping mechanism. This argument is required.
/// * `binding_probability` - Array - Upper bound on probability that final clamp binds. Must be within [0, 1).
/// * `sensitivity` - Array - Override the sensitivity computed by the library. Rejected unless `protect_sensitivity` is disabled.
/// 
/// # Returns
/// * `Value` - Array - Original data perturbed via the Snapping mechanism.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SnappingMechanism {
    /// Object describing the type and amount of privacy to be used for the mechanism release.
    #[prost(message, repeated, tag="1")]
    pub privacy_usage: ::std::vec::Vec<PrivacyUsage>,
}
/// Subtract Component
/// 
/// Mathematical subtraction. Value types of arguments must match.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the subtract on the arguments.
/// 
/// # Arguments
/// * `left` - Array - Value from which to subtract. Must be of type float or integer.
/// * `right` - Array - Value which to subtract. Must be of type float or integer.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Subtract {
}
/// Sum Component
/// 
/// Calculates the sum of each column of the data. Data must be of type float or integer.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the sum on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Data for which you want the sum of each column.
/// 
/// # Returns
/// * `Value` - Array - Sum of each column of the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Sum {
}
/// TheilSen Component
/// 
/// Returns slope and intercept estimates for point pairs
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the theil_sen on the arguments.
/// 
/// # Arguments
/// * `data_x` - Array - value(s) from the first coordinate axis
/// * `data_y` - Array - value(s) from the second coordinate axis
/// 
/// # Returns
/// * `Value` - Array - All slope and intercept estimates for point pairs
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TheilSen {
    /// Theil-Sen implementation to use. One of [`theil-sen`, `theil-sen-k-match`]
    #[prost(string, tag="1")]
    pub implementation: std::string::String,
    /// Number of trials to run for Theil-Sen K Match.
    #[prost(uint32, tag="2")]
    pub k: u32,
}
/// ToBool Component
/// 
/// Cast data to a bool atomic type.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the to_bool on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Data to be cast to Boolean type.
/// * `true_label` - Array - Positive class (class to be mapped to `true`) for each column.
/// 
/// # Returns
/// * `Value` - Array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToBool {
}
/// ToDataframe Component
/// 
/// Name columns of an array to produce a Dataframe with the specified names. Typically used when partitioning a dataframe with preprocessed columns.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the to_dataframe on the arguments.
/// 
/// # Arguments
/// * `data` - Array - ndarray (structured or homogeneous), Iterable, dict, or DataFrame
/// * `names` - Array - Column labels to use for resulting frame. Will default to RangeIndex (0, 1, 2, …, n) if no column labels are provided.
/// 
/// # Returns
/// * `Value` - Dataframe - Dataframe in target language, for example <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html">pandas.DataFrame</a>.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToDataframe {
}
/// ToFloat Component
/// 
/// Cast data to a float atomic type.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the to_float on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Data to be cast to float.
/// 
/// # Returns
/// * `Value` - Array - Array containing the converted float value(s).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToFloat {
}
/// ToInt Component
/// 
/// Cast data to a int atomic type.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the to_int on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Data to be cast to integer type.
/// * `lower` - Array - Minimum allowable imputation value. Integers cannot represent null, so values that cannot be parsed are imputed.
/// * `upper` - Array - Maximum allowable imputation value.
/// 
/// # Returns
/// * `Value` - Array - Array containing the converted integer value(s).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToInt {
}
/// ToString Component
/// 
/// Cast data to a string atomic type.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the to_string on the arguments.
/// 
/// # Arguments
/// * `data` - Array - Data to be cast to string type.
/// 
/// # Returns
/// * `Value` - Array - The return is the result of the to_string on the arguments.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ToString {
}
/// Union Component
/// 
/// Union the arrays in the arguments into one array.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the union on the arguments.
/// 
/// # Returns
/// * `Value` - Array - Array (or indexmap of arrays) containing item(s) representing the concatenation of all partitions
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Union {
    /// When set, the output is an array. When unset, the output is an indexmap of arrays.
    #[prost(bool, tag="1")]
    pub flatten: bool,
}
/// Variance Component
/// 
/// Calculates the sample variance for each column of the data.
/// 
/// This struct represents an abstract computation. Arguments are provided via the graph. Additional options are set via the fields on this struct. The return is the result of the variance on the arguments.
/// 
/// # Arguments
/// * `data` - Array
/// 
/// # Returns
/// * `Value` - Array - Sample variance for each column of the data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Variance {
    /// Whether or not to use the finite sample correction (Bessel's correction) to correct the bias in the estimation of the population variance.
    #[prost(bool, tag="1")]
    pub finite_sample_correction: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Error {
    #[prost(string, tag="1")]
    pub message: std::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Analysis {
    #[prost(message, optional, tag="1")]
    pub privacy_definition: ::std::option::Option<PrivacyDefinition>,
    #[prost(message, optional, tag="2")]
    pub computation_graph: ::std::option::Option<ComputationGraph>,
}
/// The definition of privacy determines parameters for sensitivity derivations and the set of available algorithms.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PrivacyDefinition {
    /// Privacy leakage with respect `group_size` number of rows. This is typically one.
    #[prost(uint32, tag="1")]
    pub group_size: u32,
    /// Define the kind of perturbation that may be applied to a dataset to create a neighboring dataset.
    #[prost(enumeration="privacy_definition::Neighboring", tag="2")]
    pub neighboring: i32,
    /// enable to reject the use of algorithms using delta when n is not known
    /// enable to reject the use of algorithms when some soft violations of assumptions are observed
    /// - epsilon greater than one with the gaussian mechanism
    #[prost(bool, tag="3")]
    pub strict_parameter_checks: bool,
    /// enable for tighter bounds checking to prevent leaks via overflow/underflow
    #[prost(bool, tag="4")]
    pub protect_overflow: bool,
    /// enable if side-channel elapsed execution time is considered part of the release
    #[prost(bool, tag="5")]
    pub protect_elapsed_time: bool,
    /// enable if side-channel memory usage is considered part of the release
    #[prost(bool, tag="6")]
    pub protect_memory_utilization: bool,
    /// enable to block mechanisms known to be vulnerable to floating point attacks
    #[prost(bool, tag="7")]
    pub protect_floating_point: bool,
    /// enable to prevent manual insertion of sensitivity to mechanisms
    #[prost(bool, tag="8")]
    pub protect_sensitivity: bool,
}
pub mod privacy_definition {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum Neighboring {
        Substitute = 0,
        AddRemove = 1,
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ComputationGraph {
    #[prost(map="uint32, message", tag="1")]
    pub value: ::std::collections::HashMap<u32, Component>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Release {
    #[prost(map="uint32, message", tag="1")]
    pub values: ::std::collections::HashMap<u32, ReleaseNode>,
}
/// derived properties for the top-level Value type
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ValueProperties {
    #[prost(oneof="value_properties::Variant", tags="1, 2, 3, 4, 5")]
    pub variant: ::std::option::Option<value_properties::Variant>,
}
pub mod value_properties {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Variant {
        #[prost(message, tag="1")]
        Dataframe(super::DataframeProperties),
        #[prost(message, tag="2")]
        Partitions(super::PartitionsProperties),
        #[prost(message, tag="3")]
        Array(super::ArrayProperties),
        #[prost(message, tag="4")]
        Jagged(super::JaggedProperties),
        #[prost(message, tag="5")]
        Function(super::FunctionProperties),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArgumentProperties {
    #[prost(message, repeated, tag="1")]
    pub keys: ::std::vec::Vec<IndexKey>,
    #[prost(message, repeated, tag="2")]
    pub values: ::std::vec::Vec<ValueProperties>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataframeProperties {
    #[prost(message, repeated, tag="1")]
    pub keys: ::std::vec::Vec<IndexKey>,
    #[prost(message, repeated, tag="2")]
    pub values: ::std::vec::Vec<ValueProperties>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PartitionsProperties {
    #[prost(message, repeated, tag="1")]
    pub keys: ::std::vec::Vec<IndexKey>,
    #[prost(message, repeated, tag="2")]
    pub values: ::std::vec::Vec<ValueProperties>,
}
/// sub-properties for Value::* types that may be aggregated
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AggregatorProperties {
    #[prost(message, optional, tag="1")]
    pub component: ::std::option::Option<Component>,
    #[prost(message, optional, tag="2")]
    pub properties: ::std::option::Option<ArgumentProperties>,
    #[prost(message, optional, tag="3")]
    pub lipschitz_constants: ::std::option::Option<Value>,
}
//// derived properties for the Value::Array
////    a homogeneously-typed (0, 1, 2)-dimensional array
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArrayProperties {
    //// length of axis zero. May be unknown
    #[prost(message, optional, tag="1")]
    pub num_records: ::std::option::Option<I64Null>,
    //// length of axis one. If dimensionality is one, then one. May be unknown
    #[prost(message, optional, tag="2")]
    pub num_columns: ::std::option::Option<I64Null>,
    //// true if data may contain null values
    #[prost(bool, tag="3")]
    pub nullity: bool,
    //// number of records one individual may influence
    #[prost(uint32, tag="4")]
    pub c_stability: u32,
    //// description of the aggregation that has been applied to the data
    //// used to help compute sensitivity in the mechanisms
    #[prost(message, optional, tag="5")]
    pub aggregator: ::std::option::Option<AggregatorProperties>,
    //// atomic type
    #[prost(enumeration="DataType", tag="6")]
    pub data_type: i32,
    //// true if the data has been sanitized
    #[prost(bool, tag="7")]
    pub releasable: bool,
    //// node_id of the dataset this observation originated from
    //// used to check for conformability, is erased upon resize, is reset upon filter
    #[prost(message, optional, tag="8")]
    pub dataset_id: ::std::option::Option<I64Null>,
    //// true if the row length is known to be greater than zero
    #[prost(bool, tag="9")]
    pub is_not_empty: bool,
    //// number of axes in the array
    #[prost(message, optional, tag="10")]
    pub dimensionality: ::std::option::Option<I64Null>,
    //// used for tracking subpartitions
    #[prost(message, repeated, tag="11")]
    pub group_id: ::std::vec::Vec<GroupId>,
    /// true if row ordering has not changed
    #[prost(bool, tag="12")]
    pub naturally_ordered: bool,
    /// proportion of records this array contains sampled from the original dataset
    #[prost(message, optional, tag="13")]
    pub sample_proportion: ::std::option::Option<F64Null>,
    /// useful to reference an intermediate calculation
    #[prost(uint32, tag="14")]
    pub node_id: u32,
    #[prost(oneof="array_properties::Nature", tags="100, 101")]
    pub nature: ::std::option::Option<array_properties::Nature>,
}
pub mod array_properties {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Nature {
        //// numerical bounds of each column
        #[prost(message, tag="100")]
        Continuous(super::NatureContinuous),
        //// categories of each column
        #[prost(message, tag="101")]
        Categorical(super::NatureCategorical),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NatureContinuous {
    #[prost(message, optional, tag="1")]
    pub minimum: ::std::option::Option<Array1dNull>,
    #[prost(message, optional, tag="2")]
    pub maximum: ::std::option::Option<Array1dNull>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NatureCategorical {
    #[prost(message, optional, tag="1")]
    pub categories: ::std::option::Option<Jagged>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GroupId {
    //// node id of partition
    #[prost(uint32, tag="1")]
    pub partition_id: u32,
    //// indexes referenced in the partition
    #[prost(message, optional, tag="2")]
    pub index: ::std::option::Option<IndexKey>,
}
//// derived properties for the Value::Jagged type
////   a homogeneously-typed vector of vectors
////   each vector represents a column
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JaggedProperties {
    //// number of records per column
    #[prost(message, optional, tag="1")]
    pub num_records: ::std::option::Option<Array1dI64>,
    //// true if the data may contain null values
    #[prost(bool, tag="2")]
    pub nullity: bool,
    //// description of the aggregation that has been applied to the data
    //// used to help compute sensitivity in the mechanisms
    #[prost(message, optional, tag="3")]
    pub aggregator: ::std::option::Option<AggregatorProperties>,
    //// atomic type
    #[prost(enumeration="DataType", tag="4")]
    pub data_type: i32,
    //// true if the data has been sanitized
    #[prost(bool, tag="5")]
    pub releasable: bool,
    #[prost(oneof="jagged_properties::Nature", tags="100, 101")]
    pub nature: ::std::option::Option<jagged_properties::Nature>,
}
pub mod jagged_properties {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Nature {
        //// numerical bounds of each column
        #[prost(message, tag="100")]
        Continuous(super::NatureContinuous),
        //// categories of each column
        #[prost(message, tag="101")]
        Categorical(super::NatureCategorical),
    }
}
/// derived properties for the Value::Function type
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FunctionProperties {
    #[prost(bool, tag="1")]
    pub releasable: bool,
}
/// properties for each node on a graph
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GraphProperties {
    #[prost(map="uint32, message", tag="1")]
    pub properties: ::std::collections::HashMap<u32, ValueProperties>,
    #[prost(message, repeated, tag="2")]
    pub warnings: ::std::vec::Vec<Error>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Accuracies {
    #[prost(message, repeated, tag="1")]
    pub values: ::std::vec::Vec<Accuracy>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Accuracy {
    #[prost(double, tag="1")]
    pub value: f64,
    #[prost(double, tag="2")]
    pub alpha: f64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ComponentExpansion {
    #[prost(map="uint32, message", tag="1")]
    pub computation_graph: ::std::collections::HashMap<u32, Component>,
    #[prost(map="uint32, message", tag="2")]
    pub properties: ::std::collections::HashMap<u32, ValueProperties>,
    #[prost(map="uint32, message", tag="3")]
    pub releases: ::std::collections::HashMap<u32, ReleaseNode>,
    #[prost(uint32, repeated, tag="4")]
    pub traversal: ::std::vec::Vec<u32>,
    #[prost(message, repeated, tag="5")]
    pub warnings: ::std::vec::Vec<Error>,
}
/// literals
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Value {
    /// bytes bytes = 1;
    #[prost(oneof="value::Data", tags="2, 3, 4, 5, 6")]
    pub data: ::std::option::Option<value::Data>,
}
pub mod value {
    /// bytes bytes = 1;
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Data {
        /// N-dimensional homogeneously typed array
        #[prost(message, tag="2")]
        Array(super::Array),
        /// Key-Value pairs
        #[prost(message, tag="3")]
        Dataframe(super::Dataframe),
        #[prost(message, tag="4")]
        Partitions(super::Partitions),
        /// Data structure with mixed column lengths
        #[prost(message, tag="5")]
        Jagged(super::Jagged),
        /// Evaluable function
        #[prost(message, tag="6")]
        Function(super::Function),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Dataframe {
    #[prost(message, repeated, tag="1")]
    pub keys: ::std::vec::Vec<IndexKey>,
    #[prost(message, repeated, tag="2")]
    pub values: ::std::vec::Vec<Value>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Partitions {
    #[prost(message, repeated, tag="1")]
    pub keys: ::std::vec::Vec<IndexKey>,
    #[prost(message, repeated, tag="2")]
    pub values: ::std::vec::Vec<Value>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Function {
    #[prost(message, optional, tag="1")]
    pub computation_graph: ::std::option::Option<ComputationGraph>,
    #[prost(message, optional, tag="2")]
    pub release: ::std::option::Option<Release>,
    #[prost(map="string, uint32", tag="3")]
    pub arguments: ::std::collections::HashMap<std::string::String, u32>,
    #[prost(map="string, uint32", tag="4")]
    pub outputs: ::std::collections::HashMap<std::string::String, u32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReleaseNode {
    #[prost(message, optional, tag="1")]
    pub value: ::std::option::Option<Value>,
    #[prost(message, optional, tag="2")]
    pub privacy_usages: ::std::option::Option<PrivacyUsages>,
    #[prost(bool, tag="3")]
    pub public: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IndexmapReleaseNode {
    #[prost(message, repeated, tag="1")]
    pub keys: ::std::vec::Vec<IndexKey>,
    #[prost(message, repeated, tag="2")]
    pub values: ::std::vec::Vec<ReleaseNode>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum FilterLevel {
    /// release from runtime should include public data (either literals or sanitized data)
    Public = 0,
    /// release from runtime should include public and prior known values
    PublicAndPrior = 1,
    /// release from runtime should include evaluations from all nodes
    All = 2,
}
// REQUESTS
// VALIDATOR API

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestValidateAnalysis {
    #[prost(message, optional, tag="1")]
    pub analysis: ::std::option::Option<Analysis>,
    #[prost(message, optional, tag="2")]
    pub release: ::std::option::Option<Release>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestComputePrivacyUsage {
    #[prost(message, optional, tag="1")]
    pub analysis: ::std::option::Option<Analysis>,
    #[prost(message, optional, tag="2")]
    pub release: ::std::option::Option<Release>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestGenerateReport {
    #[prost(message, optional, tag="1")]
    pub analysis: ::std::option::Option<Analysis>,
    #[prost(message, optional, tag="2")]
    pub release: ::std::option::Option<Release>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestGetProperties {
    #[prost(message, optional, tag="1")]
    pub analysis: ::std::option::Option<Analysis>,
    #[prost(message, optional, tag="2")]
    pub release: ::std::option::Option<Release>,
    /// only compute properties for these nodes. If empty, properties for all nodes are returned
    #[prost(uint32, repeated, tag="3")]
    pub node_ids: ::std::vec::Vec<u32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestAccuracyToPrivacyUsage {
    #[prost(message, optional, tag="1")]
    pub privacy_definition: ::std::option::Option<PrivacyDefinition>,
    #[prost(message, optional, tag="2")]
    pub component: ::std::option::Option<Component>,
    #[prost(message, optional, tag="3")]
    pub properties: ::std::option::Option<ArgumentProperties>,
    #[prost(message, optional, tag="4")]
    pub accuracies: ::std::option::Option<Accuracies>,
    #[prost(message, optional, tag="5")]
    pub public_arguments: ::std::option::Option<IndexmapReleaseNode>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestPrivacyUsageToAccuracy {
    #[prost(message, optional, tag="1")]
    pub privacy_definition: ::std::option::Option<PrivacyDefinition>,
    #[prost(message, optional, tag="2")]
    pub component: ::std::option::Option<Component>,
    #[prost(message, optional, tag="3")]
    pub properties: ::std::option::Option<ArgumentProperties>,
    #[prost(double, tag="4")]
    pub alpha: f64,
    #[prost(message, optional, tag="5")]
    pub public_arguments: ::std::option::Option<IndexmapReleaseNode>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestExpandComponent {
    #[prost(message, optional, tag="1")]
    pub component: ::std::option::Option<Component>,
    #[prost(message, optional, tag="2")]
    pub properties: ::std::option::Option<ArgumentProperties>,
    #[prost(message, optional, tag="3")]
    pub arguments: ::std::option::Option<IndexmapReleaseNode>,
    #[prost(message, optional, tag="4")]
    pub privacy_definition: ::std::option::Option<PrivacyDefinition>,
    #[prost(uint32, tag="5")]
    pub component_id: u32,
    #[prost(uint32, tag="6")]
    pub maximum_id: u32,
}
// REQUESTS
// RUNTIME API

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestRelease {
    #[prost(message, optional, tag="1")]
    pub analysis: ::std::option::Option<Analysis>,
    #[prost(message, optional, tag="2")]
    pub release: ::std::option::Option<Release>,
    /// enable to return stack traces in the error response variant
    #[prost(bool, tag="10")]
    pub stack_trace: bool,
    /// configure how much data should be returned from runtime
    #[prost(enumeration="FilterLevel", tag="11")]
    pub filter_level: i32,
}
// RESPONSES
// VALIDATOR API

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResponseValidateAnalysis {
    #[prost(oneof="response_validate_analysis::Value", tags="1, 2")]
    pub value: ::std::option::Option<response_validate_analysis::Value>,
}
pub mod response_validate_analysis {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Validated {
        #[prost(bool, tag="1")]
        pub value: bool,
        #[prost(string, tag="2")]
        pub message: std::string::String,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(message, tag="1")]
        Data(Validated),
        #[prost(message, tag="2")]
        Error(super::Error),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResponseComputePrivacyUsage {
    #[prost(oneof="response_compute_privacy_usage::Value", tags="1, 2")]
    pub value: ::std::option::Option<response_compute_privacy_usage::Value>,
}
pub mod response_compute_privacy_usage {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(message, tag="1")]
        Data(super::PrivacyUsage),
        #[prost(message, tag="2")]
        Error(super::Error),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResponseGenerateReport {
    #[prost(oneof="response_generate_report::Value", tags="1, 2")]
    pub value: ::std::option::Option<response_generate_report::Value>,
}
pub mod response_generate_report {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(string, tag="1")]
        Data(std::string::String),
        #[prost(message, tag="2")]
        Error(super::Error),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResponseGetProperties {
    #[prost(oneof="response_get_properties::Value", tags="1, 2")]
    pub value: ::std::option::Option<response_get_properties::Value>,
}
pub mod response_get_properties {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(message, tag="1")]
        Data(super::GraphProperties),
        #[prost(message, tag="2")]
        Error(super::Error),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResponseAccuracyToPrivacyUsage {
    #[prost(oneof="response_accuracy_to_privacy_usage::Value", tags="1, 2")]
    pub value: ::std::option::Option<response_accuracy_to_privacy_usage::Value>,
}
pub mod response_accuracy_to_privacy_usage {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(message, tag="1")]
        Data(super::PrivacyUsages),
        #[prost(message, tag="2")]
        Error(super::Error),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResponsePrivacyUsageToAccuracy {
    #[prost(oneof="response_privacy_usage_to_accuracy::Value", tags="1, 2")]
    pub value: ::std::option::Option<response_privacy_usage_to_accuracy::Value>,
}
pub mod response_privacy_usage_to_accuracy {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(message, tag="1")]
        Data(super::Accuracies),
        #[prost(message, tag="2")]
        Error(super::Error),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResponseExpandComponent {
    #[prost(oneof="response_expand_component::Value", tags="1, 2")]
    pub value: ::std::option::Option<response_expand_component::Value>,
}
pub mod response_expand_component {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(message, tag="1")]
        Data(super::ComponentExpansion),
        #[prost(message, tag="2")]
        Error(super::Error),
    }
}
// RESPONSES
// RUNTIME API

#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResponseRelease {
    #[prost(oneof="response_release::Value", tags="1, 2")]
    pub value: ::std::option::Option<response_release::Value>,
}
pub mod response_release {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Success {
        #[prost(message, optional, tag="1")]
        pub release: ::std::option::Option<super::Release>,
        #[prost(message, repeated, tag="2")]
        pub warnings: ::std::vec::Vec<super::Error>,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(message, tag="1")]
        Data(Success),
        #[prost(message, tag="2")]
        Error(super::Error),
    }
}