viam-rust-utils 0.5.2

// @generated
// A representation of the abstract syntax of the Common Expression Language.

/// An expression together with source information as returned by the parser.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ParsedExpr {
    /// The parsed expression.
    #[prost(message, optional, tag="2")]
    pub expr: ::core::option::Option<Expr>,
    /// The source info derived from input that generated the parsed `expr`.
    #[prost(message, optional, tag="3")]
    pub source_info: ::core::option::Option<SourceInfo>,
}
/// An abstract representation of a common expression.
///
/// Expressions are abstractly represented as a collection of identifiers,
/// select statements, function calls, literals, and comprehensions. All
/// operators with the exception of the '.' operator are modelled as function
/// calls. This makes it easy to represent new operators in the existing AST.
///
/// All references within expressions must resolve to a
/// \[Decl][google.api.expr.v1alpha1.Decl\] provided at type-check for an
/// expression to be valid. A reference may either be a bare identifier `name` or
/// a qualified identifier `google.api.name`. References may refer to either a
/// value or a function declaration.
///
/// For example, the expression `google.api.name.startsWith('expr')` references
/// the declaration `google.api.name` within a
/// \[Expr.Select][google.api.expr.v1alpha1.Expr.Select\] expression, and the
/// function declaration `startsWith`.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Expr {
    /// Required. An id assigned to this node by the parser which is unique in a
    /// given expression tree. This is used to associate type information and other
    /// attributes with a node in the parse tree.
    #[prost(int64, tag="2")]
    pub id: i64,
    /// Required. Variants of expressions.
    #[prost(oneof="expr::ExprKind", tags="3, 4, 5, 6, 7, 8, 9")]
    pub expr_kind: ::core::option::Option<expr::ExprKind>,
}
/// Nested message and enum types in `Expr`.
pub mod expr {
    /// An identifier expression. e.g. `request`.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Ident {
        /// Required. Holds a single, unqualified identifier, possibly preceded by a
        /// '.'.
        ///
        /// Qualified names are represented by the
        /// \[Expr.Select][google.api.expr.v1alpha1.Expr.Select\] expression.
        #[prost(string, tag="1")]
        pub name: ::prost::alloc::string::String,
    }
    /// A field selection expression. e.g. `request.auth`.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Select {
        /// Required. The target of the selection expression.
        ///
        /// For example, in the select expression `request.auth`, the `request`
        /// portion of the expression is the `operand`.
        #[prost(message, optional, boxed, tag="1")]
        pub operand: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
        /// Required. The name of the field to select.
        ///
        /// For example, in the select expression `request.auth`, the `auth` portion
        /// of the expression would be the `field`.
        #[prost(string, tag="2")]
        pub field: ::prost::alloc::string::String,
        /// Whether the select is to be interpreted as a field presence test.
        ///
        /// This results from the macro `has(request.auth)`.
        #[prost(bool, tag="3")]
        pub test_only: bool,
    }
    /// A call expression, including calls to predefined functions and operators.
    ///
    /// For example, `value == 10`, `size(map_value)`.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Call {
        /// The target of a method call-style expression. For example, `x` in
        /// `x.f()`.
        #[prost(message, optional, boxed, tag="1")]
        pub target: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
        /// Required. The name of the function or method being called.
        #[prost(string, tag="2")]
        pub function: ::prost::alloc::string::String,
        /// The arguments.
        #[prost(message, repeated, tag="3")]
        pub args: ::prost::alloc::vec::Vec<super::Expr>,
    }
    /// A list creation expression.
    ///
    /// Lists may either be homogeneous, e.g. `[1, 2, 3]`, or heterogeneous, e.g.
    /// `dyn([1, 'hello', 2.0])`
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CreateList {
        /// The elements part of the list.
        #[prost(message, repeated, tag="1")]
        pub elements: ::prost::alloc::vec::Vec<super::Expr>,
        /// The indices within the elements list which are marked as optional
        /// elements.
        ///
        /// When an optional-typed value is present, the value it contains
        /// is included in the list. If the optional-typed value is absent, the list
        /// element is omitted from the CreateList result.
        #[prost(int32, repeated, tag="2")]
        pub optional_indices: ::prost::alloc::vec::Vec<i32>,
    }
    /// A map or message creation expression.
    ///
    /// Maps are constructed as `{'key_name': 'value'}`. Message construction is
    /// similar, but prefixed with a type name and composed of field ids:
    /// `types.MyType{field_id: 'value'}`.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CreateStruct {
        /// The type name of the message to be created; empty when creating map
        /// literals.
        #[prost(string, tag="1")]
        pub message_name: ::prost::alloc::string::String,
        /// The entries in the creation expression.
        #[prost(message, repeated, tag="2")]
        pub entries: ::prost::alloc::vec::Vec<create_struct::Entry>,
    }
    /// Nested message and enum types in `CreateStruct`.
    pub mod create_struct {
        /// Represents an entry.
        #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Entry {
            /// Required. An id assigned to this node by the parser which is unique
            /// in a given expression tree. This is used to associate type
            /// information and other attributes with the node.
            #[prost(int64, tag="1")]
            pub id: i64,
            /// Required. The value assigned to the key.
            ///
            /// If the optional_entry field is true, the expression must resolve to an
            /// optional-typed value. If the optional value is present, the key will be
            /// set; however, if the optional value is absent, the key will be unset.
            #[prost(message, optional, tag="4")]
            pub value: ::core::option::Option<super::super::Expr>,
            /// Whether the key-value pair is optional.
            #[prost(bool, tag="5")]
            pub optional_entry: bool,
            /// The `Entry` key kinds.
            #[prost(oneof="entry::KeyKind", tags="2, 3")]
            pub key_kind: ::core::option::Option<entry::KeyKind>,
        }
        /// Nested message and enum types in `Entry`.
        pub mod entry {
            /// The `Entry` key kinds.
            #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum KeyKind {
                /// The field key for a message creator statement.
                #[prost(string, tag="2")]
                FieldKey(::prost::alloc::string::String),
                /// The key expression for a map creation statement.
                #[prost(message, tag="3")]
                MapKey(super::super::super::Expr),
            }
        }
    }
    /// A comprehension expression applied to a list or map.
    ///
    /// Comprehensions are not part of the core syntax, but enabled with macros.
    /// A macro matches a specific call signature within a parsed AST and replaces
    /// the call with an alternate AST block. Macro expansion happens at parse
    /// time.
    ///
    /// The following macros are supported within CEL:
    ///
    /// Aggregate type macros may be applied to all elements in a list or all keys
    /// in a map:
    ///
    /// *  `all`, `exists`, `exists_one` -  test a predicate expression against
    ///     the inputs and return `true` if the predicate is satisfied for all,
    ///     any, or only one value `list.all(x, x < 10)`.
    /// *  `filter` - test a predicate expression against the inputs and return
    ///     the subset of elements which satisfy the predicate:
    ///     `payments.filter(p, p > 1000)`.
    /// *  `map` - apply an expression to all elements in the input and return the
    ///     output aggregate type: `[1, 2, 3].map(i, i * i)`.
    ///
    /// The `has(m.x)` macro tests whether the property `x` is present in struct
    /// `m`. The semantics of this macro depend on the type of `m`. For proto2
    /// messages `has(m.x)` is defined as 'defined, but not set'. For proto3, the
    /// macro tests whether the property is set to its default. For map and struct
    /// types, the macro tests whether the property `x` is defined on `m`.
    ///
    /// Comprehensions for the standard environment macros evaluation can be best
    /// visualized as the following pseudocode:
    ///
    /// ```
    /// let `accu_var` = `accu_init`
    /// for (let `iter_var` in `iter_range`) {
    ///    if (!`loop_condition`) {
    ///      break
    ///    }
    ///    `accu_var` = `loop_step`
    /// }
    /// return `result`
    /// ```
    ///
    /// Comprehensions for the optional V2 macros which support map-to-map
    /// translation differ slightly from the standard environment macros in that
    /// they expose the key or index in addition to the value for each list
    /// or map entry:
    ///
    /// ```
    /// let `accu_var` = `accu_init`
    /// for (let `iter_var`, `iter_var2` in `iter_range`) {
    ///    if (!`loop_condition`) {
    ///      break
    ///    }
    ///    `accu_var` = `loop_step`
    /// }
    /// return `result`
    /// ```
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Comprehension {
        /// The name of the first iteration variable.
        /// For the single iteration variable macros, when iter_range is a list, this
        /// variable is the list element and when the iter_range is a map, this
        /// variable is the map key.
        #[prost(string, tag="1")]
        pub iter_var: ::prost::alloc::string::String,
        /// The name of the second iteration variable; empty if not set.
        /// This field is only set for comprehension v2 macros.
        #[prost(string, tag="8")]
        pub iter_var2: ::prost::alloc::string::String,
        /// The range over which the comprehension iterates.
        #[prost(message, optional, boxed, tag="2")]
        pub iter_range: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
        /// The name of the variable used for accumulation of the result.
        #[prost(string, tag="3")]
        pub accu_var: ::prost::alloc::string::String,
        /// The initial value of the accumulator.
        #[prost(message, optional, boxed, tag="4")]
        pub accu_init: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
        /// An expression which can contain iter_var, iter_var2, and accu_var.
        ///
        /// Returns false when the result has been computed and may be used as
        /// a hint to short-circuit the remainder of the comprehension.
        #[prost(message, optional, boxed, tag="5")]
        pub loop_condition: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
        /// An expression which can contain iter_var, iter_var2, and accu_var.
        ///
        /// Computes the next value of accu_var.
        #[prost(message, optional, boxed, tag="6")]
        pub loop_step: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
        /// An expression which can contain accu_var.
        ///
        /// Computes the result.
        #[prost(message, optional, boxed, tag="7")]
        pub result: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
    }
    /// Required. Variants of expressions.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ExprKind {
        /// A literal expression.
        #[prost(message, tag="3")]
        ConstExpr(super::Constant),
        /// An identifier expression.
        #[prost(message, tag="4")]
        IdentExpr(Ident),
        /// A field selection expression, e.g. `request.auth`.
        #[prost(message, tag="5")]
        SelectExpr(::prost::alloc::boxed::Box<Select>),
        /// A call expression, including calls to predefined functions and operators.
        #[prost(message, tag="6")]
        CallExpr(::prost::alloc::boxed::Box<Call>),
        /// A list creation expression.
        #[prost(message, tag="7")]
        ListExpr(CreateList),
        /// A map or message creation expression.
        #[prost(message, tag="8")]
        StructExpr(CreateStruct),
        /// A comprehension expression.
        #[prost(message, tag="9")]
        ComprehensionExpr(::prost::alloc::boxed::Box<Comprehension>),
    }
}
/// Represents a primitive literal.
///
/// Named 'Constant' here for backwards compatibility.
///
/// This is similar to the primitives supported in the well-known type
/// `google.protobuf.Value`, but richer so it can represent CEL's full range of
/// primitives.
///
/// Lists and structs are not included as constants as these aggregate types may
/// contain \[Expr][google.api.expr.v1alpha1.Expr\] elements which require
/// evaluation and are thus not constant.
///
/// Examples of literals include: `"hello"`, `b'bytes'`, `1u`, `4.2`, `-2`,
/// `true`, `null`.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Constant {
    /// Required. The valid constant kinds.
    #[prost(oneof="constant::ConstantKind", tags="1, 2, 3, 4, 5, 6, 7, 8, 9")]
    pub constant_kind: ::core::option::Option<constant::ConstantKind>,
}
/// Nested message and enum types in `Constant`.
pub mod constant {
    /// Required. The valid constant kinds.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ConstantKind {
        /// null value.
        #[prost(enumeration="::prost_types::NullValue", tag="1")]
        NullValue(i32),
        /// boolean value.
        #[prost(bool, tag="2")]
        BoolValue(bool),
        /// int64 value.
        #[prost(int64, tag="3")]
        Int64Value(i64),
        /// uint64 value.
        #[prost(uint64, tag="4")]
        Uint64Value(u64),
        /// double value.
        #[prost(double, tag="5")]
        DoubleValue(f64),
        /// string value.
        #[prost(string, tag="6")]
        StringValue(::prost::alloc::string::String),
        /// bytes value.
        #[prost(bytes, tag="7")]
        BytesValue(::prost::alloc::vec::Vec<u8>),
        /// protobuf.Duration value.
        ///
        /// Deprecated: duration is no longer considered a builtin CEL type.
        #[prost(message, tag="8")]
        DurationValue(::prost_types::Duration),
        /// protobuf.Timestamp value.
        ///
        /// Deprecated: timestamp is no longer considered a builtin CEL type.
        #[prost(message, tag="9")]
        TimestampValue(::prost_types::Timestamp),
    }
}
/// Source information collected at parse time.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SourceInfo {
    /// The syntax version of the source, e.g. `cel1`.
    #[prost(string, tag="1")]
    pub syntax_version: ::prost::alloc::string::String,
    /// The location name. All position information attached to an expression is
    /// relative to this location.
    ///
    /// The location could be a file, UI element, or similar. For example,
    /// `acme/app/AnvilPolicy.cel`.
    #[prost(string, tag="2")]
    pub location: ::prost::alloc::string::String,
    /// Monotonically increasing list of code point offsets where newlines
    /// `\n` appear.
    ///
    /// The line number of a given position is the index `i` where for a given
    /// `id` the `line_offsets\[i\] < id_positions\[id\] < line_offsets\[i+1\]`. The
    /// column may be derived from `id_positions\[id\] - line_offsets\[i\]`.
    #[prost(int32, repeated, tag="3")]
    pub line_offsets: ::prost::alloc::vec::Vec<i32>,
    /// A map from the parse node id (e.g. `Expr.id`) to the code point offset
    /// within the source.
    #[prost(map="int64, int32", tag="4")]
    pub positions: ::std::collections::HashMap<i64, i32>,
    /// A map from the parse node id where a macro replacement was made to the
    /// call `Expr` that resulted in a macro expansion.
    ///
    /// For example, `has(value.field)` is a function call that is replaced by a
    /// `test_only` field selection in the AST. Likewise, the call
    /// `list.exists(e, e > 10)` translates to a comprehension expression. The key
    /// in the map corresponds to the expression id of the expanded macro, and the
    /// value is the call `Expr` that was replaced.
    #[prost(map="int64, message", tag="5")]
    pub macro_calls: ::std::collections::HashMap<i64, Expr>,
    /// A list of tags for extensions that were used while parsing or type checking
    /// the source expression. For example, optimizations that require special
    /// runtime support may be specified.
    ///
    /// These are used to check feature support between components in separate
    /// implementations. This can be used to either skip redundant work or
    /// report an error if the extension is unsupported.
    #[prost(message, repeated, tag="6")]
    pub extensions: ::prost::alloc::vec::Vec<source_info::Extension>,
}
/// Nested message and enum types in `SourceInfo`.
pub mod source_info {
    /// An extension that was requested for the source expression.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Extension {
        /// Identifier for the extension. Example: constant_folding
        #[prost(string, tag="1")]
        pub id: ::prost::alloc::string::String,
        /// If set, the listed components must understand the extension for the
        /// expression to evaluate correctly.
        ///
        /// This field has set semantics; repeated values should be deduplicated.
        #[prost(enumeration="extension::Component", repeated, tag="2")]
        pub affected_components: ::prost::alloc::vec::Vec<i32>,
        /// Version info. May be skipped if it isn't meaningful for the extension.
        /// (for example constant_folding might always be v0.0).
        #[prost(message, optional, tag="3")]
        pub version: ::core::option::Option<extension::Version>,
    }
    /// Nested message and enum types in `Extension`.
    pub mod extension {
        /// Version
        #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Version {
            /// Major version changes indicate different required support level from
            /// the required components.
            #[prost(int64, tag="1")]
            pub major: i64,
            /// Minor version changes must not change the observed behavior from
            /// existing implementations, but may be provided informationally.
            #[prost(int64, tag="2")]
            pub minor: i64,
        }
        /// CEL component specifier.
        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
        #[repr(i32)]
        pub enum Component {
            /// Unspecified, default.
            Unspecified = 0,
            /// Parser. Converts a CEL string to an AST.
            Parser = 1,
            /// Type checker. Checks that references in an AST are defined and types
            /// agree.
            TypeChecker = 2,
            /// Runtime. Evaluates a parsed and optionally checked CEL AST against a
            /// context.
            Runtime = 3,
        }
        impl Component {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Component::Unspecified => "COMPONENT_UNSPECIFIED",
                    Component::Parser => "COMPONENT_PARSER",
                    Component::TypeChecker => "COMPONENT_TYPE_CHECKER",
                    Component::Runtime => "COMPONENT_RUNTIME",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "COMPONENT_UNSPECIFIED" => Some(Self::Unspecified),
                    "COMPONENT_PARSER" => Some(Self::Parser),
                    "COMPONENT_TYPE_CHECKER" => Some(Self::TypeChecker),
                    "COMPONENT_RUNTIME" => Some(Self::Runtime),
                    _ => None,
                }
            }
        }
    }
}
/// A specific position in source.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SourcePosition {
    /// The source location name (e.g. file name).
    #[prost(string, tag="1")]
    pub location: ::prost::alloc::string::String,
    /// The UTF-8 code unit offset.
    #[prost(int32, tag="2")]
    pub offset: i32,
    /// The 1-based index of the starting line in the source text
    /// where the issue occurs, or 0 if unknown.
    #[prost(int32, tag="3")]
    pub line: i32,
    /// The 0-based index of the starting position within the line of source text
    /// where the issue occurs.  Only meaningful if line is nonzero.
    #[prost(int32, tag="4")]
    pub column: i32,
}
// Protos for representing CEL declarations and typed checked expressions.

