protoeval

type Env struct {
	// contains filtered or unexported fields
}

type Scope struct {

	// parent is the parent scope of this scope. If omitted, this scope is the
	// root scope.
	Parent *Scope `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// field_descriptor describes the field leading up to the value of this Scope.
	// If omitted, this scope is the root scope.
	FieldDescriptor *descriptorpb.FieldDescriptorProto `protobuf:"bytes,2,opt,name=field_descriptor,json=fieldDescriptor,proto3" json:"field_descriptor,omitempty"`
	// value is the scope value for messages and scalars. For scalars, the
	// google.protobuf wrappers types will be used. Enum values will be
	// converted to google.protobuf.Int32Value.
	// CEL automatically converts the Any and wrapper types to their proper
	// message or scalar types.
	// If the scope value is not a message or a scalar, value will be omitted.
	Value *anypb.Any `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	// list is the scope value for lists. If the list element type is a scalar,
	// a google.protobuf wrappers type will be used.
	// CEL automatically converts the Any and wrapper types to their proper
	// message or scalar types.
	// If the scope value is not a list, list will be omitted.
	List []*anypb.Any `protobuf:"bytes,4,rep,name=list,proto3" json:"list,omitempty"`
	// map is the scope value for maps. If the map key type is not a string, the
	// keys will be converted to a string as follows:
	//
	//     /-----------------------------------------\
	//     | Key     | String representation of Key  |
	//     |=========|===============================|
	//     | false   | "False"                       |
	//     | true    | "True"                        |
	//     | integer | The integer as decimal string |
	//     \-----------------------------------------/
	//
	// If the map value type is a scalar, a google.protobuf wrappers type will be
	// used. CEL automatically converts the Any and wrapper types to their proper
	// message or scalar types.
	// If the scope value is not a map, map will be omitted.
	Map map[string]*anypb.Any `` /* 147-byte string literal not displayed */
	// contains filtered or unexported fields
}

type Value struct {

	// drop_args drops the specified number of arguments (optional). That is, if
	// drop_args = n, args 0 through n-1 are dropped and the previously n-th
	// argument becomes the 0-th argument.
	// drop_args is applied before the args field is.
	//
	// Since arguments are available only from the current scope and all
	// subscopes, explicitly dropping arguments may be unnecessary.
	DropArgs uint32 `protobuf:"varint,1,opt,name=drop_args,json=dropArgs,proto3" json:"drop_args,omitempty"`
	// args adds the specified arguments. Arguments can be accessed by a
	// zero based index. Previous arguments are shifted, e. g., if the length
	// of args is n, the previous 0-th argument becomes the n-th argument.
	// Optional.
	//
	// The args field is applied after the drop_args and the scope fields.
	// The arguments are available in the resulting scope and all subscopes.
	Args []*Value `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"`
	// scope changes the scope relative to the current scope.
	//
	// If omitted, the current scope remains unchanged.
	//
	// If empty, forces the creation of a new scope identical to its parent scope.
	// This can be useful in combination with argument handling.
	//
	// If non-empty, each element corresponds to a field, list element, or map
	// entry selection. A string element can select a message field by name or a
	// map entry (if the map does not have string keys, an attempt at conversion
	// will be made). A number element can select a message field by field number,
	// a list entry by index, or a map entry if the map has integer keys. It is an
	// error if the number is not losslessly convertible to the corresponding
	// integer type. A bool element can only select a map entry, and the map must
	// have boolean keys.
	Scope *structpb.ListValue `protobuf:"bytes,3,opt,name=scope,proto3" json:"scope,omitempty"`
	// value describes the actual value. If omitted, the value will be the
	// scope value.
	//
	// Types that are assignable to Value:
	//	*Value_Arg
	//	*Value_Parent
	//	*Value_Default
	//	*Value_BasicValue
	//	*Value_Int
	//	*Value_Uint
	//	*Value_Bytes
	//	*Value_Enum_
	//	*Value_List_
	//	*Value_Map_
	//	*Value_Message_
	//	*Value_BasicMessage
	//	*Value_Duration
	//	*Value_Timestamp
	//	*Value_Not
	//	*Value_AllOf
	//	*Value_AnyOf
	//	*Value_Seq
	//	*Value_Switch_
	//	*Value_While
	//	*Value_Break
	//	*Value_Continue
	//	*Value_Store
	//	*Value_Proc
	//	*Value_Load
	//	*Value_Program_
	//	*Value_Range_
	Value isValue_Value `protobuf_oneof:"value"`
	// contains filtered or unexported fields
}

