envoy_types/generated/cel.expr.rs
1// This file is @generated by prost-build.
2/// An expression together with source information as returned by the parser.
3#[derive(Clone, PartialEq, ::prost::Message)]
4pub struct ParsedExpr {
5 /// The parsed expression.
6 #[prost(message, optional, tag = "2")]
7 pub expr: ::core::option::Option<Expr>,
8 /// The source info derived from input that generated the parsed `expr`.
9 #[prost(message, optional, tag = "3")]
10 pub source_info: ::core::option::Option<SourceInfo>,
11}
12impl ::prost::Name for ParsedExpr {
13 const NAME: &'static str = "ParsedExpr";
14 const PACKAGE: &'static str = "cel.expr";
15 fn full_name() -> ::prost::alloc::string::String {
16 "cel.expr.ParsedExpr".into()
17 }
18 fn type_url() -> ::prost::alloc::string::String {
19 "type.googleapis.com/cel.expr.ParsedExpr".into()
20 }
21}
22/// An abstract representation of a common expression.
23///
24/// Expressions are abstractly represented as a collection of identifiers,
25/// select statements, function calls, literals, and comprehensions. All
26/// operators with the exception of the '.' operator are modelled as function
27/// calls. This makes it easy to represent new operators into the existing AST.
28///
29/// All references within expressions must resolve to a
30/// \[Decl\]\[cel.expr.Decl\] provided at type-check for an expression to be
31/// valid. A reference may either be a bare identifier `name` or a qualified
32/// identifier `google.api.name`. References may either refer to a value or a
33/// function declaration.
34///
35/// For example, the expression `google.api.name.startsWith('expr')` references
36/// the declaration `google.api.name` within a
37/// \[Expr.Select\]\[cel.expr.Expr.Select\] expression, and the function
38/// declaration `startsWith`.
39#[derive(Clone, PartialEq, ::prost::Message)]
40pub struct Expr {
41 /// Required. An id assigned to this node by the parser which is unique in a
42 /// given expression tree. This is used to associate type information and other
43 /// attributes to a node in the parse tree.
44 #[prost(int64, tag = "2")]
45 pub id: i64,
46 /// Required. Variants of expressions.
47 #[prost(oneof = "expr::ExprKind", tags = "3, 4, 5, 6, 7, 8, 9")]
48 pub expr_kind: ::core::option::Option<expr::ExprKind>,
49}
50/// Nested message and enum types in `Expr`.
51pub mod expr {
52 /// An identifier expression. e.g. `request`.
53 #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
54 pub struct Ident {
55 /// Required. Holds a single, unqualified identifier, possibly preceded by a
56 /// '.'.
57 ///
58 /// Qualified names are represented by the
59 /// \[Expr.Select\]\[cel.expr.Expr.Select\] expression.
60 #[prost(string, tag = "1")]
61 pub name: ::prost::alloc::string::String,
62 }
63 impl ::prost::Name for Ident {
64 const NAME: &'static str = "Ident";
65 const PACKAGE: &'static str = "cel.expr";
66 fn full_name() -> ::prost::alloc::string::String {
67 "cel.expr.Expr.Ident".into()
68 }
69 fn type_url() -> ::prost::alloc::string::String {
70 "type.googleapis.com/cel.expr.Expr.Ident".into()
71 }
72 }
73 /// A field selection expression. e.g. `request.auth`.
74 #[derive(Clone, PartialEq, ::prost::Message)]
75 pub struct Select {
76 /// Required. The target of the selection expression.
77 ///
78 /// For example, in the select expression `request.auth`, the `request`
79 /// portion of the expression is the `operand`.
80 #[prost(message, optional, boxed, tag = "1")]
81 pub operand: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
82 /// Required. The name of the field to select.
83 ///
84 /// For example, in the select expression `request.auth`, the `auth` portion
85 /// of the expression would be the `field`.
86 #[prost(string, tag = "2")]
87 pub field: ::prost::alloc::string::String,
88 /// Whether the select is to be interpreted as a field presence test.
89 ///
90 /// This results from the macro `has(request.auth)`.
91 #[prost(bool, tag = "3")]
92 pub test_only: bool,
93 }
94 impl ::prost::Name for Select {
95 const NAME: &'static str = "Select";
96 const PACKAGE: &'static str = "cel.expr";
97 fn full_name() -> ::prost::alloc::string::String {
98 "cel.expr.Expr.Select".into()
99 }
100 fn type_url() -> ::prost::alloc::string::String {
101 "type.googleapis.com/cel.expr.Expr.Select".into()
102 }
103 }
104 /// A call expression, including calls to predefined functions and operators.
105 ///
106 /// For example, `value == 10`, `size(map_value)`.
107 #[derive(Clone, PartialEq, ::prost::Message)]
108 pub struct Call {
109 /// The target of an method call-style expression. For example, `x` in
110 /// `x.f()`.
111 #[prost(message, optional, boxed, tag = "1")]
112 pub target: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
113 /// Required. The name of the function or method being called.
114 #[prost(string, tag = "2")]
115 pub function: ::prost::alloc::string::String,
116 /// The arguments.
117 #[prost(message, repeated, tag = "3")]
118 pub args: ::prost::alloc::vec::Vec<super::Expr>,
119 }
120 impl ::prost::Name for Call {
121 const NAME: &'static str = "Call";
122 const PACKAGE: &'static str = "cel.expr";
123 fn full_name() -> ::prost::alloc::string::String {
124 "cel.expr.Expr.Call".into()
125 }
126 fn type_url() -> ::prost::alloc::string::String {
127 "type.googleapis.com/cel.expr.Expr.Call".into()
128 }
129 }
130 /// A list creation expression.
131 ///
132 /// Lists may either be homogenous, e.g. `\[1, 2, 3\]`, or heterogeneous, 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 /// The indices within the elements list which are marked as optional
140 /// elements.
141 ///
142 /// When an optional-typed value is present, the value it contains
143 /// is included in the list. If the optional-typed value is absent, the list
144 /// element is omitted from the CreateList result.
145 #[prost(int32, repeated, tag = "2")]
146 pub optional_indices: ::prost::alloc::vec::Vec<i32>,
147 }
148 impl ::prost::Name for CreateList {
149 const NAME: &'static str = "CreateList";
150 const PACKAGE: &'static str = "cel.expr";
151 fn full_name() -> ::prost::alloc::string::String {
152 "cel.expr.Expr.CreateList".into()
153 }
154 fn type_url() -> ::prost::alloc::string::String {
155 "type.googleapis.com/cel.expr.Expr.CreateList".into()
156 }
157 }
158 /// A map or message creation expression.
159 ///
160 /// Maps are constructed as `{'key_name': 'value'}`. Message construction is
161 /// similar, but prefixed with a type name and composed of field ids:
162 /// `types.MyType{field_id: 'value'}`.
163 #[derive(Clone, PartialEq, ::prost::Message)]
164 pub struct CreateStruct {
165 /// The type name of the message to be created, empty when creating map
166 /// literals.
167 #[prost(string, tag = "1")]
168 pub message_name: ::prost::alloc::string::String,
169 /// The entries in the creation expression.
170 #[prost(message, repeated, tag = "2")]
171 pub entries: ::prost::alloc::vec::Vec<create_struct::Entry>,
172 }
173 /// Nested message and enum types in `CreateStruct`.
174 pub mod create_struct {
175 /// Represents an entry.
176 #[derive(Clone, PartialEq, ::prost::Message)]
177 pub struct Entry {
178 /// Required. An id assigned to this node by the parser which is unique
179 /// in a given expression tree. This is used to associate type
180 /// information and other attributes to the node.
181 #[prost(int64, tag = "1")]
182 pub id: i64,
183 /// Required. The value assigned to the key.
184 ///
185 /// If the optional_entry field is true, the expression must resolve to an
186 /// optional-typed value. If the optional value is present, the key will be
187 /// set; however, if the optional value is absent, the key will be unset.
188 #[prost(message, optional, tag = "4")]
189 pub value: ::core::option::Option<super::super::Expr>,
190 /// Whether the key-value pair is optional.
191 #[prost(bool, tag = "5")]
192 pub optional_entry: bool,
193 /// The `Entry` key kinds.
194 #[prost(oneof = "entry::KeyKind", tags = "2, 3")]
195 pub key_kind: ::core::option::Option<entry::KeyKind>,
196 }
197 /// Nested message and enum types in `Entry`.
198 pub mod entry {
199 /// The `Entry` key kinds.
200 #[derive(Clone, PartialEq, ::prost::Oneof)]
201 pub enum KeyKind {
202 /// The field key for a message creator statement.
203 #[prost(string, tag = "2")]
204 FieldKey(::prost::alloc::string::String),
205 /// The key expression for a map creation statement.
206 #[prost(message, tag = "3")]
207 MapKey(super::super::super::Expr),
208 }
209 }
210 impl ::prost::Name for Entry {
211 const NAME: &'static str = "Entry";
212 const PACKAGE: &'static str = "cel.expr";
213 fn full_name() -> ::prost::alloc::string::String {
214 "cel.expr.Expr.CreateStruct.Entry".into()
215 }
216 fn type_url() -> ::prost::alloc::string::String {
217 "type.googleapis.com/cel.expr.Expr.CreateStruct.Entry".into()
218 }
219 }
220 }
221 impl ::prost::Name for CreateStruct {
222 const NAME: &'static str = "CreateStruct";
223 const PACKAGE: &'static str = "cel.expr";
224 fn full_name() -> ::prost::alloc::string::String {
225 "cel.expr.Expr.CreateStruct".into()
226 }
227 fn type_url() -> ::prost::alloc::string::String {
228 "type.googleapis.com/cel.expr.Expr.CreateStruct".into()
229 }
230 }
231 /// A comprehension expression applied to a list or map.
232 ///
233 /// Comprehensions are not part of the core syntax, but enabled with macros.
234 /// A macro matches a specific call signature within a parsed AST and replaces
235 /// the call with an alternate AST block. Macro expansion happens at parse
236 /// time.
237 ///
238 /// The following macros are supported within CEL:
239 ///
240 /// Aggregate type macros may be applied to all elements in a list or all keys
241 /// in a map:
242 ///
243 /// * `all`, `exists`, `exists_one` - test a predicate expression against
244 /// the inputs and return `true` if the predicate is satisfied for all,
245 /// any, or only one value `list.all(x, x < 10)`.
246 /// * `filter` - test a predicate expression against the inputs and return
247 /// the subset of elements which satisfy the predicate:
248 /// `payments.filter(p, p > 1000)`.
249 /// * `map` - apply an expression to all elements in the input and return the
250 /// output aggregate type: `\[1, 2, 3\].map(i, i * i)`.
251 ///
252 /// The `has(m.x)` macro tests whether the property `x` is present in struct
253 /// `m`. The semantics of this macro depend on the type of `m`. For proto2
254 /// 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\`.
255 ///
256 /// Comprehensions for the standard environment macros evaluation can be best
257 /// visualized as the following pseudocode:
258 ///
259 /// ```text,
260 /// let `accu_var` = `accu_init`
261 /// for (let `iter_var` in `iter_range`) {
262 /// if (!`loop_condition`) {
263 /// break
264 /// }
265 /// `accu_var` = `loop_step`
266 /// }
267 /// return `result`
268 /// ```
269 ///
270 /// Comprehensions for the optional V2 macros which support map-to-map
271 /// translation differ slightly from the standard environment macros in that
272 /// they expose both the key or index in addition to the value for each list
273 /// or map entry:
274 ///
275 /// ```text,
276 /// let `accu_var` = `accu_init`
277 /// for (let `iter_var`, `iter_var2` in `iter_range`) {
278 /// if (!`loop_condition`) {
279 /// break
280 /// }
281 /// `accu_var` = `loop_step`
282 /// }
283 /// return `result`
284 /// ```
285 #[derive(Clone, PartialEq, ::prost::Message)]
286 pub struct Comprehension {
287 /// The name of the first iteration variable.
288 /// For the single iteration variable macros, when iter_range is a list, this
289 /// variable is the list element and when the iter_range is a map, this
290 /// variable is the map key.
291 #[prost(string, tag = "1")]
292 pub iter_var: ::prost::alloc::string::String,
293 /// The name of the second iteration variable, empty if not set.
294 /// This field is only set for comprehension v2 macros.
295 #[prost(string, tag = "8")]
296 pub iter_var2: ::prost::alloc::string::String,
297 /// The range over which the comprehension iterates.
298 #[prost(message, optional, boxed, tag = "2")]
299 pub iter_range: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
300 /// The name of the variable used for accumulation of the result.
301 #[prost(string, tag = "3")]
302 pub accu_var: ::prost::alloc::string::String,
303 /// The initial value of the accumulator.
304 #[prost(message, optional, boxed, tag = "4")]
305 pub accu_init: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
306 /// An expression which can contain iter_var, iter_var2, and accu_var.
307 ///
308 /// Returns false when the result has been computed and may be used as
309 /// a hint to short-circuit the remainder of the comprehension.
310 #[prost(message, optional, boxed, tag = "5")]
311 pub loop_condition: ::core::option::Option<
312 ::prost::alloc::boxed::Box<super::Expr>,
313 >,
314 /// An expression which can contain iter_var, iter_var2, and accu_var.
315 ///
316 /// Computes the next value of accu_var.
317 #[prost(message, optional, boxed, tag = "6")]
318 pub loop_step: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
319 /// An expression which can contain accu_var.
320 ///
321 /// Computes the result.
322 #[prost(message, optional, boxed, tag = "7")]
323 pub result: ::core::option::Option<::prost::alloc::boxed::Box<super::Expr>>,
324 }
325 impl ::prost::Name for Comprehension {
326 const NAME: &'static str = "Comprehension";
327 const PACKAGE: &'static str = "cel.expr";
328 fn full_name() -> ::prost::alloc::string::String {
329 "cel.expr.Expr.Comprehension".into()
330 }
331 fn type_url() -> ::prost::alloc::string::String {
332 "type.googleapis.com/cel.expr.Expr.Comprehension".into()
333 }
334 }
335 /// Required. Variants of expressions.
336 #[derive(Clone, PartialEq, ::prost::Oneof)]
337 pub enum ExprKind {
338 /// A constant expression.
339 #[prost(message, tag = "3")]
340 ConstExpr(super::Constant),
341 /// An identifier expression.
342 #[prost(message, tag = "4")]
343 IdentExpr(Ident),
344 /// A field selection expression, e.g. `request.auth`.
345 #[prost(message, tag = "5")]
346 SelectExpr(::prost::alloc::boxed::Box<Select>),
347 /// A call expression, including calls to predefined functions and operators.
348 #[prost(message, tag = "6")]
349 CallExpr(::prost::alloc::boxed::Box<Call>),
350 /// A list creation expression.
351 #[prost(message, tag = "7")]
352 ListExpr(CreateList),
353 /// A map or message creation expression.
354 #[prost(message, tag = "8")]
355 StructExpr(CreateStruct),
356 /// A comprehension expression.
357 #[prost(message, tag = "9")]
358 ComprehensionExpr(::prost::alloc::boxed::Box<Comprehension>),
359 }
360}
361impl ::prost::Name for Expr {
362 const NAME: &'static str = "Expr";
363 const PACKAGE: &'static str = "cel.expr";
364 fn full_name() -> ::prost::alloc::string::String {
365 "cel.expr.Expr".into()
366 }
367 fn type_url() -> ::prost::alloc::string::String {
368 "type.googleapis.com/cel.expr.Expr".into()
369 }
370}
371/// Represents a primitive literal.
372///
373/// Named 'Constant' here for backwards compatibility.
374///
375/// This is similar as the primitives supported in the well-known type
376/// `google.protobuf.Value`, but richer so it can represent CEL's full range of
377/// primitives.
378///
379/// Lists and structs are not included as constants as these aggregate types may
380/// contain \[Expr\]\[cel.expr.Expr\] elements which require evaluation and
381/// are thus not constant.
382///
383/// Examples of constants include: `"hello"`, `b'bytes'`, `1u`, `4.2`, `-2`,
384/// `true`, `null`.
385#[derive(Clone, PartialEq, ::prost::Message)]
386pub struct Constant {
387 /// Required. The valid constant kinds.
388 #[prost(oneof = "constant::ConstantKind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9")]
389 pub constant_kind: ::core::option::Option<constant::ConstantKind>,
390}
391/// Nested message and enum types in `Constant`.
392pub mod constant {
393 /// Required. The valid constant kinds.
394 #[derive(Clone, PartialEq, ::prost::Oneof)]
395 pub enum ConstantKind {
396 /// null value.
397 #[prost(
398 enumeration = "super::super::super::google::protobuf::NullValue",
399 tag = "1"
400 )]
401 NullValue(i32),
402 /// boolean value.
403 #[prost(bool, tag = "2")]
404 BoolValue(bool),
405 /// int64 value.
406 #[prost(int64, tag = "3")]
407 Int64Value(i64),
408 /// uint64 value.
409 #[prost(uint64, tag = "4")]
410 Uint64Value(u64),
411 /// double value.
412 #[prost(double, tag = "5")]
413 DoubleValue(f64),
414 /// string value.
415 #[prost(string, tag = "6")]
416 StringValue(::prost::alloc::string::String),
417 /// bytes value.
418 #[prost(bytes, tag = "7")]
419 BytesValue(::prost::alloc::vec::Vec<u8>),
420 /// protobuf.Duration value.
421 ///
422 /// Deprecated: duration is no longer considered a builtin cel type.
423 #[deprecated]
424 #[prost(message, tag = "8")]
425 DurationValue(super::super::super::google::protobuf::Duration),
426 /// protobuf.Timestamp value.
427 ///
428 /// Deprecated: timestamp is no longer considered a builtin cel type.
429 #[deprecated]
430 #[prost(message, tag = "9")]
431 TimestampValue(super::super::super::google::protobuf::Timestamp),
432 }
433}
434impl ::prost::Name for Constant {
435 const NAME: &'static str = "Constant";
436 const PACKAGE: &'static str = "cel.expr";
437 fn full_name() -> ::prost::alloc::string::String {
438 "cel.expr.Constant".into()
439 }
440 fn type_url() -> ::prost::alloc::string::String {
441 "type.googleapis.com/cel.expr.Constant".into()
442 }
443}
444/// Source information collected at parse time.
445#[derive(Clone, PartialEq, ::prost::Message)]
446pub struct SourceInfo {
447 /// The syntax version of the source, e.g. `cel1`.
448 #[prost(string, tag = "1")]
449 pub syntax_version: ::prost::alloc::string::String,
450 /// The location name. All position information attached to an expression is
451 /// relative to this location.
452 ///
453 /// The location could be a file, UI element, or similar. For example,
454 /// `acme/app/AnvilPolicy.cel`.
455 #[prost(string, tag = "2")]
456 pub location: ::prost::alloc::string::String,
457 /// Monotonically increasing list of code point offsets where newlines
458 /// `\n` appear.
459 ///
460 /// The line number of a given position is the index `i` where for a given
461 /// `id` the `line_offsets\[i\] < id_positions\[id\] < line_offsets\[i+1\]`. The
462 /// column may be derived from `id_positions\[id\] - line_offsets\[i\]`.
463 #[prost(int32, repeated, tag = "3")]
464 pub line_offsets: ::prost::alloc::vec::Vec<i32>,
465 /// A map from the parse node id (e.g. `Expr.id`) to the code point offset
466 /// within the source.
467 #[prost(map = "int64, int32", tag = "4")]
468 pub positions: ::std::collections::HashMap<i64, i32>,
469 /// A map from the parse node id where a macro replacement was made to the
470 /// call `Expr` that resulted in a macro expansion.
471 ///
472 /// For example, `has(value.field)` is a function call that is replaced by a
473 /// `test_only` field selection in the AST. Likewise, the call
474 /// `list.exists(e, e > 10)` translates to a comprehension expression. The key
475 /// in the map corresponds to the expression id of the expanded macro, and the
476 /// value is the call `Expr` that was replaced.
477 #[prost(map = "int64, message", tag = "5")]
478 pub macro_calls: ::std::collections::HashMap<i64, Expr>,
479 /// A list of tags for extensions that were used while parsing or type checking
480 /// the source expression. For example, optimizations that require special
481 /// runtime support may be specified.
482 ///
483 /// These are used to check feature support between components in separate
484 /// implementations. This can be used to either skip redundant work or
485 /// report an error if the extension is unsupported.
486 #[prost(message, repeated, tag = "6")]
487 pub extensions: ::prost::alloc::vec::Vec<source_info::Extension>,
488}
489/// Nested message and enum types in `SourceInfo`.
490pub mod source_info {
491 /// An extension that was requested for the source expression.
492 #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
493 pub struct Extension {
494 /// Identifier for the extension. Example: constant_folding
495 #[prost(string, tag = "1")]
496 pub id: ::prost::alloc::string::String,
497 /// If set, the listed components must understand the extension for the
498 /// expression to evaluate correctly.
499 ///
500 /// This field has set semantics, repeated values should be deduplicated.
501 #[prost(enumeration = "extension::Component", repeated, tag = "2")]
502 pub affected_components: ::prost::alloc::vec::Vec<i32>,
503 /// Version info. May be skipped if it isn't meaningful for the extension.
504 /// (for example constant_folding might always be v0.0).
505 #[prost(message, optional, tag = "3")]
506 pub version: ::core::option::Option<extension::Version>,
507 }
508 /// Nested message and enum types in `Extension`.
509 pub mod extension {
510 /// Version
511 #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
512 pub struct Version {
513 /// Major version changes indicate different required support level from
514 /// the required components.
515 #[prost(int64, tag = "1")]
516 pub major: i64,
517 /// Minor version changes must not change the observed behavior from
518 /// existing implementations, but may be provided informationally.
519 #[prost(int64, tag = "2")]
520 pub minor: i64,
521 }
522 impl ::prost::Name for Version {
523 const NAME: &'static str = "Version";
524 const PACKAGE: &'static str = "cel.expr";
525 fn full_name() -> ::prost::alloc::string::String {
526 "cel.expr.SourceInfo.Extension.Version".into()
527 }
528 fn type_url() -> ::prost::alloc::string::String {
529 "type.googleapis.com/cel.expr.SourceInfo.Extension.Version".into()
530 }
531 }
532 /// CEL component specifier.
533 #[derive(
534 Clone,
535 Copy,
536 Debug,
537 PartialEq,
538 Eq,
539 Hash,
540 PartialOrd,
541 Ord,
542 ::prost::Enumeration
543 )]
544 #[repr(i32)]
545 pub enum Component {
546 /// Unspecified, default.
547 Unspecified = 0,
548 /// Parser. Converts a CEL string to an AST.
549 Parser = 1,
550 /// Type checker. Checks that references in an AST are defined and types
551 /// agree.
552 TypeChecker = 2,
553 /// Runtime. Evaluates a parsed and optionally checked CEL AST against a
554 /// context.
555 Runtime = 3,
556 }
557 impl Component {
558 /// String value of the enum field names used in the ProtoBuf definition.
559 ///
560 /// The values are not transformed in any way and thus are considered stable
561 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
562 pub fn as_str_name(&self) -> &'static str {
563 match self {
564 Self::Unspecified => "COMPONENT_UNSPECIFIED",
565 Self::Parser => "COMPONENT_PARSER",
566 Self::TypeChecker => "COMPONENT_TYPE_CHECKER",
567 Self::Runtime => "COMPONENT_RUNTIME",
568 }
569 }
570 /// Creates an enum from field names used in the ProtoBuf definition.
571 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
572 match value {
573 "COMPONENT_UNSPECIFIED" => Some(Self::Unspecified),
574 "COMPONENT_PARSER" => Some(Self::Parser),
575 "COMPONENT_TYPE_CHECKER" => Some(Self::TypeChecker),
576 "COMPONENT_RUNTIME" => Some(Self::Runtime),
577 _ => None,
578 }
579 }
580 }
581 }
582 impl ::prost::Name for Extension {
583 const NAME: &'static str = "Extension";
584 const PACKAGE: &'static str = "cel.expr";
585 fn full_name() -> ::prost::alloc::string::String {
586 "cel.expr.SourceInfo.Extension".into()
587 }
588 fn type_url() -> ::prost::alloc::string::String {
589 "type.googleapis.com/cel.expr.SourceInfo.Extension".into()
590 }
591 }
592}
593impl ::prost::Name for SourceInfo {
594 const NAME: &'static str = "SourceInfo";
595 const PACKAGE: &'static str = "cel.expr";
596 fn full_name() -> ::prost::alloc::string::String {
597 "cel.expr.SourceInfo".into()
598 }
599 fn type_url() -> ::prost::alloc::string::String {
600 "type.googleapis.com/cel.expr.SourceInfo".into()
601 }
602}
603/// A CEL expression which has been successfully type checked.
604#[derive(Clone, PartialEq, ::prost::Message)]
605pub struct CheckedExpr {
606 /// A map from expression ids to resolved references.
607 ///
608 /// The following entries are in this table:
609 ///
610 /// * An Ident or Select expression is represented here if it resolves to a
611 /// declaration. For instance, if `a.b.c` is represented by
612 /// `select(select(id(a), b), c)`, and `a.b` resolves to a declaration,
613 /// while `c` is a field selection, then the reference is attached to the
614 /// nested select expression (but not to the id or or the outer select).
615 /// In turn, if `a` resolves to a declaration and `b.c` are field selections,
616 /// the reference is attached to the ident expression.
617 /// * Every Call expression has an entry here, identifying the function being
618 /// called.
619 /// * Every CreateStruct expression for a message has an entry, identifying
620 /// the message.
621 #[prost(map = "int64, message", tag = "2")]
622 pub reference_map: ::std::collections::HashMap<i64, Reference>,
623 /// A map from expression ids to types.
624 ///
625 /// Every expression node which has a type different than DYN has a mapping
626 /// here. If an expression has type DYN, it is omitted from this map to save
627 /// space.
628 #[prost(map = "int64, message", tag = "3")]
629 pub type_map: ::std::collections::HashMap<i64, Type>,
630 /// The source info derived from input that generated the parsed `expr` and
631 /// any optimizations made during the type-checking pass.
632 #[prost(message, optional, tag = "5")]
633 pub source_info: ::core::option::Option<SourceInfo>,
634 /// The expr version indicates the major / minor version number of the `expr`
635 /// representation.
636 ///
637 /// The most common reason for a version change will be to indicate to the CEL
638 /// runtimes that transformations have been performed on the expr during static
639 /// analysis. In some cases, this will save the runtime the work of applying
640 /// the same or similar transformations prior to evaluation.
641 #[prost(string, tag = "6")]
642 pub expr_version: ::prost::alloc::string::String,
643 /// The checked expression. Semantically equivalent to the parsed `expr`, but
644 /// may have structural differences.
645 #[prost(message, optional, tag = "4")]
646 pub expr: ::core::option::Option<Expr>,
647}
648impl ::prost::Name for CheckedExpr {
649 const NAME: &'static str = "CheckedExpr";
650 const PACKAGE: &'static str = "cel.expr";
651 fn full_name() -> ::prost::alloc::string::String {
652 "cel.expr.CheckedExpr".into()
653 }
654 fn type_url() -> ::prost::alloc::string::String {
655 "type.googleapis.com/cel.expr.CheckedExpr".into()
656 }
657}
658/// Represents a CEL type.
659#[derive(Clone, PartialEq, ::prost::Message)]
660pub struct Type {
661 /// The kind of type.
662 #[prost(
663 oneof = "r#type::TypeKind",
664 tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14"
665 )]
666 pub type_kind: ::core::option::Option<r#type::TypeKind>,
667}
668/// Nested message and enum types in `Type`.
669pub mod r#type {
670 /// List type with typed elements, e.g. `list<example.proto.MyMessage>`.
671 #[derive(Clone, PartialEq, ::prost::Message)]
672 pub struct ListType {
673 /// The element type.
674 #[prost(message, optional, boxed, tag = "1")]
675 pub elem_type: ::core::option::Option<::prost::alloc::boxed::Box<super::Type>>,
676 }
677 impl ::prost::Name for ListType {
678 const NAME: &'static str = "ListType";
679 const PACKAGE: &'static str = "cel.expr";
680 fn full_name() -> ::prost::alloc::string::String {
681 "cel.expr.Type.ListType".into()
682 }
683 fn type_url() -> ::prost::alloc::string::String {
684 "type.googleapis.com/cel.expr.Type.ListType".into()
685 }
686 }
687 /// Map type with parameterized key and value types, e.g. `map<string, int>`.
688 #[derive(Clone, PartialEq, ::prost::Message)]
689 pub struct MapType {
690 /// The type of the key.
691 #[prost(message, optional, boxed, tag = "1")]
692 pub key_type: ::core::option::Option<::prost::alloc::boxed::Box<super::Type>>,
693 /// The type of the value.
694 #[prost(message, optional, boxed, tag = "2")]
695 pub value_type: ::core::option::Option<::prost::alloc::boxed::Box<super::Type>>,
696 }
697 impl ::prost::Name for MapType {
698 const NAME: &'static str = "MapType";
699 const PACKAGE: &'static str = "cel.expr";
700 fn full_name() -> ::prost::alloc::string::String {
701 "cel.expr.Type.MapType".into()
702 }
703 fn type_url() -> ::prost::alloc::string::String {
704 "type.googleapis.com/cel.expr.Type.MapType".into()
705 }
706 }
707 /// Function type with result and arg types.
708 #[derive(Clone, PartialEq, ::prost::Message)]
709 pub struct FunctionType {
710 /// Result type of the function.
711 #[prost(message, optional, boxed, tag = "1")]
712 pub result_type: ::core::option::Option<::prost::alloc::boxed::Box<super::Type>>,
713 /// Argument types of the function.
714 #[prost(message, repeated, tag = "2")]
715 pub arg_types: ::prost::alloc::vec::Vec<super::Type>,
716 }
717 impl ::prost::Name for FunctionType {
718 const NAME: &'static str = "FunctionType";
719 const PACKAGE: &'static str = "cel.expr";
720 fn full_name() -> ::prost::alloc::string::String {
721 "cel.expr.Type.FunctionType".into()
722 }
723 fn type_url() -> ::prost::alloc::string::String {
724 "type.googleapis.com/cel.expr.Type.FunctionType".into()
725 }
726 }
727 /// Application defined abstract type.
728 #[derive(Clone, PartialEq, ::prost::Message)]
729 pub struct AbstractType {
730 /// The fully qualified name of this abstract type.
731 #[prost(string, tag = "1")]
732 pub name: ::prost::alloc::string::String,
733 /// Parameter types for this abstract type.
734 #[prost(message, repeated, tag = "2")]
735 pub parameter_types: ::prost::alloc::vec::Vec<super::Type>,
736 }
737 impl ::prost::Name for AbstractType {
738 const NAME: &'static str = "AbstractType";
739 const PACKAGE: &'static str = "cel.expr";
740 fn full_name() -> ::prost::alloc::string::String {
741 "cel.expr.Type.AbstractType".into()
742 }
743 fn type_url() -> ::prost::alloc::string::String {
744 "type.googleapis.com/cel.expr.Type.AbstractType".into()
745 }
746 }
747 /// CEL primitive types.
748 #[derive(
749 Clone,
750 Copy,
751 Debug,
752 PartialEq,
753 Eq,
754 Hash,
755 PartialOrd,
756 Ord,
757 ::prost::Enumeration
758 )]
759 #[repr(i32)]
760 pub enum PrimitiveType {
761 /// Unspecified type.
762 Unspecified = 0,
763 /// Boolean type.
764 Bool = 1,
765 /// Int64 type.
766 ///
767 /// 32-bit integer values are widened to int64.
768 Int64 = 2,
769 /// Uint64 type.
770 ///
771 /// 32-bit unsigned integer values are widened to uint64.
772 Uint64 = 3,
773 /// Double type.
774 ///
775 /// 32-bit float values are widened to double values.
776 Double = 4,
777 /// String type.
778 String = 5,
779 /// Bytes type.
780 Bytes = 6,
781 }
782 impl PrimitiveType {
783 /// String value of the enum field names used in the ProtoBuf definition.
784 ///
785 /// The values are not transformed in any way and thus are considered stable
786 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
787 pub fn as_str_name(&self) -> &'static str {
788 match self {
789 Self::Unspecified => "PRIMITIVE_TYPE_UNSPECIFIED",
790 Self::Bool => "BOOL",
791 Self::Int64 => "INT64",
792 Self::Uint64 => "UINT64",
793 Self::Double => "DOUBLE",
794 Self::String => "STRING",
795 Self::Bytes => "BYTES",
796 }
797 }
798 /// Creates an enum from field names used in the ProtoBuf definition.
799 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
800 match value {
801 "PRIMITIVE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
802 "BOOL" => Some(Self::Bool),
803 "INT64" => Some(Self::Int64),
804 "UINT64" => Some(Self::Uint64),
805 "DOUBLE" => Some(Self::Double),
806 "STRING" => Some(Self::String),
807 "BYTES" => Some(Self::Bytes),
808 _ => None,
809 }
810 }
811 }
812 /// Well-known protobuf types treated with first-class support in CEL.
813 #[derive(
814 Clone,
815 Copy,
816 Debug,
817 PartialEq,
818 Eq,
819 Hash,
820 PartialOrd,
821 Ord,
822 ::prost::Enumeration
823 )]
824 #[repr(i32)]
825 pub enum WellKnownType {
826 /// Unspecified type.
827 Unspecified = 0,
828 /// Well-known protobuf.Any type.
829 ///
830 /// Any types are a polymorphic message type. During type-checking they are
831 /// treated like `DYN` types, but at runtime they are resolved to a specific
832 /// message type specified at evaluation time.
833 Any = 1,
834 /// Well-known protobuf.Timestamp type, internally referenced as `timestamp`.
835 Timestamp = 2,
836 /// Well-known protobuf.Duration type, internally referenced as `duration`.
837 Duration = 3,
838 }
839 impl WellKnownType {
840 /// String value of the enum field names used in the ProtoBuf definition.
841 ///
842 /// The values are not transformed in any way and thus are considered stable
843 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
844 pub fn as_str_name(&self) -> &'static str {
845 match self {
846 Self::Unspecified => "WELL_KNOWN_TYPE_UNSPECIFIED",
847 Self::Any => "ANY",
848 Self::Timestamp => "TIMESTAMP",
849 Self::Duration => "DURATION",
850 }
851 }
852 /// Creates an enum from field names used in the ProtoBuf definition.
853 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
854 match value {
855 "WELL_KNOWN_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
856 "ANY" => Some(Self::Any),
857 "TIMESTAMP" => Some(Self::Timestamp),
858 "DURATION" => Some(Self::Duration),
859 _ => None,
860 }
861 }
862 }
863 /// The kind of type.
864 #[derive(Clone, PartialEq, ::prost::Oneof)]
865 pub enum TypeKind {
866 /// Dynamic type.
867 #[prost(message, tag = "1")]
868 Dyn(super::super::super::google::protobuf::Empty),
869 /// Null value.
870 #[prost(
871 enumeration = "super::super::super::google::protobuf::NullValue",
872 tag = "2"
873 )]
874 Null(i32),
875 /// Primitive types: `true`, `1u`, `-2.0`, `'string'`, `b'bytes'`.
876 #[prost(enumeration = "PrimitiveType", tag = "3")]
877 Primitive(i32),
878 /// Wrapper of a primitive type, e.g. `google.protobuf.Int64Value`.
879 #[prost(enumeration = "PrimitiveType", tag = "4")]
880 Wrapper(i32),
881 /// Well-known protobuf type such as `google.protobuf.Timestamp`.
882 #[prost(enumeration = "WellKnownType", tag = "5")]
883 WellKnown(i32),
884 /// Parameterized list with elements of `list_type`, e.g. `list<timestamp>`.
885 #[prost(message, tag = "6")]
886 ListType(::prost::alloc::boxed::Box<ListType>),
887 /// Parameterized map with typed keys and values.
888 #[prost(message, tag = "7")]
889 MapType(::prost::alloc::boxed::Box<MapType>),
890 /// Function type.
891 #[prost(message, tag = "8")]
892 Function(::prost::alloc::boxed::Box<FunctionType>),
893 /// Protocol buffer message type.
894 ///
895 /// The `message_type` string specifies the qualified message type name. For
896 /// example, `google.type.PhoneNumber`.
897 #[prost(string, tag = "9")]
898 MessageType(::prost::alloc::string::String),
899 /// Type param type.
900 ///
901 /// The `type_param` string specifies the type parameter name, e.g. `list<E>`
902 /// would be a `list_type` whose element type was a `type_param` type
903 /// named `E`.
904 #[prost(string, tag = "10")]
905 TypeParam(::prost::alloc::string::String),
906 /// Type type.
907 ///
908 /// The `type` value specifies the target type. e.g. int is type with a
909 /// target type of `Primitive.INT64`.
910 #[prost(message, tag = "11")]
911 Type(::prost::alloc::boxed::Box<super::Type>),
912 /// Error type.
913 ///
914 /// During type-checking if an expression is an error, its type is propagated
915 /// as the `ERROR` type. This permits the type-checker to discover other
916 /// errors present in the expression.
917 #[prost(message, tag = "12")]
918 Error(super::super::super::google::protobuf::Empty),
919 /// Abstract, application defined type.
920 ///
921 /// An abstract type has no accessible field names, and it can only be
922 /// inspected via helper / member functions.
923 #[prost(message, tag = "14")]
924 AbstractType(AbstractType),
925 }
926}
927impl ::prost::Name for Type {
928 const NAME: &'static str = "Type";
929 const PACKAGE: &'static str = "cel.expr";
930 fn full_name() -> ::prost::alloc::string::String {
931 "cel.expr.Type".into()
932 }
933 fn type_url() -> ::prost::alloc::string::String {
934 "type.googleapis.com/cel.expr.Type".into()
935 }
936}
937/// Represents a declaration of a named value or function.
938///
939/// A declaration is part of the contract between the expression, the agent
940/// evaluating that expression, and the caller requesting evaluation.
941#[derive(Clone, PartialEq, ::prost::Message)]
942pub struct Decl {
943 /// The fully qualified name of the declaration.
944 ///
945 /// Declarations are organized in containers and this represents the full path
946 /// to the declaration in its container, as in `cel.expr.Decl`.
947 ///
948 /// Declarations used as
949 /// \[FunctionDecl.Overload\]\[cel.expr.Decl.FunctionDecl.Overload\]
950 /// parameters may or may not have a name depending on whether the overload is
951 /// function declaration or a function definition containing a result
952 /// \[Expr\]\[cel.expr.Expr\].
953 #[prost(string, tag = "1")]
954 pub name: ::prost::alloc::string::String,
955 /// Required. The declaration kind.
956 #[prost(oneof = "decl::DeclKind", tags = "2, 3")]
957 pub decl_kind: ::core::option::Option<decl::DeclKind>,
958}
959/// Nested message and enum types in `Decl`.
960pub mod decl {
961 /// Identifier declaration which specifies its type and optional `Expr` value.
962 ///
963 /// An identifier without a value is a declaration that must be provided at
964 /// evaluation time. An identifier with a value should resolve to a constant,
965 /// but may be used in conjunction with other identifiers bound at evaluation
966 /// time.
967 #[derive(Clone, PartialEq, ::prost::Message)]
968 pub struct IdentDecl {
969 /// Required. The type of the identifier.
970 #[prost(message, optional, tag = "1")]
971 pub r#type: ::core::option::Option<super::Type>,
972 /// The constant value of the identifier. If not specified, the identifier
973 /// must be supplied at evaluation time.
974 #[prost(message, optional, tag = "2")]
975 pub value: ::core::option::Option<super::Constant>,
976 /// Documentation string for the identifier.
977 ///
978 /// Provide a brief description of what the variable represents and whether
979 /// there are any constraints on the formatting or supported value range.
980 ///
981 /// Examples:
982 ///
983 /// ```text
984 /// 'request.auth.principal' - string which uniquely identifies an
985 /// authenticated principal. For JSON Web Tokens (JWTs), the principal
986 /// is the combination of the issuer ('iss') and subject ('sub') token
987 /// fields concatenated by a forward slash: iss + `/` + sub.
988 ///
989 /// 'min_cpus' - integer value indicates the minimum number of CPUs
990 /// required for a compute cluster. The 'min_cpus' value must be
991 /// greater than zero and less than 'max_cpus' or 64 whichever is less.
992 /// ```
993 #[prost(string, tag = "3")]
994 pub doc: ::prost::alloc::string::String,
995 }
996 impl ::prost::Name for IdentDecl {
997 const NAME: &'static str = "IdentDecl";
998 const PACKAGE: &'static str = "cel.expr";
999 fn full_name() -> ::prost::alloc::string::String {
1000 "cel.expr.Decl.IdentDecl".into()
1001 }
1002 fn type_url() -> ::prost::alloc::string::String {
1003 "type.googleapis.com/cel.expr.Decl.IdentDecl".into()
1004 }
1005 }
1006 /// Function declaration specifies one or more overloads which indicate the
1007 /// function's parameter types and return type.
1008 ///
1009 /// Functions have no observable side-effects (there may be side-effects like
1010 /// logging which are not observable from CEL).
1011 #[derive(Clone, PartialEq, ::prost::Message)]
1012 pub struct FunctionDecl {
1013 /// Required. List of function overloads, must contain at least one overload.
1014 #[prost(message, repeated, tag = "1")]
1015 pub overloads: ::prost::alloc::vec::Vec<function_decl::Overload>,
1016 /// Documentation string for the function that indicates the general purpose
1017 /// of the function and its behavior.
1018 ///
1019 /// Documentation strings for the function should be general purpose with
1020 /// specific examples provided in the overload doc string.
1021 ///
1022 /// Examples:
1023 ///
1024 /// ```text
1025 /// The 'in' operator tests whether an item exists in a collection.
1026 ///
1027 /// The 'substring' function returns a substring of a target string.
1028 /// ```
1029 #[prost(string, tag = "2")]
1030 pub doc: ::prost::alloc::string::String,
1031 }
1032 /// Nested message and enum types in `FunctionDecl`.
1033 pub mod function_decl {
1034 /// An overload indicates a function's parameter types and return type, and
1035 /// may optionally include a function body described in terms of
1036 /// \[Expr\]\[cel.expr.Expr\] values.
1037 ///
1038 /// Functions overloads are declared in either a function or method
1039 /// call-style. For methods, the `params\[0\]` is the expected type of the
1040 /// target receiver.
1041 ///
1042 /// Overloads must have non-overlapping argument types after erasure of all
1043 /// parameterized type variables (similar as type erasure in Java).
1044 #[derive(Clone, PartialEq, ::prost::Message)]
1045 pub struct Overload {
1046 /// Required. Globally unique overload name of the function which reflects
1047 /// the function name and argument types.
1048 ///
1049 /// This will be used by a \[Reference\]\[cel.expr.Reference\] to
1050 /// indicate the `overload_id` that was resolved for the function `name`.
1051 #[prost(string, tag = "1")]
1052 pub overload_id: ::prost::alloc::string::String,
1053 /// List of function parameter \[Type\]\[cel.expr.Type\] values.
1054 ///
1055 /// Param types are disjoint after generic type parameters have been
1056 /// replaced with the type `DYN`. Since the `DYN` type is compatible with
1057 /// any other type, this means that if `A` is a type parameter, the
1058 /// function types `int<A>` and `int<int>` are not disjoint. Likewise,
1059 /// `map<string, string>` is not disjoint from `map<K, V>`.
1060 ///
1061 /// When the `result_type` of a function is a generic type param, the
1062 /// type param name also appears as the `type` of on at least one params.
1063 #[prost(message, repeated, tag = "2")]
1064 pub params: ::prost::alloc::vec::Vec<super::super::Type>,
1065 /// The type param names associated with the function declaration.
1066 ///
1067 /// For example, `function ex<K,V>(K key, map<K, V> map) : V` would yield
1068 /// the type params of `K, V`.
1069 #[prost(string, repeated, tag = "3")]
1070 pub type_params: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1071 /// Required. The result type of the function. For example, the operator
1072 /// `string.isEmpty()` would have `result_type` of `kind: BOOL`.
1073 #[prost(message, optional, tag = "4")]
1074 pub result_type: ::core::option::Option<super::super::Type>,
1075 /// Whether the function is to be used in a method call-style `x.f(...)`
1076 /// of a function call-style `f(x, ...)`.
1077 ///
1078 /// For methods, the first parameter declaration, `params\[0\]` is the
1079 /// expected type of the target receiver.
1080 #[prost(bool, tag = "5")]
1081 pub is_instance_function: bool,
1082 /// Documentation string for the overload.
1083 ///
1084 /// Provide examples of the overload behavior, preferring to use literal
1085 /// values as input with a comment on the return value.
1086 ///
1087 /// Examples:
1088 ///
1089 /// ```text
1090 /// // Determine whether a value of type <V> exists within a list<V>.
1091 /// 2 in \[1, 2, 3\] // returns true
1092 ///
1093 /// // Determine whether a key of type <K> exists within a map<K,V>.
1094 /// 'hello' in {'hi': 'you', 'hello': 'there'} // returns true
1095 /// 'help' in {'hi': 'you', 'hello': 'there'} // returns false
1096 ///
1097 /// // Take the substring of a string starting at a specific character
1098 /// // offset (inclusive).
1099 /// "tacocat".substring(1) // returns "acocat"
1100 /// "tacocat".substring(20) // error
1101 ///
1102 /// // Take the substring of a string starting at a specific character
1103 /// // offset (inclusive) and ending at the given offset (exclusive).
1104 /// "tacocat".substring(1, 6) // returns "acoca"
1105 /// ```
1106 #[prost(string, tag = "6")]
1107 pub doc: ::prost::alloc::string::String,
1108 }
1109 impl ::prost::Name for Overload {
1110 const NAME: &'static str = "Overload";
1111 const PACKAGE: &'static str = "cel.expr";
1112 fn full_name() -> ::prost::alloc::string::String {
1113 "cel.expr.Decl.FunctionDecl.Overload".into()
1114 }
1115 fn type_url() -> ::prost::alloc::string::String {
1116 "type.googleapis.com/cel.expr.Decl.FunctionDecl.Overload".into()
1117 }
1118 }
1119 }
1120 impl ::prost::Name for FunctionDecl {
1121 const NAME: &'static str = "FunctionDecl";
1122 const PACKAGE: &'static str = "cel.expr";
1123 fn full_name() -> ::prost::alloc::string::String {
1124 "cel.expr.Decl.FunctionDecl".into()
1125 }
1126 fn type_url() -> ::prost::alloc::string::String {
1127 "type.googleapis.com/cel.expr.Decl.FunctionDecl".into()
1128 }
1129 }
1130 /// Required. The declaration kind.
1131 #[derive(Clone, PartialEq, ::prost::Oneof)]
1132 pub enum DeclKind {
1133 /// Identifier declaration.
1134 #[prost(message, tag = "2")]
1135 Ident(IdentDecl),
1136 /// Function declaration.
1137 #[prost(message, tag = "3")]
1138 Function(FunctionDecl),
1139 }
1140}
1141impl ::prost::Name for Decl {
1142 const NAME: &'static str = "Decl";
1143 const PACKAGE: &'static str = "cel.expr";
1144 fn full_name() -> ::prost::alloc::string::String {
1145 "cel.expr.Decl".into()
1146 }
1147 fn type_url() -> ::prost::alloc::string::String {
1148 "type.googleapis.com/cel.expr.Decl".into()
1149 }
1150}
1151/// Describes a resolved reference to a declaration.
1152#[derive(Clone, PartialEq, ::prost::Message)]
1153pub struct Reference {
1154 /// The fully qualified name of the declaration.
1155 #[prost(string, tag = "1")]
1156 pub name: ::prost::alloc::string::String,
1157 /// For references to functions, this is a list of `Overload.overload_id`
1158 /// values which match according to typing rules.
1159 ///
1160 /// If the list has more than one element, overload resolution among the
1161 /// presented candidates must happen at runtime because of dynamic types. The
1162 /// type checker attempts to narrow down this list as much as possible.
1163 ///
1164 /// Empty if this is not a reference to a
1165 /// \[Decl.FunctionDecl\]\[cel.expr.Decl.FunctionDecl\].
1166 #[prost(string, repeated, tag = "3")]
1167 pub overload_id: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1168 /// For references to constants, this may contain the value of the
1169 /// constant if known at compile time.
1170 #[prost(message, optional, tag = "4")]
1171 pub value: ::core::option::Option<Constant>,
1172}
1173impl ::prost::Name for Reference {
1174 const NAME: &'static str = "Reference";
1175 const PACKAGE: &'static str = "cel.expr";
1176 fn full_name() -> ::prost::alloc::string::String {
1177 "cel.expr.Reference".into()
1178 }
1179 fn type_url() -> ::prost::alloc::string::String {
1180 "type.googleapis.com/cel.expr.Reference".into()
1181 }
1182}