@devvit/protos 0.11.4 → 0.11.5-next-2024-12-09-1c29dd3cd.0

package/schema/.snootobuf/deps/google/api/expr/conformance/v1alpha1/conformance_service.proto

@@ -0,0 +1,183 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package google.api.expr.conformance.v1alpha1;
+
+import "google/api/client.proto";
+import "google/api/expr/v1alpha1/checked.proto";
+import "google/api/expr/v1alpha1/eval.proto";
+import "google/api/expr/v1alpha1/syntax.proto";
+import "google/rpc/status.proto";
+
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/genproto/googleapis/api/expr/conformance/v1alpha1;confpb";
+option java_multiple_files = true;
+option java_outer_classname = "ConformanceServiceProto";
+option java_package = "com.google.api.expr.conformance.v1alpha1";
+
+// Access a CEL implementation from another process or machine.
+// A CEL implementation is decomposed as a parser, a static checker,
+// and an evaluator.  Every CEL implementation is expected to provide
+// a server for this API.  The API will be used for conformance testing
+// and other utilities.
+service ConformanceService {
+  option (google.api.default_host) = "cel.googleapis.com";
+
+  // Transforms CEL source text into a parsed representation.
+  rpc Parse(ParseRequest) returns (ParseResponse) {
+  }
+
+  // Runs static checks on a parsed CEL representation and return
+  // an annotated representation, or a set of issues.
+  rpc Check(CheckRequest) returns (CheckResponse) {
+  }
+
+  // Evaluates a parsed or annotation CEL representation given
+  // values of external bindings.
+  rpc Eval(EvalRequest) returns (EvalResponse) {
+  }
+}
+
+// Request message for the Parse method.
+message ParseRequest {
+  // Required. Source text in CEL syntax.
+  string cel_source = 1;
+
+  // Tag for version of CEL syntax, for future use.
+  string syntax_version = 2;
+
+  // File or resource for source text, used in [SourceInfo][google.api.SourceInfo].
+  string source_location = 3;
+
+  // Prevent macro expansion.  See "Macros" in Language Defiinition.
+  bool disable_macros = 4;
+}
+
+// Response message for the Parse method.
+message ParseResponse {
+  // The parsed representation, or unset if parsing failed.
+  google.api.expr.v1alpha1.ParsedExpr parsed_expr = 1;
+
+  // Any number of issues with [StatusDetails][] as the details.
+  repeated google.rpc.Status issues = 2;
+}
+
+// Request message for the Check method.
+message CheckRequest {
+  // Required. The parsed representation of the CEL program.
+  google.api.expr.v1alpha1.ParsedExpr parsed_expr = 1;
+
+  // Declarations of types for external variables and functions.
+  // Required if program uses external variables or functions
+  // not in the default environment.
+  repeated google.api.expr.v1alpha1.Decl type_env = 2;
+
+  // The protocol buffer context.  See "Name Resolution" in the
+  // Language Definition.
+  string container = 3;
+
+  // If true, use only the declarations in [type_env][google.api.expr.conformance.v1alpha1.CheckRequest.type_env].  If false (default),
+  // add declarations for the standard definitions to the type environment.  See
+  // "Standard Definitions" in the Language Definition.
+  bool no_std_env = 4;
+}
+
+// Response message for the Check method.
+message CheckResponse {
+  // The annotated representation, or unset if checking failed.
+  google.api.expr.v1alpha1.CheckedExpr checked_expr = 1;
+
+  // Any number of issues with [StatusDetails][] as the details.
+  repeated google.rpc.Status issues = 2;
+}
+
+// Request message for the Eval method.
+message EvalRequest {
+  // Required. Either the parsed or annotated representation of the CEL program.
+  oneof expr_kind {
+    // Evaluate based on the parsed representation.
+    google.api.expr.v1alpha1.ParsedExpr parsed_expr = 1;
+
+    // Evaluate based on the checked representation.
+    google.api.expr.v1alpha1.CheckedExpr checked_expr = 2;
+  }
+
+  // Bindings for the external variables.  The types SHOULD be compatible
+  // with the type environment in [CheckRequest][google.api.expr.conformance.v1alpha1.CheckRequest], if checked.
+  map<string, google.api.expr.v1alpha1.ExprValue> bindings = 3;
+
+  // SHOULD be the same container as used in [CheckRequest][google.api.expr.conformance.v1alpha1.CheckRequest], if checked.
+  string container = 4;
+}
+
+// Response message for the Eval method.
+message EvalResponse {
+  // The execution result, or unset if execution couldn't start.
+  google.api.expr.v1alpha1.ExprValue result = 1;
+
+  // Any number of issues with [StatusDetails][] as the details.
+  // Note that CEL execution errors are reified into [ExprValue][].
+  // Nevertheless, we'll allow out-of-band issues to be raised,
+  // which also makes the replies more regular.
+  repeated google.rpc.Status issues = 2;
+}
+
+// A specific position in source.
+message SourcePosition {
+  // The source location name (e.g. file name).
+  string location = 1;
+
+  // The UTF-8 code unit offset.
+  int32 offset = 2;
+
+  // The 1-based index of the starting line in the source text
+  // where the issue occurs, or 0 if unknown.
+  int32 line = 3;
+
+  // The 0-based index of the starting position within the line of source text
+  // where the issue occurs.  Only meaningful if line is nonzero.
+  int32 column = 4;
+}
+
+// Warnings or errors in service execution are represented by
+// [google.rpc.Status][google.rpc.Status] messages, with the following message
+// in the details field.
+message IssueDetails {
+  // Severities of issues.
+  enum Severity {
+    // An unspecified severity.
+    SEVERITY_UNSPECIFIED = 0;
+
+    // Deprecation issue for statements and method that may no longer be
+    // supported or maintained.
+    DEPRECATION = 1;
+
+    // Warnings such as: unused variables.
+    WARNING = 2;
+
+    // Errors such as: unmatched curly braces or variable redefinition.
+    ERROR = 3;
+  }
+
+  // The severity of the issue.
+  Severity severity = 1;
+
+  // Position in the source, if known.
+  SourcePosition position = 2;
+
+  // Expression ID from [Expr][], 0 if unknown.
+  int64 id = 3;
+}