type Value_AllOf struct {
	// all_of yields a boolean value, which is true if and only if all values
	// in the list (based on scope) are true.
	// The list is checked in order, and if a false value is encountered, the
	// remaining entries in the list are ignored.
	// It is an error if there are values which are not boolean.
	// If the list is empty, the result is true.
	AllOf *Value_ValueList `protobuf:"bytes,19,opt,name=all_of,json=allOf,proto3,oneof"`
}

type Value_AnyOf struct {
	// any_of yields a boolean value, and is true if and only if there is a
	// value in the list (based on scope) which is true.
	// The list is checked in order, and if a true value is encountered, the
	// remaining entries in the list are ignored.
	// It is an error if there are values which are not boolean.
	// If the list is empty, the result is false.
	AnyOf *Value_ValueList `protobuf:"bytes,20,opt,name=any_of,json=anyOf,proto3,oneof"`
}

type Value_Arg struct {
	// arg yields the numbered argument.
	Arg uint32 `protobuf:"varint,4,opt,name=arg,proto3,oneof"`
}

type Value_BasicMessage struct {
	// basic_message is an explicit message value. It uses the protobuf Any
	// mechanism. While this doesn't allow complex message generation, the
	// specification of the message itself in a configuration file will be
	// less cluttered.
	BasicMessage *anypb.Any `protobuf:"bytes,15,opt,name=basic_message,json=basicMessage,proto3,oneof"`
}

type Value_BasicValue struct {
	// value is an explicit basic value. A basic value is null, bool, double,
	// string, a list of basic values, or a map with string keys and basic
	// values. These are exactly the values which can be represented with JSON
	// without ancillary information (i. e., JSON numbers are all interpreted as
	// double; see the int and uint fields to create explicit integer values).
	BasicValue *structpb.Value `protobuf:"bytes,7,opt,name=basic_value,json=basicValue,proto3,oneof"`
}

type Value_Branch struct {

	// case must be a boolean value. If it is true, then will be evaluated.
	Case *Value `protobuf:"bytes,1,opt,name=case,proto3" json:"case,omitempty"`
	// then is the value of this Branch if case is true.
	Then *Value `protobuf:"bytes,2,opt,name=then,proto3" json:"then,omitempty"`
	// contains filtered or unexported fields
}

type Value_Break struct {
	// break breaks out of the given number of while evaluations.
	// while evaluations where break occurs in the conditional part do not
	// count.
	Break uint32 `protobuf:"varint,24,opt,name=break,proto3,oneof"`
}

type Value_Bytes struct {
	// bytes is an explicit bytes value.
	Bytes []byte `protobuf:"bytes,10,opt,name=bytes,proto3,oneof"`
}

type Value_Continue struct {
	// continue continues the given nth enclosing while evaluation.
	// while evaluations where continue occurs in the conditional
	// part do not count.
	Continue uint32 `protobuf:"varint,25,opt,name=continue,proto3,oneof"`
}

type Value_Default struct {
	// default is the default value for the scope.
	Default *emptypb.Empty `protobuf:"bytes,6,opt,name=default,proto3,oneof"`
}

type Value_Duration struct {
	// duration is an explicit duration.
	Duration *durationpb.Duration `protobuf:"bytes,16,opt,name=duration,proto3,oneof"`
}

type Value_Enum struct {

	// type is the full name of the enum type. Required.
	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	// by selects the enum value by its numeric value or by its name. Required.
	//
	// Types that are assignable to By:
	//	*Value_Enum_Number
	//	*Value_Enum_Name
	By isValue_Enum_By `protobuf_oneof:"by"`
	// contains filtered or unexported fields
}

