// This file is @generated by prost-build.
/// An expression together with source information as returned by the parser.
#[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 into the existing AST.
///
/// All references within expressions must resolve to a
/// \[Decl\]\[cel.expr.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 either refer to 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\]\[cel.expr.Expr.Select\] expression, and the function
/// declaration `startsWith`.
#[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 to 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`.
    #[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\]\[cel.expr.Expr.Select\] expression.
        #[prost(string, tag = "1")]
        pub name: ::prost::alloc::string::String,
    }
    /// A field selection expression. e.g. `request.auth`.
    #[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)`.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Call {
        /// The target of an 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 homogenous, e.g. `\[1, 2, 3\]`, or heterogeneous, e.g.
    /// `dyn(\[1, 'hello', 2.0\])`
    #[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'}`.
    #[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.
        #[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 to 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.
            #[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:
    ///
    /// ```text,
    /// 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 both the key or index in addition to the value for each list
    /// or map entry:
    ///
    /// ```text,
    /// let `accu_var` = `accu_init`
    /// for (let `iter_var`, `iter_var2` in `iter_range`) {
    ///   if (!`loop_condition`) {
    ///     break
    ///   }
    ///   `accu_var` = `loop_step`
    /// }
    /// return `result`
    /// ```
    #[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.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ExprKind {
        /// A constant 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 as 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\]\[cel.expr.Expr\] elements which require evaluation and
/// are thus not constant.
///
/// Examples of constants include: `"hello"`, `b'bytes'`, `1u`, `4.2`, `-2`,
/// `true`, `null`.
#[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.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ConstantKind {
        /// null value.
        #[prost(
            enumeration = "super::super::super::google::protobuf::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(super::super::super::google::protobuf::Duration),
        /// protobuf.Timestamp value.
        ///
        /// Deprecated: timestamp is no longer considered a builtin cel type.
        #[prost(message, tag = "9")]
        TimestampValue(super::super::super::google::protobuf::Timestamp),
    }
}
/// Source information collected at parse time.
#[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.
    #[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
        #[derive(Clone, Copy, 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 {
                    Self::Unspecified => "COMPONENT_UNSPECIFIED",
                    Self::Parser => "COMPONENT_PARSER",
                    Self::TypeChecker => "COMPONENT_TYPE_CHECKER",
                    Self::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 CEL expression which has been successfully type checked.
#[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.
#[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>`.
    #[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>`.
    #[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.
    #[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.
    #[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.
        ///
        /// 32-bit integer values are widened to int64.
        Int64 = 2,
        /// Uint64 type.
        ///
        /// 32-bit unsigned integer values are widened to uint64.
        Uint64 = 3,
        /// Double type.
        ///
        /// 32-bit 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 {
                Self::Unspecified => "PRIMITIVE_TYPE_UNSPECIFIED",
                Self::Bool => "BOOL",
                Self::Int64 => "INT64",
                Self::Uint64 => "UINT64",
                Self::Double => "DOUBLE",
                Self::String => "STRING",
                Self::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 {
                Self::Unspecified => "WELL_KNOWN_TYPE_UNSPECIFIED",
                Self::Any => "ANY",
                Self::Timestamp => "TIMESTAMP",
                Self::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.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum TypeKind {
        /// Dynamic type.
        #[prost(message, tag = "1")]
        Dyn(super::super::super::google::protobuf::Empty),
        /// Null value.
        #[prost(
            enumeration = "super::super::super::google::protobuf::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.type.PhoneNumber`.
        #[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.INT64`.
        #[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(super::super::super::google::protobuf::Empty),
        /// Abstract, application defined type.
        ///
        /// An abstract type has no accessible field names, and it can only be
        /// inspected via helper / member functions.
        #[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.
#[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 `cel.expr.Decl`.
    ///
    /// Declarations used as
    /// \[FunctionDecl.Overload\]\[cel.expr.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\]\[cel.expr.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.
    #[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.
        ///
        /// Provide a brief description of what the variable represents and whether
        /// there are any constraints on the formatting or supported value range.
        ///
        /// Examples:
        ///
        /// ```text
        /// 'request.auth.principal' - string which uniquely identifies an
        /// authenticated principal. For JSON Web Tokens (JWTs), the principal
        /// is the combination of the issuer ('iss') and subject ('sub') token
        /// fields concatenated by a forward slash: iss + `/` + sub.
        ///
        /// 'min_cpus' - integer value indicates the minimum number of CPUs
        /// required for a compute cluster. The 'min_cpus' value must be
        /// greater than zero and less than 'max_cpus' or 64 whichever is less.
        /// ```
        #[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).
    #[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:
        ///
        /// ```text
        /// 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\]\[cel.expr.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).
        #[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\]\[cel.expr.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\]\[cel.expr.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(...)`
            /// of 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,
            /// Documentation string for the overload.
            ///
            /// Provide examples of the overload behavior, preferring to use literal
            /// values as input with a comment on the return value.
            ///
            /// Examples:
            ///
            /// ```text
            /// // Determine whether a value of type <V> exists within a list<V>.
            /// 2 in \[1, 2, 3\] // returns true
            ///
            /// // Determine whether a key of type <K> exists within a map<K,V>.
            /// 'hello' in {'hi': 'you', 'hello': 'there'}  // returns true
            /// 'help' in {'hi': 'you', 'hello': 'there'}  // returns false
            ///
            /// // Take the substring of a string starting at a specific character
            /// // offset (inclusive).
            /// "tacocat".substring(1) // returns "acocat"
            /// "tacocat".substring(20) // error
            ///
            /// // Take the substring of a string starting at a specific character
            /// // offset (inclusive) and ending at the given offset (exclusive).
            /// "tacocat".substring(1, 6) // returns "acoca"
            /// ```
            #[prost(string, tag = "6")]
            pub doc: ::prost::alloc::string::String,
        }
    }
    /// Required. The declaration kind.
    #[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.
#[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\]\[cel.expr.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>,
}