package/schema/.snootobuf/deps/google/api/expr/v1alpha1/checked.proto

@@ -0,0 +1,343 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package google.api.expr.v1alpha1;
+
+import "google/api/expr/v1alpha1/syntax.proto";
+import "google/protobuf/empty.proto";
+import "google/protobuf/struct.proto";
+
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/genproto/googleapis/api/expr/v1alpha1;expr";
+option java_multiple_files = true;
+option java_outer_classname = "DeclProto";
+option java_package = "com.google.api.expr.v1alpha1";
+
+// Protos for representing CEL declarations and typed checked expressions.
+
+// A CEL expression which has been successfully type checked.
+message CheckedExpr {
+  // A map from expression ids to resolved references.
+  //
+  // The following entries are in this table:
+  //
+  // - An Ident or Select expression is represented here if it resolves to a
+  //   declaration. For instance, if `a.b.c` is represented by
+  //   `select(select(id(a), b), c)`, and `a.b` resolves to a declaration,
+  //   while `c` is a field selection, then the reference is attached to the
+  //   nested select expression (but not to the id or or the outer select).
+  //   In turn, if `a` resolves to a declaration and `b.c` are field selections,
+  //   the reference is attached to the ident expression.
+  // - Every Call expression has an entry here, identifying the function being
+  //   called.
+  // - Every CreateStruct expression for a message has an entry, identifying
+  //   the message.
+  map<int64, Reference> reference_map = 2;
+
+  // A map from expression ids to types.
+  //
+  // Every expression node which has a type different than DYN has a mapping
+  // here. If an expression has type DYN, it is omitted from this map to save
+  // space.
+  map<int64, Type> type_map = 3;
+
+  // The source info derived from input that generated the parsed `expr` and
+  // any optimizations made during the type-checking pass.
+  SourceInfo source_info = 5;
+
+  // The expr version indicates the major / minor version number of the `expr`
+  // representation.
+  //
+  // The most common reason for a version change will be to indicate to the CEL
+  // runtimes that transformations have been performed on the expr during static
+  // analysis. In some cases, this will save the runtime the work of applying
+  // the same or similar transformations prior to evaluation.
+  string expr_version = 6;
+
+  // The checked expression. Semantically equivalent to the parsed `expr`, but
+  // may have structural differences.
+  Expr expr = 4;
+}
+
+// Represents a CEL type.
+message Type {
+  // List type with typed elements, e.g. `list<example.proto.MyMessage>`.
+  message ListType {
+    // The element type.
+    Type elem_type = 1;
+  }
+
+  // Map type with parameterized key and value types, e.g. `map<string, int>`.
+  message MapType {
+    // The type of the key.
+    Type key_type = 1;
+
+    // The type of the value.
+    Type value_type = 2;
+  }
+
+  // Function type with result and arg types.
+  message FunctionType {
+    // Result type of the function.
+    Type result_type = 1;
+
+    // Argument types of the function.
+    repeated Type arg_types = 2;
+  }
+
+  // Application defined abstract type.
+  message AbstractType {
+    // The fully qualified name of this abstract type.
+    string name = 1;
+
+    // Parameter types for this abstract type.
+    repeated Type parameter_types = 2;
+  }
+
+  // CEL primitive types.
+  enum PrimitiveType {
+    // Unspecified type.
+    PRIMITIVE_TYPE_UNSPECIFIED = 0;
+
+    // Boolean type.
+    BOOL = 1;
+
+    // Int64 type.
+    //
+    // Proto-based integer values are widened to int64.
+    INT64 = 2;
+
+    // Uint64 type.
+    //
+    // Proto-based unsigned integer values are widened to uint64.
+    UINT64 = 3;
+
+    // Double type.
+    //
+    // Proto-based float values are widened to double values.
+    DOUBLE = 4;
+
+    // String type.
+    STRING = 5;
+
+    // Bytes type.
+    BYTES = 6;
+  }
+
+  // Well-known protobuf types treated with first-class support in CEL.
+  enum WellKnownType {
+    // Unspecified type.
+    WELL_KNOWN_TYPE_UNSPECIFIED = 0;
+
+    // Well-known protobuf.Any type.
+    //
+    // Any types are a polymorphic message type. During type-checking they are
+    // treated like `DYN` types, but at runtime they are resolved to a specific
+    // message type specified at evaluation time.
+    ANY = 1;
+
+    // Well-known protobuf.Timestamp type, internally referenced as `timestamp`.
+    TIMESTAMP = 2;
+
+    // Well-known protobuf.Duration type, internally referenced as `duration`.
+    DURATION = 3;
+  }
+
+  // The kind of type.
+  oneof type_kind {
+    // Dynamic type.
+    google.protobuf.Empty dyn = 1;
+
+    // Null value.
+    google.protobuf.NullValue null = 2;
+
+    // Primitive types: `true`, `1u`, `-2.0`, `'string'`, `b'bytes'`.
+    PrimitiveType primitive = 3;
+
+    // Wrapper of a primitive type, e.g. `google.protobuf.Int64Value`.
+    PrimitiveType wrapper = 4;
+
+    // Well-known protobuf type such as `google.protobuf.Timestamp`.
+    WellKnownType well_known = 5;
+
+    // Parameterized list with elements of `list_type`, e.g. `list<timestamp>`.
+    ListType list_type = 6;
+
+    // Parameterized map with typed keys and values.
+    MapType map_type = 7;
+
+    // Function type.
+    FunctionType function = 8;
+
+    // Protocol buffer message type.
+    //
+    // The `message_type` string specifies the qualified message type name. For
+    // example, `google.plus.Profile`.
+    string message_type = 9;
+
+    // Type param type.
+    //
+    // The `type_param` string specifies the type parameter name, e.g. `list<E>`
+    // would be a `list_type` whose element type was a `type_param` type
+    // named `E`.
+    string type_param = 10;
+
+    // Type type.
+    //
+    // The `type` value specifies the target type. e.g. int is type with a
+    // target type of `Primitive.INT`.
+    Type type = 11;
+
+    // Error type.
+    //
+    // During type-checking if an expression is an error, its type is propagated
+    // as the `ERROR` type. This permits the type-checker to discover other
+    // errors present in the expression.
+    google.protobuf.Empty error = 12;
+
+    // Abstract, application defined type.
+    AbstractType abstract_type = 14;
+  }
+}
+
+// Represents a declaration of a named value or function.
+//
+// A declaration is part of the contract between the expression, the agent
+// evaluating that expression, and the caller requesting evaluation.
+message Decl {
+  // Identifier declaration which specifies its type and optional `Expr` value.
+  //
+  // An identifier without a value is a declaration that must be provided at
+  // evaluation time. An identifier with a value should resolve to a constant,
+  // but may be used in conjunction with other identifiers bound at evaluation
+  // time.
+  message IdentDecl {
+    // Required. The type of the identifier.
+    Type type = 1;
+
+    // The constant value of the identifier. If not specified, the identifier
+    // must be supplied at evaluation time.
+    Constant value = 2;
+
+    // Documentation string for the identifier.
+    string doc = 3;
+  }
+
+  // Function declaration specifies one or more overloads which indicate the
+  // function's parameter types and return type.
+  //
+  // Functions have no observable side-effects (there may be side-effects like
+  // logging which are not observable from CEL).
+  message FunctionDecl {
+    // An overload indicates a function's parameter types and return type, and
+    // may optionally include a function body described in terms of
+    // [Expr][google.api.expr.v1alpha1.Expr] values.
+    //
+    // Functions overloads are declared in either a function or method
+    // call-style. For methods, the `params[0]` is the expected type of the
+    // target receiver.
+    //
+    // Overloads must have non-overlapping argument types after erasure of all
+    // parameterized type variables (similar as type erasure in Java).
+    message Overload {
+      // Required. Globally unique overload name of the function which reflects
+      // the function name and argument types.
+      //
+      // This will be used by a [Reference][google.api.expr.v1alpha1.Reference]
+      // to indicate the `overload_id` that was resolved for the function
+      // `name`.
+      string overload_id = 1;
+
+      // List of function parameter [Type][google.api.expr.v1alpha1.Type]
+      // values.
+      //
+      // Param types are disjoint after generic type parameters have been
+      // replaced with the type `DYN`. Since the `DYN` type is compatible with
+      // any other type, this means that if `A` is a type parameter, the
+      // function types `int<A>` and `int<int>` are not disjoint. Likewise,
+      // `map<string, string>` is not disjoint from `map<K, V>`.
+      //
+      // When the `result_type` of a function is a generic type param, the
+      // type param name also appears as the `type` of on at least one params.
+      repeated Type params = 2;
+
+      // The type param names associated with the function declaration.
+      //
+      // For example, `function ex<K,V>(K key, map<K, V> map) : V` would yield
+      // the type params of `K, V`.
+      repeated string type_params = 3;
+
+      // Required. The result type of the function. For example, the operator
+      // `string.isEmpty()` would have `result_type` of `kind: BOOL`.
+      Type result_type = 4;
+
+      // Whether the function is to be used in a method call-style `x.f(...)`
+      // or a function call-style `f(x, ...)`.
+      //
+      // For methods, the first parameter declaration, `params[0]` is the
+      // expected type of the target receiver.
+      bool is_instance_function = 5;
+
+      // Documentation string for the overload.
+      string doc = 6;
+    }
+
+    // Required. List of function overloads, must contain at least one overload.
+    repeated Overload overloads = 1;
+  }
+
+  // The fully qualified name of the declaration.
+  //
+  // Declarations are organized in containers and this represents the full path
+  // to the declaration in its container, as in `google.api.expr.Decl`.
+  //
+  // Declarations used as
+  // [FunctionDecl.Overload][google.api.expr.v1alpha1.Decl.FunctionDecl.Overload]
+  // parameters may or may not have a name depending on whether the overload is
+  // function declaration or a function definition containing a result
+  // [Expr][google.api.expr.v1alpha1.Expr].
+  string name = 1;
+
+  // Required. The declaration kind.
+  oneof decl_kind {
+    // Identifier declaration.
+    IdentDecl ident = 2;
+
+    // Function declaration.
+    FunctionDecl function = 3;
+  }
+}
+
+// Describes a resolved reference to a declaration.
+message Reference {
+  // The fully qualified name of the declaration.
+  string name = 1;
+
+  // For references to functions, this is a list of `Overload.overload_id`
+  // values which match according to typing rules.
+  //
+  // If the list has more than one element, overload resolution among the
+  // presented candidates must happen at runtime because of dynamic types. The
+  // type checker attempts to narrow down this list as much as possible.
+  //
+  // Empty if this is not a reference to a
+  // [Decl.FunctionDecl][google.api.expr.v1alpha1.Decl.FunctionDecl].
+  repeated string overload_id = 3;
+
+  // For references to constants, this may contain the value of the
+  // constant if known at compile time.
+  Constant value = 4;
+}

