@0xkaleab/sdk-js 0.2.7

package/dist/esm/codegen/google/api/expr/v1beta1/expr.js

@@ -0,0 +1,1228 @@
+// @ts-nocheck
+/* eslint-disable */
+import { SourceInfo } from "./source";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { GlobalDecoderRegistry } from "../../../../registry";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+function createBaseParsedExpr() {
+    return {
+        expr: undefined,
+        sourceInfo: undefined,
+        syntaxVersion: ""
+    };
+}
+/**
+ * An expression together with source information as returned by the parser.
+ * @name ParsedExpr
+ * @package google.api.expr.v1beta1
+ * @see proto type: google.api.expr.v1beta1.ParsedExpr
+ */
+export const ParsedExpr = {
+    typeUrl: "/google.api.expr.v1beta1.ParsedExpr",
+    is(o) {
+        return o && (o.$typeUrl === ParsedExpr.typeUrl || typeof o.syntaxVersion === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === ParsedExpr.typeUrl || typeof o.syntax_version === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.expr !== undefined) {
+            Expr.encode(message.expr, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.sourceInfo !== undefined) {
+            SourceInfo.encode(message.sourceInfo, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.syntaxVersion !== "") {
+            writer.uint32(34).string(message.syntaxVersion);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseParsedExpr();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2:
+                    message.expr = Expr.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.sourceInfo = SourceInfo.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.syntaxVersion = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseParsedExpr();
+        message.expr = object.expr !== undefined && object.expr !== null ? Expr.fromPartial(object.expr) : undefined;
+        message.sourceInfo = object.sourceInfo !== undefined && object.sourceInfo !== null ? SourceInfo.fromPartial(object.sourceInfo) : undefined;
+        message.syntaxVersion = object.syntaxVersion ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseParsedExpr();
+        if (object.expr !== undefined && object.expr !== null) {
+            message.expr = Expr.fromAmino(object.expr);
+        }
+        if (object.source_info !== undefined && object.source_info !== null) {
+            message.sourceInfo = SourceInfo.fromAmino(object.source_info);
+        }
+        if (object.syntax_version !== undefined && object.syntax_version !== null) {
+            message.syntaxVersion = object.syntax_version;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.expr = message.expr ? Expr.toAmino(message.expr) : undefined;
+        obj.source_info = message.sourceInfo ? SourceInfo.toAmino(message.sourceInfo) : undefined;
+        obj.syntax_version = message.syntaxVersion === "" ? undefined : message.syntaxVersion;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ParsedExpr.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ParsedExpr.decode(message.value);
+    },
+    toProto(message) {
+        return ParsedExpr.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1beta1.ParsedExpr",
+            value: ParsedExpr.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(ParsedExpr.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+        SourceInfo.registerTypeUrl();
+    }
+};
+function createBaseExpr() {
+    return {
+        id: 0,
+        literalExpr: undefined,
+        identExpr: undefined,
+        selectExpr: undefined,
+        callExpr: undefined,
+        listExpr: undefined,
+        structExpr: undefined,
+        comprehensionExpr: undefined
+    };
+}
+/**
+ * An abstract representation of a common expression.
+ *
+ * Expressions are abstractly represented as a collection of identifiers,
+ * select statements, function calls, literals, and comprehensions. All
+ * operators with the exception of the '.' operator are modelled as function
+ * calls. This makes it easy to represent new operators into the existing AST.
+ *
+ * All references within expressions must resolve to a [Decl][google.api.expr.v1beta1.Decl] provided at
+ * type-check for an expression to be valid. A reference may either be a bare
+ * identifier `name` or a qualified identifier `google.api.name`. References
+ * may either refer to a value or a function declaration.
+ *
+ * For example, the expression `google.api.name.startsWith('expr')` references
+ * the declaration `google.api.name` within a [Expr.Select][google.api.expr.v1beta1.Expr.Select] expression, and
+ * the function declaration `startsWith`.
+ * @name Expr
+ * @package google.api.expr.v1beta1
+ * @see proto type: google.api.expr.v1beta1.Expr
+ */
+export const Expr = {
+    typeUrl: "/google.api.expr.v1beta1.Expr",
+    is(o) {
+        return o && (o.$typeUrl === Expr.typeUrl || typeof o.id === "number");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Expr.typeUrl || typeof o.id === "number");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== 0) {
+            writer.uint32(16).int32(message.id);
+        }
+        if (message.literalExpr !== undefined) {
+            Literal.encode(message.literalExpr, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.identExpr !== undefined) {
+            Expr_Ident.encode(message.identExpr, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.selectExpr !== undefined) {
+            Expr_Select.encode(message.selectExpr, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.callExpr !== undefined) {
+            Expr_Call.encode(message.callExpr, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.listExpr !== undefined) {
+            Expr_CreateList.encode(message.listExpr, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.structExpr !== undefined) {
+            Expr_CreateStruct.encode(message.structExpr, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.comprehensionExpr !== undefined) {
+            Expr_Comprehension.encode(message.comprehensionExpr, writer.uint32(74).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseExpr();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2:
+                    message.id = reader.int32();
+                    break;
+                case 3:
+                    message.literalExpr = Literal.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.identExpr = Expr_Ident.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.selectExpr = Expr_Select.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.callExpr = Expr_Call.decode(reader, reader.uint32());
+                    break;
+                case 7:
+                    message.listExpr = Expr_CreateList.decode(reader, reader.uint32());
+                    break;
+                case 8:
+                    message.structExpr = Expr_CreateStruct.decode(reader, reader.uint32());
+                    break;
+                case 9:
+                    message.comprehensionExpr = Expr_Comprehension.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseExpr();
+        message.id = object.id ?? 0;
+        message.literalExpr = object.literalExpr !== undefined && object.literalExpr !== null ? Literal.fromPartial(object.literalExpr) : undefined;
+        message.identExpr = object.identExpr !== undefined && object.identExpr !== null ? Expr_Ident.fromPartial(object.identExpr) : undefined;
+        message.selectExpr = object.selectExpr !== undefined && object.selectExpr !== null ? Expr_Select.fromPartial(object.selectExpr) : undefined;
+        message.callExpr = object.callExpr !== undefined && object.callExpr !== null ? Expr_Call.fromPartial(object.callExpr) : undefined;
+        message.listExpr = object.listExpr !== undefined && object.listExpr !== null ? Expr_CreateList.fromPartial(object.listExpr) : undefined;
+        message.structExpr = object.structExpr !== undefined && object.structExpr !== null ? Expr_CreateStruct.fromPartial(object.structExpr) : undefined;
+        message.comprehensionExpr = object.comprehensionExpr !== undefined && object.comprehensionExpr !== null ? Expr_Comprehension.fromPartial(object.comprehensionExpr) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseExpr();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = object.id;
+        }
+        if (object.literal_expr !== undefined && object.literal_expr !== null) {
+            message.literalExpr = Literal.fromAmino(object.literal_expr);
+        }
+        if (object.ident_expr !== undefined && object.ident_expr !== null) {
+            message.identExpr = Expr_Ident.fromAmino(object.ident_expr);
+        }
+        if (object.select_expr !== undefined && object.select_expr !== null) {
+            message.selectExpr = Expr_Select.fromAmino(object.select_expr);
+        }
+        if (object.call_expr !== undefined && object.call_expr !== null) {
+            message.callExpr = Expr_Call.fromAmino(object.call_expr);
+        }
+        if (object.list_expr !== undefined && object.list_expr !== null) {
+            message.listExpr = Expr_CreateList.fromAmino(object.list_expr);
+        }
+        if (object.struct_expr !== undefined && object.struct_expr !== null) {
+            message.structExpr = Expr_CreateStruct.fromAmino(object.struct_expr);
+        }
+        if (object.comprehension_expr !== undefined && object.comprehension_expr !== null) {
+            message.comprehensionExpr = Expr_Comprehension.fromAmino(object.comprehension_expr);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id === 0 ? undefined : message.id;
+        obj.literal_expr = message.literalExpr ? Literal.toAmino(message.literalExpr) : undefined;
+        obj.ident_expr = message.identExpr ? Expr_Ident.toAmino(message.identExpr) : undefined;
+        obj.select_expr = message.selectExpr ? Expr_Select.toAmino(message.selectExpr) : undefined;
+        obj.call_expr = message.callExpr ? Expr_Call.toAmino(message.callExpr) : undefined;
+        obj.list_expr = message.listExpr ? Expr_CreateList.toAmino(message.listExpr) : undefined;
+        obj.struct_expr = message.structExpr ? Expr_CreateStruct.toAmino(message.structExpr) : undefined;
+        obj.comprehension_expr = message.comprehensionExpr ? Expr_Comprehension.toAmino(message.comprehensionExpr) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Expr.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Expr.decode(message.value);
+    },
+    toProto(message) {
+        return Expr.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1beta1.Expr",
+            value: Expr.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Expr.typeUrl)) {
+            return;
+        }
+        Literal.registerTypeUrl();
+        Expr_Ident.registerTypeUrl();
+        Expr_Select.registerTypeUrl();
+        Expr_Call.registerTypeUrl();
+        Expr_CreateList.registerTypeUrl();
+        Expr_CreateStruct.registerTypeUrl();
+        Expr_Comprehension.registerTypeUrl();
+    }
+};
+function createBaseExpr_Ident() {
+    return {
+        name: ""
+    };
+}
+/**
+ * An identifier expression. e.g. `request`.
+ * @name Expr_Ident
+ * @package google.api.expr.v1beta1
+ * @see proto type: google.api.expr.v1beta1.Ident
+ */
+export const Expr_Ident = {
+    typeUrl: "/google.api.expr.v1beta1.Ident",
+    is(o) {
+        return o && (o.$typeUrl === Expr_Ident.typeUrl || typeof o.name === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Expr_Ident.typeUrl || typeof o.name === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseExpr_Ident();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseExpr_Ident();
+        message.name = object.name ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseExpr_Ident();
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name === "" ? undefined : message.name;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Expr_Ident.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Expr_Ident.decode(message.value);
+    },
+    toProto(message) {
+        return Expr_Ident.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1beta1.Ident",
+            value: Expr_Ident.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseExpr_Select() {
+    return {
+        operand: undefined,
+        field: "",
+        testOnly: false
+    };
+}
+/**
+ * A field selection expression. e.g. `request.auth`.
+ * @name Expr_Select
+ * @package google.api.expr.v1beta1
+ * @see proto type: google.api.expr.v1beta1.Select
+ */
+export const Expr_Select = {
+    typeUrl: "/google.api.expr.v1beta1.Select",
+    is(o) {
+        return o && (o.$typeUrl === Expr_Select.typeUrl || typeof o.field === "string" && typeof o.testOnly === "boolean");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Expr_Select.typeUrl || typeof o.field === "string" && typeof o.test_only === "boolean");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.operand !== undefined) {
+            Expr.encode(message.operand, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.field !== "") {
+            writer.uint32(18).string(message.field);
+        }
+        if (message.testOnly === true) {
+            writer.uint32(24).bool(message.testOnly);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseExpr_Select();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.operand = Expr.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.field = reader.string();
+                    break;
+                case 3:
+                    message.testOnly = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseExpr_Select();
+        message.operand = object.operand !== undefined && object.operand !== null ? Expr.fromPartial(object.operand) : undefined;
+        message.field = object.field ?? "";
+        message.testOnly = object.testOnly ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseExpr_Select();
+        if (object.operand !== undefined && object.operand !== null) {
+            message.operand = Expr.fromAmino(object.operand);
+        }
+        if (object.field !== undefined && object.field !== null) {
+            message.field = object.field;
+        }
+        if (object.test_only !== undefined && object.test_only !== null) {
+            message.testOnly = object.test_only;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.operand = message.operand ? Expr.toAmino(message.operand) : undefined;
+        obj.field = message.field === "" ? undefined : message.field;
+        obj.test_only = message.testOnly === false ? undefined : message.testOnly;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Expr_Select.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Expr_Select.decode(message.value);
+    },
+    toProto(message) {
+        return Expr_Select.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1beta1.Select",
+            value: Expr_Select.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Expr_Select.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+    }
+};
+function createBaseExpr_Call() {
+    return {
+        target: undefined,
+        function: "",
+        args: []
+    };
+}
+/**
+ * A call expression, including calls to predefined functions and operators.
+ *
+ * For example, `value == 10`, `size(map_value)`.
+ * @name Expr_Call
+ * @package google.api.expr.v1beta1
+ * @see proto type: google.api.expr.v1beta1.Call
+ */
+export const Expr_Call = {
+    typeUrl: "/google.api.expr.v1beta1.Call",
+    is(o) {
+        return o && (o.$typeUrl === Expr_Call.typeUrl || typeof o.function === "string" && Array.isArray(o.args) && (!o.args.length || Expr.is(o.args[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Expr_Call.typeUrl || typeof o.function === "string" && Array.isArray(o.args) && (!o.args.length || Expr.isAmino(o.args[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.target !== undefined) {
+            Expr.encode(message.target, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.function !== "") {
+            writer.uint32(18).string(message.function);
+        }
+        for (const v of message.args) {
+            Expr.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseExpr_Call();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.target = Expr.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.function = reader.string();
+                    break;
+                case 3:
+                    message.args.push(Expr.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseExpr_Call();
+        message.target = object.target !== undefined && object.target !== null ? Expr.fromPartial(object.target) : undefined;
+        message.function = object.function ?? "";
+        message.args = object.args?.map(e => Expr.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseExpr_Call();
+        if (object.target !== undefined && object.target !== null) {
+            message.target = Expr.fromAmino(object.target);
+        }
+        if (object.function !== undefined && object.function !== null) {
+            message.function = object.function;
+        }
+        message.args = object.args?.map(e => Expr.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.target = message.target ? Expr.toAmino(message.target) : undefined;
+        obj.function = message.function === "" ? undefined : message.function;
+        if (message.args) {
+            obj.args = message.args.map(e => e ? Expr.toAmino(e) : undefined);
+        }
+        else {
+            obj.args = message.args;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Expr_Call.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Expr_Call.decode(message.value);
+    },
+    toProto(message) {
+        return Expr_Call.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1beta1.Call",
+            value: Expr_Call.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Expr_Call.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+    }
+};
+function createBaseExpr_CreateList() {
+    return {
+        elements: []
+    };
+}
+/**
+ * A list creation expression.
+ *
+ * Lists may either be homogenous, e.g. `[1, 2, 3]`, or heterogenous, e.g.
+ * `dyn([1, 'hello', 2.0])`
+ * @name Expr_CreateList
+ * @package google.api.expr.v1beta1
+ * @see proto type: google.api.expr.v1beta1.CreateList
+ */
+export const Expr_CreateList = {
+    typeUrl: "/google.api.expr.v1beta1.CreateList",
+    is(o) {
+        return o && (o.$typeUrl === Expr_CreateList.typeUrl || Array.isArray(o.elements) && (!o.elements.length || Expr.is(o.elements[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Expr_CreateList.typeUrl || Array.isArray(o.elements) && (!o.elements.length || Expr.isAmino(o.elements[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.elements) {
+            Expr.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseExpr_CreateList();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.elements.push(Expr.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseExpr_CreateList();
+        message.elements = object.elements?.map(e => Expr.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseExpr_CreateList();
+        message.elements = object.elements?.map(e => Expr.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.elements) {
+            obj.elements = message.elements.map(e => e ? Expr.toAmino(e) : undefined);
+        }
+        else {
+            obj.elements = message.elements;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Expr_CreateList.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Expr_CreateList.decode(message.value);
+    },
+    toProto(message) {
+        return Expr_CreateList.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1beta1.CreateList",
+            value: Expr_CreateList.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Expr_CreateList.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+    }
+};
+function createBaseExpr_CreateStruct() {
+    return {
+        type: "",
+        entries: []
+    };
+}
+/**
+ * A map or message creation expression.
+ *
+ * Maps are constructed as `{'key_name': 'value'}`. Message construction is
+ * similar, but prefixed with a type name and composed of field ids:
+ * `types.MyType{field_id: 'value'}`.
+ * @name Expr_CreateStruct
+ * @package google.api.expr.v1beta1
+ * @see proto type: google.api.expr.v1beta1.CreateStruct
+ */
+export const Expr_CreateStruct = {
+    typeUrl: "/google.api.expr.v1beta1.CreateStruct",
+    is(o) {
+        return o && (o.$typeUrl === Expr_CreateStruct.typeUrl || typeof o.type === "string" && Array.isArray(o.entries) && (!o.entries.length || Expr_CreateStruct_Entry.is(o.entries[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Expr_CreateStruct.typeUrl || typeof o.type === "string" && Array.isArray(o.entries) && (!o.entries.length || Expr_CreateStruct_Entry.isAmino(o.entries[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.type !== "") {
+            writer.uint32(10).string(message.type);
+        }
+        for (const v of message.entries) {
+            Expr_CreateStruct_Entry.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseExpr_CreateStruct();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.type = reader.string();
+                    break;
+                case 2:
+                    message.entries.push(Expr_CreateStruct_Entry.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseExpr_CreateStruct();
+        message.type = object.type ?? "";
+        message.entries = object.entries?.map(e => Expr_CreateStruct_Entry.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseExpr_CreateStruct();
+        if (object.type !== undefined && object.type !== null) {
+            message.type = object.type;
+        }
+        message.entries = object.entries?.map(e => Expr_CreateStruct_Entry.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.type = message.type === "" ? undefined : message.type;
+        if (message.entries) {
+            obj.entries = message.entries.map(e => e ? Expr_CreateStruct_Entry.toAmino(e) : undefined);
+        }
+        else {
+            obj.entries = message.entries;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Expr_CreateStruct.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Expr_CreateStruct.decode(message.value);
+    },
+    toProto(message) {
+        return Expr_CreateStruct.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1beta1.CreateStruct",
+            value: Expr_CreateStruct.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Expr_CreateStruct.typeUrl)) {
+            return;
+        }
+        Expr_CreateStruct_Entry.registerTypeUrl();
+    }
+};
+function createBaseExpr_CreateStruct_Entry() {
+    return {
+        id: 0,
+        fieldKey: undefined,
+        mapKey: undefined,
+        value: undefined
+    };
+}
+/**
+ * Represents an entry.
+ * @name Expr_CreateStruct_Entry
+ * @package google.api.expr.v1beta1
+ * @see proto type: google.api.expr.v1beta1.Entry
+ */
+export const Expr_CreateStruct_Entry = {
+    typeUrl: "/google.api.expr.v1beta1.Entry",
+    is(o) {
+        return o && (o.$typeUrl === Expr_CreateStruct_Entry.typeUrl || typeof o.id === "number");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Expr_CreateStruct_Entry.typeUrl || typeof o.id === "number");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== 0) {
+            writer.uint32(8).int32(message.id);
+        }
+        if (message.fieldKey !== undefined) {
+            writer.uint32(18).string(message.fieldKey);
+        }
+        if (message.mapKey !== undefined) {
+            Expr.encode(message.mapKey, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.value !== undefined) {
+            Expr.encode(message.value, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseExpr_CreateStruct_Entry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.int32();
+                    break;
+                case 2:
+                    message.fieldKey = reader.string();
+                    break;
+                case 3:
+                    message.mapKey = Expr.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.value = Expr.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseExpr_CreateStruct_Entry();
+        message.id = object.id ?? 0;
+        message.fieldKey = object.fieldKey ?? undefined;
+        message.mapKey = object.mapKey !== undefined && object.mapKey !== null ? Expr.fromPartial(object.mapKey) : undefined;
+        message.value = object.value !== undefined && object.value !== null ? Expr.fromPartial(object.value) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseExpr_CreateStruct_Entry();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = object.id;
+        }
+        if (object.field_key !== undefined && object.field_key !== null) {
+            message.fieldKey = object.field_key;
+        }
+        if (object.map_key !== undefined && object.map_key !== null) {
+            message.mapKey = Expr.fromAmino(object.map_key);
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = Expr.fromAmino(object.value);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id === 0 ? undefined : message.id;
+        obj.field_key = message.fieldKey === null ? undefined : message.fieldKey;
+        obj.map_key = message.mapKey ? Expr.toAmino(message.mapKey) : undefined;
+        obj.value = message.value ? Expr.toAmino(message.value) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Expr_CreateStruct_Entry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Expr_CreateStruct_Entry.decode(message.value);
+    },
+    toProto(message) {
+        return Expr_CreateStruct_Entry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1beta1.Entry",
+            value: Expr_CreateStruct_Entry.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Expr_CreateStruct_Entry.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+    }
+};
+function createBaseExpr_Comprehension() {
+    return {
+        iterVar: "",
+        iterRange: undefined,
+        accuVar: "",
+        accuInit: undefined,
+        loopCondition: undefined,
+        loopStep: undefined,
+        result: undefined
+    };
+}
+/**
+ * A comprehension expression applied to a list or map.
+ *
+ * Comprehensions are not part of the core syntax, but enabled with macros.
+ * A macro matches a specific call signature within a parsed AST and replaces
+ * the call with an alternate AST block. Macro expansion happens at parse
+ * time.
+ *
+ * The following macros are supported within CEL:
+ *
+ * Aggregate type macros may be applied to all elements in a list or all keys
+ * in a map:
+ *
+ * *  `all`, `exists`, `exists_one` -  test a predicate expression against
+ *    the inputs and return `true` if the predicate is satisfied for all,
+ *    any, or only one value `list.all(x, x < 10)`.
+ * *  `filter` - test a predicate expression against the inputs and return
+ *    the subset of elements which satisfy the predicate:
+ *    `payments.filter(p, p > 1000)`.
+ * *  `map` - apply an expression to all elements in the input and return the
+ *    output aggregate type: `[1, 2, 3].map(i, i * i)`.
+ *
+ * The `has(m.x)` macro tests whether the property `x` is present in struct
+ * `m`. The semantics of this macro depend on the type of `m`. For proto2
+ * messages `has(m.x)` is defined as 'defined, but not set`. For proto3, the
+ * macro tests whether the property is set to its default. For map and struct
+ * types, the macro tests whether the property `x` is defined on `m`.
+ * @name Expr_Comprehension
+ * @package google.api.expr.v1beta1
+ * @see proto type: google.api.expr.v1beta1.Comprehension
+ */
+export const Expr_Comprehension = {
+    typeUrl: "/google.api.expr.v1beta1.Comprehension",
+    is(o) {
+        return o && (o.$typeUrl === Expr_Comprehension.typeUrl || typeof o.iterVar === "string" && typeof o.accuVar === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Expr_Comprehension.typeUrl || typeof o.iter_var === "string" && typeof o.accu_var === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.iterVar !== "") {
+            writer.uint32(10).string(message.iterVar);
+        }
+        if (message.iterRange !== undefined) {
+            Expr.encode(message.iterRange, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.accuVar !== "") {
+            writer.uint32(26).string(message.accuVar);
+        }
+        if (message.accuInit !== undefined) {
+            Expr.encode(message.accuInit, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.loopCondition !== undefined) {
+            Expr.encode(message.loopCondition, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.loopStep !== undefined) {
+            Expr.encode(message.loopStep, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.result !== undefined) {
+            Expr.encode(message.result, writer.uint32(58).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseExpr_Comprehension();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.iterVar = reader.string();
+                    break;
+                case 2:
+                    message.iterRange = Expr.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.accuVar = reader.string();
+                    break;
+                case 4:
+                    message.accuInit = Expr.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.loopCondition = Expr.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.loopStep = Expr.decode(reader, reader.uint32());
+                    break;
+                case 7:
+                    message.result = Expr.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseExpr_Comprehension();
+        message.iterVar = object.iterVar ?? "";
+        message.iterRange = object.iterRange !== undefined && object.iterRange !== null ? Expr.fromPartial(object.iterRange) : undefined;
+        message.accuVar = object.accuVar ?? "";
+        message.accuInit = object.accuInit !== undefined && object.accuInit !== null ? Expr.fromPartial(object.accuInit) : undefined;
+        message.loopCondition = object.loopCondition !== undefined && object.loopCondition !== null ? Expr.fromPartial(object.loopCondition) : undefined;
+        message.loopStep = object.loopStep !== undefined && object.loopStep !== null ? Expr.fromPartial(object.loopStep) : undefined;
+        message.result = object.result !== undefined && object.result !== null ? Expr.fromPartial(object.result) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseExpr_Comprehension();
+        if (object.iter_var !== undefined && object.iter_var !== null) {
+            message.iterVar = object.iter_var;
+        }
+        if (object.iter_range !== undefined && object.iter_range !== null) {
+            message.iterRange = Expr.fromAmino(object.iter_range);
+        }
+        if (object.accu_var !== undefined && object.accu_var !== null) {
+            message.accuVar = object.accu_var;
+        }
+        if (object.accu_init !== undefined && object.accu_init !== null) {
+            message.accuInit = Expr.fromAmino(object.accu_init);
+        }
+        if (object.loop_condition !== undefined && object.loop_condition !== null) {
+            message.loopCondition = Expr.fromAmino(object.loop_condition);
+        }
+        if (object.loop_step !== undefined && object.loop_step !== null) {
+            message.loopStep = Expr.fromAmino(object.loop_step);
+        }
+        if (object.result !== undefined && object.result !== null) {
+            message.result = Expr.fromAmino(object.result);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.iter_var = message.iterVar === "" ? undefined : message.iterVar;
+        obj.iter_range = message.iterRange ? Expr.toAmino(message.iterRange) : undefined;
+        obj.accu_var = message.accuVar === "" ? undefined : message.accuVar;
+        obj.accu_init = message.accuInit ? Expr.toAmino(message.accuInit) : undefined;
+        obj.loop_condition = message.loopCondition ? Expr.toAmino(message.loopCondition) : undefined;
+        obj.loop_step = message.loopStep ? Expr.toAmino(message.loopStep) : undefined;
+        obj.result = message.result ? Expr.toAmino(message.result) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Expr_Comprehension.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Expr_Comprehension.decode(message.value);
+    },
+    toProto(message) {
+        return Expr_Comprehension.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1beta1.Comprehension",
+            value: Expr_Comprehension.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Expr_Comprehension.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+    }
+};
+function createBaseLiteral() {
+    return {
+        nullValue: undefined,
+        boolValue: undefined,
+        int64Value: undefined,
+        uint64Value: undefined,
+        doubleValue: undefined,
+        stringValue: undefined,
+        bytesValue: undefined
+    };
+}
+/**
+ * Represents a primitive literal.
+ *
+ * This is similar to the primitives supported in the well-known type
+ * `google.protobuf.Value`, but richer so it can represent CEL's full range of
+ * primitives.
+ *
+ * Lists and structs are not included as constants as these aggregate types may
+ * contain [Expr][google.api.expr.v1beta1.Expr] elements which require evaluation and are thus not constant.
+ *
+ * Examples of literals include: `"hello"`, `b'bytes'`, `1u`, `4.2`, `-2`,
+ * `true`, `null`.
+ * @name Literal
+ * @package google.api.expr.v1beta1
+ * @see proto type: google.api.expr.v1beta1.Literal
+ */
+export const Literal = {
+    typeUrl: "/google.api.expr.v1beta1.Literal",
+    is(o) {
+        return o && o.$typeUrl === Literal.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === Literal.typeUrl;
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.nullValue !== undefined) {
+            writer.uint32(8).int32(message.nullValue);
+        }
+        if (message.boolValue !== undefined) {
+            writer.uint32(16).bool(message.boolValue);
+        }
+        if (message.int64Value !== undefined) {
+            writer.uint32(24).int64(message.int64Value);
+        }
+        if (message.uint64Value !== undefined) {
+            writer.uint32(32).uint64(message.uint64Value);
+        }
+        if (message.doubleValue !== undefined) {
+            writer.uint32(41).double(message.doubleValue);
+        }
+        if (message.stringValue !== undefined) {
+            writer.uint32(50).string(message.stringValue);
+        }
+        if (message.bytesValue !== undefined) {
+            writer.uint32(58).bytes(message.bytesValue);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseLiteral();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.nullValue = reader.int32();
+                    break;
+                case 2:
+                    message.boolValue = reader.bool();
+                    break;
+                case 3:
+                    message.int64Value = reader.int64();
+                    break;
+                case 4:
+                    message.uint64Value = reader.uint64();
+                    break;
+                case 5:
+                    message.doubleValue = reader.double();
+                    break;
+                case 6:
+                    message.stringValue = reader.string();
+                    break;
+                case 7:
+                    message.bytesValue = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseLiteral();
+        message.nullValue = object.nullValue ?? undefined;
+        message.boolValue = object.boolValue ?? undefined;
+        message.int64Value = object.int64Value !== undefined && object.int64Value !== null ? BigInt(object.int64Value.toString()) : undefined;
+        message.uint64Value = object.uint64Value !== undefined && object.uint64Value !== null ? BigInt(object.uint64Value.toString()) : undefined;
+        message.doubleValue = object.doubleValue ?? undefined;
+        message.stringValue = object.stringValue ?? undefined;
+        message.bytesValue = object.bytesValue ?? undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseLiteral();
+        if (object.null_value !== undefined && object.null_value !== null) {
+            message.nullValue = object.null_value;
+        }
+        if (object.bool_value !== undefined && object.bool_value !== null) {
+            message.boolValue = object.bool_value;
+        }
+        if (object.int64_value !== undefined && object.int64_value !== null) {
+            message.int64Value = BigInt(object.int64_value);
+        }
+        if (object.uint64_value !== undefined && object.uint64_value !== null) {
+            message.uint64Value = BigInt(object.uint64_value);
+        }
+        if (object.double_value !== undefined && object.double_value !== null) {
+            message.doubleValue = object.double_value;
+        }
+        if (object.string_value !== undefined && object.string_value !== null) {
+            message.stringValue = object.string_value;
+        }
+        if (object.bytes_value !== undefined && object.bytes_value !== null) {
+            message.bytesValue = bytesFromBase64(object.bytes_value);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.null_value = message.nullValue === null ? undefined : message.nullValue;
+        obj.bool_value = message.boolValue === null ? undefined : message.boolValue;
+        obj.int64_value = message.int64Value !== BigInt(0) ? message.int64Value?.toString() : undefined;
+        obj.uint64_value = message.uint64Value !== BigInt(0) ? message.uint64Value?.toString() : undefined;
+        obj.double_value = message.doubleValue === null ? undefined : message.doubleValue;
+        obj.string_value = message.stringValue === null ? undefined : message.stringValue;
+        obj.bytes_value = message.bytesValue ? base64FromBytes(message.bytesValue) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Literal.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Literal.decode(message.value);
+    },
+    toProto(message) {
+        return Literal.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1beta1.Literal",
+            value: Literal.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};