type Value_Enum_ struct {
	// enum is an explicit enum value.
	Enum *Value_Enum `protobuf:"bytes,11,opt,name=enum,proto3,oneof"`
}

type Value_Enum_Name struct {
	// name is the name of the enum constant.
	Name string `protobuf:"bytes,3,opt,name=name,proto3,oneof"`
}

type Value_Enum_Number struct {
	// number is the numeric value of the enum constant.
	Number int32 `protobuf:"varint,2,opt,name=number,proto3,oneof"`
}

type Value_Int struct {
	// int is an explicit signed integer value.
	Int int64 `protobuf:"varint,8,opt,name=int,proto3,oneof"`
}

type Value_Kind int32

type Value_List struct {

	// kind is the kind of the value type of the list.
	Kind Value_Kind `protobuf:"varint,1,opt,name=kind,proto3,enum=com.github.thecount.protoeval.Value_Kind" json:"kind,omitempty"`
	// type is the full name of the value type of the list.
	Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	// values are the values in this List. Unless the list is a heterogeneous
	// CEL list, all values must have a type compatible with kind and type.
	Values []*Value `protobuf:"bytes,3,rep,name=values,proto3" json:"values,omitempty"`
	// contains filtered or unexported fields
}

type Value_List_ struct {
	// list is an explicit list value based on scope. For simple lists,
	// basic_value may be a better choice.
	List *Value_List `protobuf:"bytes,12,opt,name=list,proto3,oneof"`
}

type Value_Load struct {
	// load loads a value from the environment.
	// load should evaluate to a string, the key to be retrieved from the
	// enviroinment.
	// If no previous store under that key is present, the value is null.
	Load *Value `protobuf:"bytes,28,opt,name=load,proto3,oneof"`
}

type Value_Map struct {

	// key_kind is the kind of the key type of the map.
	// Must be a valid kind for a map key type.
	// Can be omitted, see above.
	KeyKind Value_Kind `` /* 129-byte string literal not displayed */
	// value_kind is the kind of the value type of the map.
	ValueKind Value_Kind `` /* 135-byte string literal not displayed */
	// value_type is the full name of the value type of the map.
	ValueType string `protobuf:"bytes,3,opt,name=value_type,json=valueType,proto3" json:"value_type,omitempty"`
	// entries is the list of map entries. The keys must be mutually distinct.
	// Keys and values must match the types determined by
	// key_kind/value_kind/value_type as described above.
	Entries []*Value_Map_Entry `protobuf:"bytes,4,rep,name=entries,proto3" json:"entries,omitempty"`
	// contains filtered or unexported fields
}

type Value_Map_ struct {
	// map is an explicit map value based on scope. For simple maps,
	// basic_value may be a better choice.
	Map *Value_Map `protobuf:"bytes,13,opt,name=map,proto3,oneof"`
}

