googleapis_tonic_google_api_expr_v1beta1/vec_u8_hash_map/google.api.expr.v1beta1.rs
1// This file is @generated by prost-build.
2/// Source information collected at parse time.
3#[derive(Clone, PartialEq, ::prost::Message)]
4pub struct SourceInfo {
5 /// The location name. All position information attached to an expression is
6 /// relative to this location.
7 ///
8 /// The location could be a file, UI element, or similar. For example,
9 /// `acme/app/AnvilPolicy.cel`.
10 #[prost(string, tag = "2")]
11 pub location: ::prost::alloc::string::String,
12 /// Monotonically increasing list of character offsets where newlines appear.
13 ///
14 /// The line number of a given position is the index `i` where for a given
15 /// `id` the `line_offsets\[i\] < id_positions\[id\] < line_offsets\[i+1\]`. The
16 /// column may be derivd from `id_positions\[id\] - line_offsets\[i\]`.
17 #[prost(int32, repeated, tag = "3")]
18 pub line_offsets: ::prost::alloc::vec::Vec<i32>,
19 /// A map from the parse node id (e.g. `Expr.id`) to the character offset
20 /// within source.
21 #[prost(map = "int32, int32", tag = "4")]
22 pub positions: ::std::collections::HashMap<i32, i32>,
23}
24/// A specific position in source.
25#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
26pub struct SourcePosition {
27 /// The soucre location name (e.g. file name).
28 #[prost(string, tag = "1")]
29 pub location: ::prost::alloc::string::String,
30 /// The character offset.
31 #[prost(int32, tag = "2")]
32 pub offset: i32,
33 /// The 1-based index of the starting line in the source text
34 /// where the issue occurs, or 0 if unknown.
35 #[prost(int32, tag = "3")]
36 pub line: i32,
37 /// The 0-based index of the starting position within the line of source text
38 /// where the issue occurs. Only meaningful if line is nonzer..
39 #[prost(int32, tag = "4")]
40 pub column: i32,
41}
42/// An expression together with source information as returned by the parser.
43#[derive(Clone, PartialEq, ::prost::Message)]
44pub struct ParsedExpr {
45 /// The parsed expression.
46 #[prost(message, optional, tag = "2")]
47 pub expr: ::core::option::Option<Expr>,
48 /// The source info derived from input that generated the parsed `expr`.
49 #[prost(message, optional, tag = "3")]
50 pub source_info: ::core::option::Option<SourceInfo>,
51 /// The syntax version of the source, e.g. `cel1`.
52 #[prost(string, tag = "4")]
53 pub syntax_version: ::prost::alloc::string::String,
54}
55/// An abstract representation of a common expression.
56///
57/// Expressions are abstractly represented as a collection of identifiers,
58/// select statements, function calls, literals, and comprehensions. All
59/// operators with the exception of the '.' operator are modelled as function
60/// calls. This makes it easy to represent new operators into the existing AST.
61///
62/// All references within expressions must resolve to a \[Decl\]\[google.api.expr.v1beta1.Decl\] provided at
63/// type-check for an expression to be valid. A reference may either be a bare
64/// identifier `name` or a qualified identifier `google.api.name`. References
65/// may either refer to a value or a function declaration.
66///
67/// For example, the expression `google.api.name.startsWith('expr')` references
68/// the declaration `google.api.name` within a \[Expr.Select\]\[google.api.expr.v1beta1.Expr.Select\] expression, and
69/// the function declaration `startsWith`.
70#[derive(Clone, PartialEq, ::prost::Message)]
71pub struct Expr {
72 /// Required. An id assigned to this node by the parser which is unique in a
73 /// given expression tree. This is used to associate type information and other
74 /// attributes to a node in the parse tree.
75 #[prost(int32, tag = "2")]
76 pub id: i32,
77 /// Required. Variants of expressions.
78 #[prost(oneof = "expr::ExprKind", tags = "3, 4, 5, 6, 7, 8, 9")]
79 pub expr_kind: ::core::option::Option<expr::ExprKind>,
80}
81/// Nested message and enum types in `Expr`.
82pub mod expr {
83 /// An identifier expression. e.g. `request`.
84 #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
85 pub struct Ident {
86 /// Required. Holds a single, unqualified identifier, possibly preceded by a
87 /// '.'.
88 ///
89 /// Qualified names are represented by the \[Expr.Select\]\[google.api.expr.v1beta1.Expr.Select\] expression.
90 #[prost(string, tag = "1")]
91 pub name: ::prost::alloc::string::String,
92 }
93 /// A field selection expression. e.g. `request.auth`.
94 #[derive(Clone, PartialEq, ::prost::Message)]
95 pub struct Select {
96 /// Required. The target of the selection expression.
97 ///
98 /// For example, in the select expression `request.auth`, the `request`
99 /// portion of the expression is the `operand`.
100 #[prost(message, optional, boxed, tag = "1")]
101 pub operand: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
102 /// Required. The name of the field to select.
103 ///
104 /// For example, in the select expression `request.auth`, the `auth` portion
105 /// of the expression would be the `field`.
106 #[prost(string, tag = "2")]
107 pub field: ::prost::alloc::string::String,
108 /// Whether the select is to be interpreted as a field presence test.
109 ///
110 /// This results from the macro `has(request.auth)`.
111 #[prost(bool, tag = "3")]
112 pub test_only: bool,
113 }
114 /// A call expression, including calls to predefined functions and operators.
115 ///
116 /// For example, `value == 10`, `size(map_value)`.
117 #[derive(Clone, PartialEq, ::prost::Message)]
118 pub struct Call {
119 /// The target of an method call-style expression. For example, `x` in
120 /// `x.f()`.
121 #[prost(message, optional, boxed, tag = "1")]
122 pub target: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
123 /// Required. The name of the function or method being called.
124 #[prost(string, tag = "2")]
125 pub function: ::prost::alloc::string::String,
126 /// The arguments.
127 #[prost(message, repeated, tag = "3")]
128 pub args: ::prost::alloc::vec::Vec<super::Expr>,
129 }
130 /// A list creation expression.
131 ///
132 /// Lists may either be homogenous, e.g. `\[1, 2, 3\]`, or heterogenous, e.g.
133 /// `dyn(\[1, 'hello', 2.0\])`
134 #[derive(Clone, PartialEq, ::prost::Message)]
135 pub struct CreateList {
136 /// The elements part of the list.
137 #[prost(message, repeated, tag = "1")]
138 pub elements: ::prost::alloc::vec::Vec<super::Expr>,
139 }
140 /// A map or message creation expression.
141 ///
142 /// Maps are constructed as `{'key_name': 'value'}`. Message construction is
143 /// similar, but prefixed with a type name and composed of field ids:
144 /// `types.MyType{field_id: 'value'}`.
145 #[derive(Clone, PartialEq, ::prost::Message)]
146 pub struct CreateStruct {
147 /// The type name of the message to be created, empty when creating map
148 /// literals.
149 #[prost(string, tag = "1")]
150 pub r#type: ::prost::alloc::string::String,
151 /// The entries in the creation expression.
152 #[prost(message, repeated, tag = "2")]
153 pub entries: ::prost::alloc::vec::Vec<create_struct::Entry>,
154 }
155 /// Nested message and enum types in `CreateStruct`.
156 pub mod create_struct {
157 /// Represents an entry.
158 #[derive(Clone, PartialEq, ::prost::Message)]
159 pub struct Entry {
160 /// Required. An id assigned to this node by the parser which is unique
161 /// in a given expression tree. This is used to associate type
162 /// information and other attributes to the node.
163 #[prost(int32, tag = "1")]
164 pub id: i32,
165 /// Required. The value assigned to the key.
166 #[prost(message, optional, tag = "4")]
167 pub value: ::core::option::Option<super::super::Expr>,
168 /// The `Entry` key kinds.
169 #[prost(oneof = "entry::KeyKind", tags = "2, 3")]
170 pub key_kind: ::core::option::Option<entry::KeyKind>,
171 }
172 /// Nested message and enum types in `Entry`.
173 pub mod entry {
174 /// The `Entry` key kinds.
175 #[derive(Clone, PartialEq, ::prost::Oneof)]
176 pub enum KeyKind {
177 /// The field key for a message creator statement.
178 #[prost(string, tag = "2")]
179 FieldKey(::prost::alloc::string::String),
180 /// The key expression for a map creation statement.
181 #[prost(message, tag = "3")]
182 MapKey(super::super::super::Expr),
183 }
184 }
185 }
186 /// A comprehension expression applied to a list or map.
187 ///
188 /// Comprehensions are not part of the core syntax, but enabled with macros.
189 /// A macro matches a specific call signature within a parsed AST and replaces
190 /// the call with an alternate AST block. Macro expansion happens at parse
191 /// time.
192 ///
193 /// The following macros are supported within CEL:
194 ///
195 /// Aggregate type macros may be applied to all elements in a list or all keys
196 /// in a map:
197 ///
198 /// * `all`, `exists`, `exists_one` - test a predicate expression against
199 /// the inputs and return `true` if the predicate is satisfied for all,
200 /// any, or only one value `list.all(x, x < 10)`.
201 /// * `filter` - test a predicate expression against the inputs and return
202 /// the subset of elements which satisfy the predicate:
203 /// `payments.filter(p, p > 1000)`.
204 /// * `map` - apply an expression to all elements in the input and return the
205 /// output aggregate type: `\[1, 2, 3\].map(i, i * i)`.
206 ///
207 /// The `has(m.x)` macro tests whether the property `x` is present in struct
208 /// `m`. The semantics of this macro depend on the type of `m`. For proto2
209 /// 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\`.
210 #[derive(Clone, PartialEq, ::prost::Message)]
211 pub struct Comprehension {
212 /// The name of the iteration variable.
213 #[prost(string, tag = "1")]
214 pub iter_var: ::prost::alloc::string::String,
215 /// The range over which var iterates.
216 #[prost(message, optional, boxed, tag = "2")]
217 pub iter_range: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
218 /// The name of the variable used for accumulation of the result.
219 #[prost(string, tag = "3")]
220 pub accu_var: ::prost::alloc::string::String,
221 /// The initial value of the accumulator.
222 #[prost(message, optional, boxed, tag = "4")]
223 pub accu_init: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
224 /// An expression which can contain iter_var and accu_var.
225 ///
226 /// Returns false when the result has been computed and may be used as
227 /// a hint to short-circuit the remainder of the comprehension.
228 #[prost(message, optional, boxed, tag = "5")]
229 pub loop_condition: ::core::option::Option<
230 ::prost::alloc::boxed::Box<super::Expr>,
231 >,
232 /// An expression which can contain iter_var and accu_var.
233 ///
234 /// Computes the next value of accu_var.
235 #[prost(message, optional, boxed, tag = "6")]
236 pub loop_step: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
237 /// An expression which can contain accu_var.
238 ///
239 /// Computes the result.
240 #[prost(message, optional, boxed, tag = "7")]
241 pub result: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
242 }
243 /// Required. Variants of expressions.
244 #[derive(Clone, PartialEq, ::prost::Oneof)]
245 pub enum ExprKind {
246 /// A literal expression.
247 #[prost(message, tag = "3")]
248 LiteralExpr(super::Literal),
249 /// An identifier expression.
250 #[prost(message, tag = "4")]
251 IdentExpr(Ident),
252 /// A field selection expression, e.g. `request.auth`.
253 #[prost(message, tag = "5")]
254 SelectExpr(::prost::alloc::boxed::Box<Select>),
255 /// A call expression, including calls to predefined functions and operators.
256 #[prost(message, tag = "6")]
257 CallExpr(::prost::alloc::boxed::Box<Call>),
258 /// A list creation expression.
259 #[prost(message, tag = "7")]
260 ListExpr(CreateList),
261 /// A map or object creation expression.
262 #[prost(message, tag = "8")]
263 StructExpr(CreateStruct),
264 /// A comprehension expression.
265 #[prost(message, tag = "9")]
266 ComprehensionExpr(::prost::alloc::boxed::Box<Comprehension>),
267 }
268}
269/// Represents a primitive literal.
270///
271/// This is similar to the primitives supported in the well-known type
272/// `google.protobuf.Value`, but richer so it can represent CEL's full range of
273/// primitives.
274///
275/// Lists and structs are not included as constants as these aggregate types may
276/// contain \[Expr\]\[google.api.expr.v1beta1.Expr\] elements which require evaluation and are thus not constant.
277///
278/// Examples of literals include: `"hello"`, `b'bytes'`, `1u`, `4.2`, `-2`,
279/// `true`, `null`.
280#[derive(Clone, PartialEq, ::prost::Message)]
281pub struct Literal {
282 /// Required. The valid constant kinds.
283 #[prost(oneof = "literal::ConstantKind", tags = "1, 2, 3, 4, 5, 6, 7")]
284 pub constant_kind: ::core::option::Option<literal::ConstantKind>,
285}
286/// Nested message and enum types in `Literal`.
287pub mod literal {
288 /// Required. The valid constant kinds.
289 #[derive(Clone, PartialEq, ::prost::Oneof)]
290 pub enum ConstantKind {
291 /// null value.
292 #[prost(enumeration = "::prost_types::NullValue", tag = "1")]
293 NullValue(i32),
294 /// boolean value.
295 #[prost(bool, tag = "2")]
296 BoolValue(bool),
297 /// int64 value.
298 #[prost(int64, tag = "3")]
299 Int64Value(i64),
300 /// uint64 value.
301 #[prost(uint64, tag = "4")]
302 Uint64Value(u64),
303 /// double value.
304 #[prost(double, tag = "5")]
305 DoubleValue(f64),
306 /// string value.
307 #[prost(string, tag = "6")]
308 StringValue(::prost::alloc::string::String),
309 /// bytes value.
310 #[prost(bytes, tag = "7")]
311 BytesValue(::prost::alloc::vec::Vec<u8>),
312 }
313}
314/// A declaration.
315#[derive(Clone, PartialEq, ::prost::Message)]
316pub struct Decl {
317 /// The id of the declaration.
318 #[prost(int32, tag = "1")]
319 pub id: i32,
320 /// The name of the declaration.
321 #[prost(string, tag = "2")]
322 pub name: ::prost::alloc::string::String,
323 /// The documentation string for the declaration.
324 #[prost(string, tag = "3")]
325 pub doc: ::prost::alloc::string::String,
326 /// The kind of declaration.
327 #[prost(oneof = "decl::Kind", tags = "4, 5")]
328 pub kind: ::core::option::Option<decl::Kind>,
329}
330/// Nested message and enum types in `Decl`.
331pub mod decl {
332 /// The kind of declaration.
333 #[derive(Clone, PartialEq, ::prost::Oneof)]
334 pub enum Kind {
335 /// An identifier declaration.
336 #[prost(message, tag = "4")]
337 Ident(super::IdentDecl),
338 /// A function declaration.
339 #[prost(message, tag = "5")]
340 Function(super::FunctionDecl),
341 }
342}
343/// The declared type of a variable.
344///
345/// Extends runtime type values with extra information used for type checking
346/// and dispatching.
347#[derive(Clone, PartialEq, ::prost::Message)]
348pub struct DeclType {
349 /// The expression id of the declared type, if applicable.
350 #[prost(int32, tag = "1")]
351 pub id: i32,
352 /// The type name, e.g. 'int', 'my.type.Type' or 'T'
353 #[prost(string, tag = "2")]
354 pub r#type: ::prost::alloc::string::String,
355 /// An ordered list of type parameters, e.g. `<string, int>`.
356 /// Only applies to a subset of types, e.g. `map`, `list`.
357 #[prost(message, repeated, tag = "4")]
358 pub type_params: ::prost::alloc::vec::Vec<DeclType>,
359}
360/// An identifier declaration.
361#[derive(Clone, PartialEq, ::prost::Message)]
362pub struct IdentDecl {
363 /// Optional type of the identifier.
364 #[prost(message, optional, tag = "3")]
365 pub r#type: ::core::option::Option<DeclType>,
366 /// Optional value of the identifier.
367 #[prost(message, optional, tag = "4")]
368 pub value: ::core::option::Option<Expr>,
369}
370/// A function declaration.
371#[derive(Clone, PartialEq, ::prost::Message)]
372pub struct FunctionDecl {
373 /// The function arguments.
374 #[prost(message, repeated, tag = "1")]
375 pub args: ::prost::alloc::vec::Vec<IdentDecl>,
376 /// Optional declared return type.
377 #[prost(message, optional, tag = "2")]
378 pub return_type: ::core::option::Option<DeclType>,
379 /// If the first argument of the function is the receiver.
380 #[prost(bool, tag = "3")]
381 pub receiver_function: bool,
382}
383/// Represents a CEL value.
384///
385/// This is similar to `google.protobuf.Value`, but can represent CEL's full
386/// range of values.
387#[derive(Clone, PartialEq, ::prost::Message)]
388pub struct Value {
389 /// Required. The valid kinds of values.
390 #[prost(oneof = "value::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 15")]
391 pub kind: ::core::option::Option<value::Kind>,
392}
393/// Nested message and enum types in `Value`.
394pub mod value {
395 /// Required. The valid kinds of values.
396 #[derive(Clone, PartialEq, ::prost::Oneof)]
397 pub enum Kind {
398 /// Null value.
399 #[prost(enumeration = "::prost_types::NullValue", tag = "1")]
400 NullValue(i32),
401 /// Boolean value.
402 #[prost(bool, tag = "2")]
403 BoolValue(bool),
404 /// Signed integer value.
405 #[prost(int64, tag = "3")]
406 Int64Value(i64),
407 /// Unsigned integer value.
408 #[prost(uint64, tag = "4")]
409 Uint64Value(u64),
410 /// Floating point value.
411 #[prost(double, tag = "5")]
412 DoubleValue(f64),
413 /// UTF-8 string value.
414 #[prost(string, tag = "6")]
415 StringValue(::prost::alloc::string::String),
416 /// Byte string value.
417 #[prost(bytes, tag = "7")]
418 BytesValue(::prost::alloc::vec::Vec<u8>),
419 /// An enum value.
420 #[prost(message, tag = "9")]
421 EnumValue(super::EnumValue),
422 /// The proto message backing an object value.
423 #[prost(message, tag = "10")]
424 ObjectValue(::prost_types::Any),
425 /// Map value.
426 #[prost(message, tag = "11")]
427 MapValue(super::MapValue),
428 /// List value.
429 #[prost(message, tag = "12")]
430 ListValue(super::ListValue),
431 /// A Type value represented by the fully qualified name of the type.
432 #[prost(string, tag = "15")]
433 TypeValue(::prost::alloc::string::String),
434 }
435}
436/// An enum value.
437#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
438pub struct EnumValue {
439 /// The fully qualified name of the enum type.
440 #[prost(string, tag = "1")]
441 pub r#type: ::prost::alloc::string::String,
442 /// The value of the enum.
443 #[prost(int32, tag = "2")]
444 pub value: i32,
445}
446/// A list.
447///
448/// Wrapped in a message so 'not set' and empty can be differentiated, which is
449/// required for use in a 'oneof'.
450#[derive(Clone, PartialEq, ::prost::Message)]
451pub struct ListValue {
452 /// The ordered values in the list.
453 #[prost(message, repeated, tag = "1")]
454 pub values: ::prost::alloc::vec::Vec<Value>,
455}
456/// A map.
457///
458/// Wrapped in a message so 'not set' and empty can be differentiated, which is
459/// required for use in a 'oneof'.
460#[derive(Clone, PartialEq, ::prost::Message)]
461pub struct MapValue {
462 /// The set of map entries.
463 ///
464 /// CEL has fewer restrictions on keys, so a protobuf map represenation
465 /// cannot be used.
466 #[prost(message, repeated, tag = "1")]
467 pub entries: ::prost::alloc::vec::Vec<map_value::Entry>,
468}
469/// Nested message and enum types in `MapValue`.
470pub mod map_value {
471 /// An entry in the map.
472 #[derive(Clone, PartialEq, ::prost::Message)]
473 pub struct Entry {
474 /// The key.
475 ///
476 /// Must be unique with in the map.
477 /// Currently only boolean, int, uint, and string values can be keys.
478 #[prost(message, optional, tag = "1")]
479 pub key: ::core::option::Option<super::Value>,
480 /// The value.
481 #[prost(message, optional, tag = "2")]
482 pub value: ::core::option::Option<super::Value>,
483 }
484}
485/// The state of an evaluation.
486///
487/// Can represent an initial, partial, or completed state of evaluation.
488#[derive(Clone, PartialEq, ::prost::Message)]
489pub struct EvalState {
490 /// The unique values referenced in this message.
491 #[prost(message, repeated, tag = "1")]
492 pub values: ::prost::alloc::vec::Vec<ExprValue>,
493 /// An ordered list of results.
494 ///
495 /// Tracks the flow of evaluation through the expression.
496 /// May be sparse.
497 #[prost(message, repeated, tag = "3")]
498 pub results: ::prost::alloc::vec::Vec<eval_state::Result>,
499}
500/// Nested message and enum types in `EvalState`.
501pub mod eval_state {
502 /// A single evaluation result.
503 #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
504 pub struct Result {
505 /// The expression this result is for.
506 #[prost(message, optional, tag = "1")]
507 pub expr: ::core::option::Option<super::IdRef>,
508 /// The index in `values` of the resulting value.
509 #[prost(int32, tag = "2")]
510 pub value: i32,
511 }
512}
513/// The value of an evaluated expression.
514#[derive(Clone, PartialEq, ::prost::Message)]
515pub struct ExprValue {
516 /// An expression can resolve to a value, error or unknown.
517 #[prost(oneof = "expr_value::Kind", tags = "1, 2, 3")]
518 pub kind: ::core::option::Option<expr_value::Kind>,
519}
520/// Nested message and enum types in `ExprValue`.
521pub mod expr_value {
522 /// An expression can resolve to a value, error or unknown.
523 #[derive(Clone, PartialEq, ::prost::Oneof)]
524 pub enum Kind {
525 /// A concrete value.
526 #[prost(message, tag = "1")]
527 Value(super::Value),
528 /// The set of errors in the critical path of evalution.
529 ///
530 /// Only errors in the critical path are included. For example,
531 /// `(<error1> || true) && <error2>` will only result in `<error2>`,
532 /// while `<error1> || <error2>` will result in both `<error1>` and
533 /// `<error2>`.
534 ///
535 /// Errors cause by the presence of other errors are not included in the
536 /// set. For example `<error1>.foo`, `foo(<error1>)`, and `<error1> + 1` will
537 /// only result in `<error1>`.
538 ///
539 /// Multiple errors *might* be included when evaluation could result
540 /// in different errors. For example `<error1> + <error2>` and
541 /// `foo(<error1>, <error2>)` may result in `<error1>`, `<error2>` or both.
542 /// The exact subset of errors included for this case is unspecified and
543 /// depends on the implementation details of the evaluator.
544 #[prost(message, tag = "2")]
545 Error(super::ErrorSet),
546 /// The set of unknowns in the critical path of evaluation.
547 ///
548 /// Unknown behaves identically to Error with regards to propagation.
549 /// Specifically, only unknowns in the critical path are included, unknowns
550 /// caused by the presence of other unknowns are not included, and multiple
551 /// unknowns *might* be included included when evaluation could result in
552 /// different unknowns. For example:
553 ///
554 /// ```text
555 /// (<unknown\[1\]> || true) && <unknown\[2\]> -> <unknown\[2\]>
556 /// <unknown\[1\]> || <unknown\[2\]> -> <unknown\[1,2\]>
557 /// <unknown\[1\]>.foo -> <unknown\[1\]>
558 /// foo(<unknown\[1\]>) -> <unknown\[1\]>
559 /// <unknown\[1\]> + <unknown\[2\]> -> <unknown\[1\]> or <unknown[2[>
560 /// ```
561 ///
562 /// Unknown takes precidence over Error in cases where a `Value` can short
563 /// circuit the result:
564 ///
565 /// ```text
566 /// <error> || <unknown> -> <unknown>
567 /// <error> && <unknown> -> <unknown>
568 /// ```
569 ///
570 /// Errors take precidence in all other cases:
571 ///
572 /// ```text
573 /// <unknown> + <error> -> <error>
574 /// foo(<unknown>, <error>) -> <error>
575 /// ```
576 #[prost(message, tag = "3")]
577 Unknown(super::UnknownSet),
578 }
579}
580/// A set of errors.
581///
582/// The errors included depend on the context. See `ExprValue.error`.
583#[derive(Clone, PartialEq, ::prost::Message)]
584pub struct ErrorSet {
585 /// The errors in the set.
586 #[prost(message, repeated, tag = "1")]
587 pub errors: ::prost::alloc::vec::Vec<super::super::super::rpc::Status>,
588}
589/// A set of expressions for which the value is unknown.
590///
591/// The unknowns included depend on the context. See `ExprValue.unknown`.
592#[derive(Clone, PartialEq, ::prost::Message)]
593pub struct UnknownSet {
594 /// The ids of the expressions with unknown values.
595 #[prost(message, repeated, tag = "1")]
596 pub exprs: ::prost::alloc::vec::Vec<IdRef>,
597}
598/// A reference to an expression id.
599#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
600pub struct IdRef {
601 /// The expression id.
602 #[prost(int32, tag = "1")]
603 pub id: i32,
604}