/// A CEL expression which has been successfully type checked.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CheckedExpr {
    /// A map from expression ids to resolved references.
    ///
    /// The following entries are in this table:
    ///
    /// - An Ident or Select expression is represented here if it resolves to a
    ///    declaration. For instance, if `a.b.c` is represented by
    ///    `select(select(id(a), b), c)`, and `a.b` resolves to a declaration,
    ///    while `c` is a field selection, then the reference is attached to the
    ///    nested select expression (but not to the id or or the outer select).
    ///    In turn, if `a` resolves to a declaration and `b.c` are field selections,
    ///    the reference is attached to the ident expression.
    /// - Every Call expression has an entry here, identifying the function being
    ///    called.
    /// - Every CreateStruct expression for a message has an entry, identifying
    ///    the message.
    #[prost(map="int64, message", tag="2")]
    pub reference_map: ::std::collections::HashMap<i64, Reference>,
    /// A map from expression ids to types.
    ///
    /// Every expression node which has a type different than DYN has a mapping
    /// here. If an expression has type DYN, it is omitted from this map to save
    /// space.
    #[prost(map="int64, message", tag="3")]
    pub type_map: ::std::collections::HashMap<i64, Type>,
    /// The source info derived from input that generated the parsed `expr` and
    /// any optimizations made during the type-checking pass.
    #[prost(message, optional, tag="5")]
    pub source_info: ::core::option::Option<SourceInfo>,
    /// The expr version indicates the major / minor version number of the `expr`
    /// representation.
    ///
    /// The most common reason for a version change will be to indicate to the CEL
    /// runtimes that transformations have been performed on the expr during static
    /// analysis. In some cases, this will save the runtime the work of applying
    /// the same or similar transformations prior to evaluation.
    #[prost(string, tag="6")]
    pub expr_version: ::prost::alloc::string::String,
    /// The checked expression. Semantically equivalent to the parsed `expr`, but
    /// may have structural differences.
    #[prost(message, optional, tag="4")]
    pub expr: ::core::option::Option<Expr>,
}
/// Represents a CEL type.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Type {
    /// The kind of type.
    #[prost(oneof="r#type::TypeKind", tags="1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14")]
    pub type_kind: ::core::option::Option<r#type::TypeKind>,
}
/// Nested message and enum types in `Type`.
pub mod r#type {
    /// List type with typed elements, e.g. `list<example.proto.MyMessage>`.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ListType {
        /// The element type.
        #[prost(message, optional, boxed, tag="1")]
        pub elem_type: ::core::option::Option<::prost::alloc::boxed::Box<super::Type>>,
    }
    /// Map type with parameterized key and value types, e.g. `map<string, int>`.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MapType {
        /// The type of the key.
        #[prost(message, optional, boxed, tag="1")]
        pub key_type: ::core::option::Option<::prost::alloc::boxed::Box<super::Type>>,
        /// The type of the value.
        #[prost(message, optional, boxed, tag="2")]
        pub value_type: ::core::option::Option<::prost::alloc::boxed::Box<super::Type>>,
    }
    /// Function type with result and arg types.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FunctionType {
        /// Result type of the function.
        #[prost(message, optional, boxed, tag="1")]
        pub result_type: ::core::option::Option<::prost::alloc::boxed::Box<super::Type>>,
        /// Argument types of the function.
        #[prost(message, repeated, tag="2")]
        pub arg_types: ::prost::alloc::vec::Vec<super::Type>,
    }
    /// Application defined abstract type.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct AbstractType {
        /// The fully qualified name of this abstract type.
        #[prost(string, tag="1")]
        pub name: ::prost::alloc::string::String,
        /// Parameter types for this abstract type.
        #[prost(message, repeated, tag="2")]
        pub parameter_types: ::prost::alloc::vec::Vec<super::Type>,
    }
    /// CEL primitive types.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum PrimitiveType {
        /// Unspecified type.
        Unspecified = 0,
        /// Boolean type.
        Bool = 1,
        /// Int64 type.
        ///
        /// Proto-based integer values are widened to int64.
        Int64 = 2,
        /// Uint64 type.
        ///
        /// Proto-based unsigned integer values are widened to uint64.
        Uint64 = 3,
        /// Double type.
        ///
        /// Proto-based float values are widened to double values.
        Double = 4,
        /// String type.
        String = 5,
        /// Bytes type.
        Bytes = 6,
    }
    impl PrimitiveType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                PrimitiveType::Unspecified => "PRIMITIVE_TYPE_UNSPECIFIED",
                PrimitiveType::Bool => "BOOL",
                PrimitiveType::Int64 => "INT64",
                PrimitiveType::Uint64 => "UINT64",
                PrimitiveType::Double => "DOUBLE",
                PrimitiveType::String => "STRING",
                PrimitiveType::Bytes => "BYTES",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PRIMITIVE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "BOOL" => Some(Self::Bool),
                "INT64" => Some(Self::Int64),
                "UINT64" => Some(Self::Uint64),
                "DOUBLE" => Some(Self::Double),
                "STRING" => Some(Self::String),
                "BYTES" => Some(Self::Bytes),
                _ => None,
            }
        }
    }
    /// Well-known protobuf types treated with first-class support in CEL.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    pub enum WellKnownType {
        /// Unspecified type.
        Unspecified = 0,
        /// Well-known protobuf.Any type.
        ///
        /// Any types are a polymorphic message type. During type-checking they are
        /// treated like `DYN` types, but at runtime they are resolved to a specific
        /// message type specified at evaluation time.
        Any = 1,
        /// Well-known protobuf.Timestamp type, internally referenced as `timestamp`.
        Timestamp = 2,
        /// Well-known protobuf.Duration type, internally referenced as `duration`.
        Duration = 3,
    }
    impl WellKnownType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                WellKnownType::Unspecified => "WELL_KNOWN_TYPE_UNSPECIFIED",
                WellKnownType::Any => "ANY",
                WellKnownType::Timestamp => "TIMESTAMP",
                WellKnownType::Duration => "DURATION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "WELL_KNOWN_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "ANY" => Some(Self::Any),
                "TIMESTAMP" => Some(Self::Timestamp),
                "DURATION" => Some(Self::Duration),
                _ => None,
            }
        }
    }
    /// The kind of type.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum TypeKind {
        /// Dynamic type.
        #[prost(message, tag="1")]
        Dyn(()),
        /// Null value.
        #[prost(enumeration="::prost_types::NullValue", tag="2")]
        Null(i32),
        /// Primitive types: `true`, `1u`, `-2.0`, `'string'`, `b'bytes'`.
        #[prost(enumeration="PrimitiveType", tag="3")]
        Primitive(i32),
        /// Wrapper of a primitive type, e.g. `google.protobuf.Int64Value`.
        #[prost(enumeration="PrimitiveType", tag="4")]
        Wrapper(i32),
        /// Well-known protobuf type such as `google.protobuf.Timestamp`.
        #[prost(enumeration="WellKnownType", tag="5")]
        WellKnown(i32),
        /// Parameterized list with elements of `list_type`, e.g. `list<timestamp>`.
        #[prost(message, tag="6")]
        ListType(::prost::alloc::boxed::Box<ListType>),
        /// Parameterized map with typed keys and values.
        #[prost(message, tag="7")]
        MapType(::prost::alloc::boxed::Box<MapType>),
        /// Function type.
        #[prost(message, tag="8")]
        Function(::prost::alloc::boxed::Box<FunctionType>),
        /// Protocol buffer message type.
        ///
        /// The `message_type` string specifies the qualified message type name. For
        /// example, `google.plus.Profile`.
        #[prost(string, tag="9")]
        MessageType(::prost::alloc::string::String),
        /// Type param type.
        ///
        /// The `type_param` string specifies the type parameter name, e.g. `list<E>`
        /// would be a `list_type` whose element type was a `type_param` type
        /// named `E`.
        #[prost(string, tag="10")]
        TypeParam(::prost::alloc::string::String),
        /// Type type.
        ///
        /// The `type` value specifies the target type. e.g. int is type with a
        /// target type of `Primitive.INT`.
        #[prost(message, tag="11")]
        Type(::prost::alloc::boxed::Box<super::Type>),
        /// Error type.
        ///
        /// During type-checking if an expression is an error, its type is propagated
        /// as the `ERROR` type. This permits the type-checker to discover other
        /// errors present in the expression.
        #[prost(message, tag="12")]
        Error(()),
        /// Abstract, application defined type.
        #[prost(message, tag="14")]
        AbstractType(AbstractType),
    }
}
/// Represents a declaration of a named value or function.
///
/// A declaration is part of the contract between the expression, the agent
/// evaluating that expression, and the caller requesting evaluation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Decl {
    /// The fully qualified name of the declaration.
    ///
    /// Declarations are organized in containers and this represents the full path
    /// to the declaration in its container, as in `google.api.expr.Decl`.
    ///
    /// Declarations used as
    /// \[FunctionDecl.Overload][google.api.expr.v1alpha1.Decl.FunctionDecl.Overload\]
    /// parameters may or may not have a name depending on whether the overload is
    /// function declaration or a function definition containing a result
    /// \[Expr][google.api.expr.v1alpha1.Expr\].
    #[prost(string, tag="1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The declaration kind.
    #[prost(oneof="decl::DeclKind", tags="2, 3")]
    pub decl_kind: ::core::option::Option<decl::DeclKind>,
}
/// Nested message and enum types in `Decl`.
pub mod decl {
    /// Identifier declaration which specifies its type and optional `Expr` value.
    ///
    /// An identifier without a value is a declaration that must be provided at
    /// evaluation time. An identifier with a value should resolve to a constant,
    /// but may be used in conjunction with other identifiers bound at evaluation
    /// time.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct IdentDecl {
        /// Required. The type of the identifier.
        #[prost(message, optional, tag="1")]
        pub r#type: ::core::option::Option<super::Type>,
        /// The constant value of the identifier. If not specified, the identifier
        /// must be supplied at evaluation time.
        #[prost(message, optional, tag="2")]
        pub value: ::core::option::Option<super::Constant>,
        /// Documentation string for the identifier.
        #[prost(string, tag="3")]
        pub doc: ::prost::alloc::string::String,
    }
    /// Function declaration specifies one or more overloads which indicate the
    /// function's parameter types and return type.
    ///
    /// Functions have no observable side-effects (there may be side-effects like
    /// logging which are not observable from CEL).
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FunctionDecl {
        /// Required. List of function overloads, must contain at least one overload.
        #[prost(message, repeated, tag="1")]
        pub overloads: ::prost::alloc::vec::Vec<function_decl::Overload>,
        /// Documentation string for the function that indicates the general purpose
        /// of the function and its behavior.
        ///
        /// Documentation strings for the function should be general purpose with
        /// specific examples provided in the overload doc string.
        ///
        /// Examples:
        ///
        ///      The 'in' operator tests whether an item exists in a collection.
        ///
        ///      The 'substring' function returns a substring of a target string.
        #[prost(string, tag="2")]
        pub doc: ::prost::alloc::string::String,
    }
    /// Nested message and enum types in `FunctionDecl`.
    pub mod function_decl {
        /// An overload indicates a function's parameter types and return type, and
        /// may optionally include a function body described in terms of
        /// \[Expr][google.api.expr.v1alpha1.Expr\] values.
        ///
        /// Functions overloads are declared in either a function or method
        /// call-style. For methods, the `params\[0\]` is the expected type of the
        /// target receiver.
        ///
        /// Overloads must have non-overlapping argument types after erasure of all
        /// parameterized type variables (similar as type erasure in Java).
        #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Overload {
            /// Required. Globally unique overload name of the function which reflects
            /// the function name and argument types.
            ///
            /// This will be used by a \[Reference][google.api.expr.v1alpha1.Reference\]
            /// to indicate the `overload_id` that was resolved for the function
            /// `name`.
            #[prost(string, tag="1")]
            pub overload_id: ::prost::alloc::string::String,
            /// List of function parameter \[Type][google.api.expr.v1alpha1.Type\]
            /// values.
            ///
            /// Param types are disjoint after generic type parameters have been
            /// replaced with the type `DYN`. Since the `DYN` type is compatible with
            /// any other type, this means that if `A` is a type parameter, the
            /// function types `int<A>` and `int<int>` are not disjoint. Likewise,
            /// `map<string, string>` is not disjoint from `map<K, V>`.
            ///
            /// When the `result_type` of a function is a generic type param, the
            /// type param name also appears as the `type` of on at least one params.
            #[prost(message, repeated, tag="2")]
            pub params: ::prost::alloc::vec::Vec<super::super::Type>,
            /// The type param names associated with the function declaration.
            ///
            /// For example, `function ex<K,V>(K key, map<K, V> map) : V` would yield
            /// the type params of `K, V`.
            #[prost(string, repeated, tag="3")]
            pub type_params: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
            /// Required. The result type of the function. For example, the operator
            /// `string.isEmpty()` would have `result_type` of `kind: BOOL`.
            #[prost(message, optional, tag="4")]
            pub result_type: ::core::option::Option<super::super::Type>,
            /// Whether the function is to be used in a method call-style `x.f(...)`
            /// or a function call-style `f(x, ...)`.
            ///
            /// For methods, the first parameter declaration, `params\[0\]` is the
            /// expected type of the target receiver.
            #[prost(bool, tag="5")]
            pub is_instance_function: bool,
            /// Examples for the overload and its expected return value, separated by
            /// newlines.
            ///
            /// Prefer using CEL literals in examples as they are easily consumed by
            /// humans and simple to validate with machines. The example should contain
            /// an expression with a literal return value in comments inline. If the
            /// expression example is too complex or would need an example for a
            /// variable that cannot be expressed in CEL, document the input and return
            /// in a comment preceding the example.
            ///
            /// Examples:
            ///
            ///      1 in [1, 2, 3] // true
            ///      'key' in {'key1: 1, 'key2': 2} // false
            ///      // Test whether one or more keys exist within a map.
            ///      // returns true if list_of_keys contains 'key2' or 'key3'
            ///      list_of_keys.exists(key, key in {'key3': 1, 'key2': 2})
            #[prost(string, tag="6")]
            pub doc: ::prost::alloc::string::String,
        }
    }
    /// Required. The declaration kind.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum DeclKind {
        /// Identifier declaration.
        #[prost(message, tag="2")]
        Ident(IdentDecl),
        /// Function declaration.
        #[prost(message, tag="3")]
        Function(FunctionDecl),
    }
}
/// Describes a resolved reference to a declaration.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Reference {
    /// The fully qualified name of the declaration.
    #[prost(string, tag="1")]
    pub name: ::prost::alloc::string::String,
    /// For references to functions, this is a list of `Overload.overload_id`
    /// values which match according to typing rules.
    ///
    /// If the list has more than one element, overload resolution among the
    /// presented candidates must happen at runtime because of dynamic types. The
    /// type checker attempts to narrow down this list as much as possible.
    ///
    /// Empty if this is not a reference to a
    /// \[Decl.FunctionDecl][google.api.expr.v1alpha1.Decl.FunctionDecl\].
    #[prost(string, repeated, tag="3")]
    pub overload_id: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// For references to constants, this may contain the value of the
    /// constant if known at compile time.
    #[prost(message, optional, tag="4")]
    pub value: ::core::option::Option<Constant>,
}
// Contains representations for CEL runtime values.

