From aadfbeb39d0ac5ccb1a19899d7680b1c96b1a6cf Mon Sep 17 00:00:00 2001
From: mo khan <mo@mokhan.ca>
Date: Wed, 16 Jul 2025 13:44:59 -0600
Subject: chore: add generated rpc code

---
 src/rpc/google.api.expr.v1beta1.rs | 633 +++++++++++++++++++++++++++++++++++++
 1 file changed, 633 insertions(+)
 create mode 100644 src/rpc/google.api.expr.v1beta1.rs

(limited to 'src/rpc/google.api.expr.v1beta1.rs')

diff --git a/src/rpc/google.api.expr.v1beta1.rs b/src/rpc/google.api.expr.v1beta1.rs
new file mode 100644
index 00000000..097d42f1
--- /dev/null
+++ b/src/rpc/google.api.expr.v1beta1.rs
@@ -0,0 +1,633 @@
+// @generated
+// This file is @generated by prost-build.
+/// Source information collected at parse time.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SourceInfo {
+    /// 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 character offsets where newlines 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 derivd 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 character offset
+    /// within source.
+    #[prost(map="int32, int32", tag="4")]
+    pub positions: ::std::collections::HashMap<i32, i32>,
+}
+/// A specific position in source.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SourcePosition {
+    /// The soucre location name (e.g. file name).
+    #[prost(string, tag="1")]
+    pub location: ::prost::alloc::string::String,
+    /// The character 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 nonzer..
+    #[prost(int32, tag="4")]
+    pub column: i32,
+}
+/// 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>,
+    /// The syntax version of the source, e.g. `cel1`.
+    #[prost(string, tag="4")]
+    pub syntax_version: ::prost::alloc::string::String,
+}
+/// 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][google.api.expr.v1beta1.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][google.api.expr.v1beta1.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 to a node in the parse tree.
+    #[prost(int32, tag="2")]
+    pub id: i32,
+    /// 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.v1beta1.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 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 heterogenous, 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>,
+    }
+    /// 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 r#type: ::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 to the node.
+            #[prost(int32, tag="1")]
+            pub id: i32,
+            /// Required. The value assigned to the key.
+            #[prost(message, optional, tag="4")]
+            pub value: ::core::option::Option<super::super::Expr>,
+            /// 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`.
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct Comprehension {
+        /// The name of the iteration variable.
+        #[prost(string, tag="1")]
+        pub iter_var: ::prost::alloc::string::String,
+        /// The range over which var 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 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 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")]
+        LiteralExpr(super::Literal),
+        /// 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 object 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.
+///
+/// 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.v1beta1.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 Literal {
+    /// Required. The valid constant kinds.
+    #[prost(oneof="literal::ConstantKind", tags="1, 2, 3, 4, 5, 6, 7")]
+    pub constant_kind: ::core::option::Option<literal::ConstantKind>,
+}
+/// Nested message and enum types in `Literal`.
+pub mod literal {
+    /// Required. The valid constant kinds.
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum ConstantKind {
+        /// null value.
+        #[prost(enumeration="super::super::super::super::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>),
+    }
+}
+/// A declaration.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Decl {
+    /// The id of the declaration.
+    #[prost(int32, tag="1")]
+    pub id: i32,
+    /// The name of the declaration.
+    #[prost(string, tag="2")]
+    pub name: ::prost::alloc::string::String,
+    /// The documentation string for the declaration.
+    #[prost(string, tag="3")]
+    pub doc: ::prost::alloc::string::String,
+    /// The kind of declaration.
+    #[prost(oneof="decl::Kind", tags="4, 5")]
+    pub kind: ::core::option::Option<decl::Kind>,
+}
+/// Nested message and enum types in `Decl`.
+pub mod decl {
+    /// The kind of declaration.
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Kind {
+        /// An identifier declaration.
+        #[prost(message, tag="4")]
+        Ident(super::IdentDecl),
+        /// A function declaration.
+        #[prost(message, tag="5")]
+        Function(super::FunctionDecl),
+    }
+}
+/// The declared type of a variable.
+///
+/// Extends runtime type values with extra information used for type checking
+/// and dispatching.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DeclType {
+    /// The expression id of the declared type, if applicable.
+    #[prost(int32, tag="1")]
+    pub id: i32,
+    /// The type name, e.g. 'int', 'my.type.Type' or 'T'
+    #[prost(string, tag="2")]
+    pub r#type: ::prost::alloc::string::String,
+    /// An ordered list of type parameters, e.g. `<string, int>`.
+    /// Only applies to a subset of types, e.g. `map`, `list`.
+    #[prost(message, repeated, tag="4")]
+    pub type_params: ::prost::alloc::vec::Vec<DeclType>,
+}
+/// An identifier declaration.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct IdentDecl {
+    /// Optional type of the identifier.
+    #[prost(message, optional, tag="3")]
+    pub r#type: ::core::option::Option<DeclType>,
+    /// Optional value of the identifier.
+    #[prost(message, optional, tag="4")]
+    pub value: ::core::option::Option<Expr>,
+}
+/// A function declaration.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct FunctionDecl {
+    /// The function arguments.
+    #[prost(message, repeated, tag="1")]
+    pub args: ::prost::alloc::vec::Vec<IdentDecl>,
+    /// Optional declared return type.
+    #[prost(message, optional, tag="2")]
+    pub return_type: ::core::option::Option<DeclType>,
+    /// If the first argument of the function is the receiver.
+    #[prost(bool, tag="3")]
+    pub receiver_function: bool,
+}
+/// 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="super::super::super::super::protobuf::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(super::super::super::super::protobuf::Any),
+        /// Map value.
+        #[prost(message, tag="11")]
+        MapValue(super::MapValue),
+        /// List value.
+        #[prost(message, tag="12")]
+        ListValue(super::ListValue),
+        /// A Type value represented by the fully qualified name of the type.
+        #[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 represenation
+    /// 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, Copy, PartialEq, ::prost::Message)]
+    pub struct Result {
+        /// The expression this result is for.
+        #[prost(message, optional, tag="1")]
+        pub expr: ::core::option::Option<super::IdRef>,
+        /// The index in `values` of the resulting value.
+        #[prost(int32, tag="2")]
+        pub value: i32,
+    }
+}
+/// 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 evalution.
+        ///
+        /// 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 cause 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 precidence over Error in cases where a `Value` can short
+        /// circuit the result:
+        ///
+        ///      <error> || <unknown> -> <unknown>
+        ///      <error> && <unknown> -> <unknown>
+        ///
+        /// Errors take precidence 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(message, repeated, tag="1")]
+    pub exprs: ::prost::alloc::vec::Vec<IdRef>,
+}
+/// A reference to an expression id.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct IdRef {
+    /// The expression id.
+    #[prost(int32, tag="1")]
+    pub id: i32,
+}
+// @@protoc_insertion_point(module)
-- 
cgit v1.2.3