package/schema/.snootobuf/deps/google/api/expr/v1alpha1/eval.proto

@@ -0,0 +1,118 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package google.api.expr.v1alpha1;
+
+import "google/api/expr/v1alpha1/value.proto";
+import "google/rpc/status.proto";
+
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/genproto/googleapis/api/expr/v1alpha1;expr";
+option java_multiple_files = true;
+option java_outer_classname = "EvalProto";
+option java_package = "com.google.api.expr.v1alpha1";
+
+// The state of an evaluation.
+//
+// Can represent an inital, partial, or completed state of evaluation.
+message EvalState {
+  // A single evalution result.
+  message Result {
+    // The id of the expression this result if for.
+    int64 expr = 1;
+
+    // The index in `values` of the resulting value.
+    int64 value = 2;
+  }
+
+  // The unique values referenced in this message.
+  repeated ExprValue values = 1;
+
+  // An ordered list of results.
+  //
+  // Tracks the flow of evaluation through the expression.
+  // May be sparse.
+  repeated Result results = 3;
+}
+
+// The value of an evaluated expression.
+message ExprValue {
+  // An expression can resolve to a value, error or unknown.
+  oneof kind {
+    // A concrete value.
+    Value value = 1;
+
+    // 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.
+    ErrorSet error = 2;
+
+    // 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>
+    UnknownSet unknown = 3;
+  }
+}
+
+// A set of errors.
+//
+// The errors included depend on the context. See `ExprValue.error`.
+message ErrorSet {
+  // The errors in the set.
+  repeated google.rpc.Status errors = 1;
+}
+
+// A set of expressions for which the value is unknown.
+//
+// The unknowns included depend on the context. See `ExprValue.unknown`.
+message UnknownSet {
+  // The ids of the expressions with unknown values.
+  repeated int64 exprs = 1;
+}

package/schema/.snootobuf/deps/google/api/expr/v1alpha1/explain.proto

@@ -0,0 +1,53 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package google.api.expr.v1alpha1;
+
+import "google/api/expr/v1alpha1/value.proto";
+
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/genproto/googleapis/api/expr/v1alpha1;expr";
+option java_multiple_files = true;
+option java_outer_classname = "ExplainProto";
+option java_package = "com.google.api.expr.v1alpha1";
+
+// Values of intermediate expressions produced when evaluating expression.
+// Deprecated, use `EvalState` instead.
+message Explain {
+  option deprecated = true;
+
+  // ID and value index of one step.
+  message ExprStep {
+    // ID of corresponding Expr node.
+    int64 id = 1;
+
+    // Index of the value in the values list.
+    int32 value_index = 2;
+  }
+
+  // All of the observed values.
+  //
+  // The field value_index is an index in the values list.
+  // Separating values from steps is needed to remove redundant values.
+  repeated Value values = 1;
+
+  // List of steps.
+  //
+  // Repeated evaluations of the same expression generate new ExprStep
+  // instances. The order of such ExprStep instances matches the order of
+  // elements returned by Comprehension.iter_range.
+  repeated ExprStep expr_steps = 2;
+}