/// Represents a CEL value.
///
/// This is similar to `google.protobuf.Value`, but can represent CEL's full
/// range of values.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Value {
    /// Required. The valid kinds of values.
    #[prost(oneof="value::Kind", tags="1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 15")]
    pub kind: ::core::option::Option<value::Kind>,
}
/// Nested message and enum types in `Value`.
pub mod value {
    /// Required. The valid kinds of values.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        /// Null value.
        #[prost(enumeration="::prost_types::NullValue", tag="1")]
        NullValue(i32),
        /// Boolean value.
        #[prost(bool, tag="2")]
        BoolValue(bool),
        /// Signed integer value.
        #[prost(int64, tag="3")]
        Int64Value(i64),
        /// Unsigned integer value.
        #[prost(uint64, tag="4")]
        Uint64Value(u64),
        /// Floating point value.
        #[prost(double, tag="5")]
        DoubleValue(f64),
        /// UTF-8 string value.
        #[prost(string, tag="6")]
        StringValue(::prost::alloc::string::String),
        /// Byte string value.
        #[prost(bytes, tag="7")]
        BytesValue(::prost::alloc::vec::Vec<u8>),
        /// An enum value.
        #[prost(message, tag="9")]
        EnumValue(super::EnumValue),
        /// The proto message backing an object value.
        #[prost(message, tag="10")]
        ObjectValue(::prost_types::Any),
        /// Map value.
        #[prost(message, tag="11")]
        MapValue(super::MapValue),
        /// List value.
        #[prost(message, tag="12")]
        ListValue(super::ListValue),
        /// Type value.
        #[prost(string, tag="15")]
        TypeValue(::prost::alloc::string::String),
    }
}
/// An enum value.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EnumValue {
    /// The fully qualified name of the enum type.
    #[prost(string, tag="1")]
    pub r#type: ::prost::alloc::string::String,
    /// The value of the enum.
    #[prost(int32, tag="2")]
    pub value: i32,
}
/// A list.
///
/// Wrapped in a message so 'not set' and empty can be differentiated, which is
/// required for use in a 'oneof'.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListValue {
    /// The ordered values in the list.
    #[prost(message, repeated, tag="1")]
    pub values: ::prost::alloc::vec::Vec<Value>,
}
/// A map.
///
/// Wrapped in a message so 'not set' and empty can be differentiated, which is
/// required for use in a 'oneof'.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MapValue {
    /// The set of map entries.
    ///
    /// CEL has fewer restrictions on keys, so a protobuf map representation
    /// cannot be used.
    #[prost(message, repeated, tag="1")]
    pub entries: ::prost::alloc::vec::Vec<map_value::Entry>,
}
/// Nested message and enum types in `MapValue`.
pub mod map_value {
    /// An entry in the map.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Entry {
        /// The key.
        ///
        /// Must be unique with in the map.
        /// Currently only boolean, int, uint, and string values can be keys.
        #[prost(message, optional, tag="1")]
        pub key: ::core::option::Option<super::Value>,
        /// The value.
        #[prost(message, optional, tag="2")]
        pub value: ::core::option::Option<super::Value>,
    }
}
/// The state of an evaluation.
///
/// Can represent an initial, partial, or completed state of evaluation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EvalState {
    /// The unique values referenced in this message.
    #[prost(message, repeated, tag="1")]
    pub values: ::prost::alloc::vec::Vec<ExprValue>,
    /// An ordered list of results.
    ///
    /// Tracks the flow of evaluation through the expression.
    /// May be sparse.
    #[prost(message, repeated, tag="3")]
    pub results: ::prost::alloc::vec::Vec<eval_state::Result>,
}
/// Nested message and enum types in `EvalState`.
pub mod eval_state {
    /// A single evaluation result.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Result {
        /// The id of the expression this result is for.
        #[prost(int64, tag="1")]
        pub expr: i64,
        /// The index in `values` of the resulting value.
        #[prost(int64, tag="2")]
        pub value: i64,
    }
}
/// The value of an evaluated expression.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExprValue {
    /// An expression can resolve to a value, error or unknown.
    #[prost(oneof="expr_value::Kind", tags="1, 2, 3")]
    pub kind: ::core::option::Option<expr_value::Kind>,
}
/// Nested message and enum types in `ExprValue`.
pub mod expr_value {
    /// An expression can resolve to a value, error or unknown.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Kind {
        /// A concrete value.
        #[prost(message, tag="1")]
        Value(super::Value),
        /// The set of errors in the critical path of evaluation.
        ///
        /// Only errors in the critical path are included. For example,
        /// `(<error1> || true) && <error2>` will only result in `<error2>`,
        /// while `<error1> || <error2>` will result in both `<error1>` and
        /// `<error2>`.
        ///
        /// Errors caused by the presence of other errors are not included in the
        /// set. For example `<error1>.foo`, `foo(<error1>)`, and `<error1> + 1` will
        /// only result in `<error1>`.
        ///
        /// Multiple errors *might* be included when evaluation could result
        /// in different errors. For example `<error1> + <error2>` and
        /// `foo(<error1>, <error2>)` may result in `<error1>`, `<error2>` or both.
        /// The exact subset of errors included for this case is unspecified and
        /// depends on the implementation details of the evaluator.
        #[prost(message, tag="2")]
        Error(super::ErrorSet),
        /// The set of unknowns in the critical path of evaluation.
        ///
        /// Unknown behaves identically to Error with regards to propagation.
        /// Specifically, only unknowns in the critical path are included, unknowns
        /// caused by the presence of other unknowns are not included, and multiple
        /// unknowns *might* be included included when evaluation could result in
        /// different unknowns. For example:
        ///
        ///      (<unknown\[1\]> || true) && <unknown\[2\]> -> <unknown\[2\]>
        ///      <unknown\[1\]> || <unknown\[2\]> -> <unknown\[1,2\]>
        ///      <unknown\[1\]>.foo -> <unknown\[1\]>
        ///      foo(<unknown\[1\]>) -> <unknown\[1\]>
        ///      <unknown\[1\]> + <unknown\[2\]> -> <unknown\[1\]> or <unknown[2[>
        ///
        /// Unknown takes precedence over Error in cases where a `Value` can short
        /// circuit the result:
        ///
        ///      <error> || <unknown> -> <unknown>
        ///      <error> && <unknown> -> <unknown>
        ///
        /// Errors take precedence in all other cases:
        ///
        ///      <unknown> + <error> -> <error>
        ///      foo(<unknown>, <error>) -> <error>
        #[prost(message, tag="3")]
        Unknown(super::UnknownSet),
    }
}
/// A set of errors.
///
/// The errors included depend on the context. See `ExprValue.error`.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ErrorSet {
    /// The errors in the set.
    #[prost(message, repeated, tag="1")]
    pub errors: ::prost::alloc::vec::Vec<super::super::super::rpc::Status>,
}
/// A set of expressions for which the value is unknown.
///
/// The unknowns included depend on the context. See `ExprValue.unknown`.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UnknownSet {
    /// The ids of the expressions with unknown values.
    #[prost(int64, repeated, tag="1")]
    pub exprs: ::prost::alloc::vec::Vec<i64>,
}
/// Values of intermediate expressions produced when evaluating expression.
/// Deprecated, use `EvalState` instead.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Explain {
    /// All of the observed values.
    ///
    /// The field value_index is an index in the values list.
    /// Separating values from steps is needed to remove redundant values.
    #[prost(message, repeated, tag="1")]
    pub values: ::prost::alloc::vec::Vec<Value>,
    /// List of steps.
    ///
    /// Repeated evaluations of the same expression generate new ExprStep
    /// instances. The order of such ExprStep instances matches the order of
    /// elements returned by Comprehension.iter_range.
    #[prost(message, repeated, tag="2")]
    pub expr_steps: ::prost::alloc::vec::Vec<explain::ExprStep>,
}
/// Nested message and enum types in `Explain`.
pub mod explain {
    /// ID and value index of one step.
    #[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ExprStep {
        /// ID of corresponding Expr node.
        #[prost(int64, tag="1")]
        pub id: i64,
        /// Index of the value in the values list.
        #[prost(int32, tag="2")]
        pub value_index: i32,
    }
}
// @@protoc_insertion_point(module)