type Value_Map_Entry struct {

	// key is the the of this entry. Required.
	Key *Value `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// value is the value of this entry. Required.
	Value *Value `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type Value_Message struct {

	// type is the full name of the message type. Required.
	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	// fields describes the message fields. The types of the values must match
	// the message field types.
	Fields map[string]*Value `` /* 153-byte string literal not displayed */
	// contains filtered or unexported fields
}

type Value_Message_ struct {
	// message is an explicit message value based on scope. For simple
	// messages, basic_message may be a better choice.
	Message *Value_Message `protobuf:"bytes,14,opt,name=message,proto3,oneof"`
}

type Value_Not struct {
	// not yields a boolean value which is the inverse of the specified value
	// based on scope. It is an error if the specified value is not boolean.
	Not *Value `protobuf:"bytes,18,opt,name=not,proto3,oneof"`
}

type Value_Parent struct {
	// parent is a value based on the parent scope. It can be used to backtrack
	// from the current scope.
	Parent *Value `protobuf:"bytes,5,opt,name=parent,proto3,oneof"`
}

type Value_Proc struct {
	// proc stores the value in the environment.
	// Only when loaded, the value will be evaluated with the then valid
	// environment and scope.
	Proc *Value_StoredValue `protobuf:"bytes,27,opt,name=proc,proto3,oneof"`
}

type Value_Program struct {

	// code is the program code, unless lines is used.
	// If lines is used, code must be empty.
	Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
	// lines are the lines of code. The program code is derived from the lines
	// by concatenating them with newline characters between them. This is
	// a convenience feature for protobuf representations which don't have
	// easily human readable multiline strings (namely JSON).
	// If code is used, lines must be empty.
	Lines []string `protobuf:"bytes,2,rep,name=lines,proto3" json:"lines,omitempty"`
	// contains filtered or unexported fields
}

type Value_Program_ struct {
	// program is a user defined program to determine the value.
	Program *Value_Program `protobuf:"bytes,29,opt,name=program,proto3,oneof"`
}

type Value_Range struct {

	// iterable is the iterable value ranged over. If omitted, the scope value
	// is used instead. It is an error if this value is not an aggregate.
	Iterable *Value `protobuf:"bytes,1,opt,name=iterable,proto3" json:"iterable,omitempty"`
	// value is evaluated for each element in the iterable value ranged over.
	//
	// Two arguments will be added before each evaluation, and
	// removed after each evaluation: for a list, the 0-th argument is the zero
	// based list index, the 1st argument is the list value. For a map, the 0-th
	// argument is the map key, and the 1st argument is the map value.
	//
	// A list will be evaluated in order. The evaluation order for a map is
	// unspecified.
	//
	// If an evaluation yields a value other than null, evaluation
	// stops early and the range yields that value. Otherwise, the range
	// yields null.
	Value *Value `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type Value_Range_ struct {
	// range ranges over an aggregate value. See the Range documentation for
	// which value this yields.
	Range *Value_Range `protobuf:"bytes,30,opt,name=range,proto3,oneof"`
}

type Value_Seq struct {
	// seq yields the value of last evaluated element in the list (based on
	// scope). This is normally the final element, but occurrences of break
	// or continue may cut the evaluation short. If no elements are evaluated,
	// seq yields null.
	Seq *Value_ValueList `protobuf:"bytes,21,opt,name=seq,proto3,oneof"`
}

type Value_Store struct {
	// store stores the evaluated value in the environment.
	// The completely evaluated value can be retrieved again with load.
	Store *Value_StoredValue `protobuf:"bytes,26,opt,name=store,proto3,oneof"`
}

type Value_StoredValue struct {

	// key is the storage key. It must evaluate to a string.
	Key *Value `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// value is the value stored under key.
	Value *Value `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type Value_Switch struct {

	// cases is the list of cases. The list will be evaluated in order. The
	// first case which matches determines the then value of this Switch.
	// If no case matches, the default value is returned.
	Cases []*Value_Branch `protobuf:"bytes,1,rep,name=cases,proto3" json:"cases,omitempty"`
	// default is the value returned if none of the cases matches.
	// If default is omitted, the value will be null in this case.
	Default *Value `protobuf:"bytes,2,opt,name=default,proto3" json:"default,omitempty"`
	// contains filtered or unexported fields
}

type Value_Switch_ struct {
	// switch yields a value (based on scope) based on conditions.
	Switch *Value_Switch `protobuf:"bytes,22,opt,name=switch,proto3,oneof"`
}

type Value_Timestamp struct {
	// timestamp is an explicit timestamp.
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,17,opt,name=timestamp,proto3,oneof"`
}

type Value_Uint struct {
	// uint is an explicit unsigned integer value.
	Uint uint64 `protobuf:"varint,9,opt,name=uint,proto3,oneof"`
}

type Value_ValueList struct {

	// values is the list of values.
	Values []*Value `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	// contains filtered or unexported fields
}

type Value_While struct {
	// while repeatedly evaluates the then part of the branch for as long
	// as the case yields true. The final value from then is returned.
	// If then is never evaluated, null is returned.
	While *Value_Branch `protobuf:"bytes,23,opt,name=while,proto3,oneof"`
}