@0xkaleab/sdk-js 0.2.7

package/dist/esm/codegen/google/api/expr/v1alpha1/syntax.js

@@ -0,0 +1,2042 @@
+import { Duration } from "../../../protobuf/duration";
+import { Timestamp } from "../../../protobuf/timestamp";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { GlobalDecoderRegistry } from "../../../../registry";
+import { toTimestamp, fromTimestamp, bytesFromBase64, base64FromBytes, isSet } from "../../../../helpers";
+/** CEL component specifier. */
+export var SourceInfo_Extension_Component;
+(function (SourceInfo_Extension_Component) {
+    /** COMPONENT_UNSPECIFIED - Unspecified, default. */
+    SourceInfo_Extension_Component[SourceInfo_Extension_Component["COMPONENT_UNSPECIFIED"] = 0] = "COMPONENT_UNSPECIFIED";
+    /** COMPONENT_PARSER - Parser. Converts a CEL string to an AST. */
+    SourceInfo_Extension_Component[SourceInfo_Extension_Component["COMPONENT_PARSER"] = 1] = "COMPONENT_PARSER";
+    /**
+     * COMPONENT_TYPE_CHECKER - Type checker. Checks that references in an AST are defined and types
+     * agree.
+     */
+    SourceInfo_Extension_Component[SourceInfo_Extension_Component["COMPONENT_TYPE_CHECKER"] = 2] = "COMPONENT_TYPE_CHECKER";
+    /**
+     * COMPONENT_RUNTIME - Runtime. Evaluates a parsed and optionally checked CEL AST against a
+     * context.
+     */
+    SourceInfo_Extension_Component[SourceInfo_Extension_Component["COMPONENT_RUNTIME"] = 3] = "COMPONENT_RUNTIME";
+    SourceInfo_Extension_Component[SourceInfo_Extension_Component["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(SourceInfo_Extension_Component || (SourceInfo_Extension_Component = {}));
+export const SourceInfo_Extension_ComponentAmino = SourceInfo_Extension_Component;
+export function sourceInfo_Extension_ComponentFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "COMPONENT_UNSPECIFIED":
+            return SourceInfo_Extension_Component.COMPONENT_UNSPECIFIED;
+        case 1:
+        case "COMPONENT_PARSER":
+            return SourceInfo_Extension_Component.COMPONENT_PARSER;
+        case 2:
+        case "COMPONENT_TYPE_CHECKER":
+            return SourceInfo_Extension_Component.COMPONENT_TYPE_CHECKER;
+        case 3:
+        case "COMPONENT_RUNTIME":
+            return SourceInfo_Extension_Component.COMPONENT_RUNTIME;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return SourceInfo_Extension_Component.UNRECOGNIZED;
+    }
+}
+export function sourceInfo_Extension_ComponentToJSON(object) {
+    switch (object) {
+        case SourceInfo_Extension_Component.COMPONENT_UNSPECIFIED:
+            return "COMPONENT_UNSPECIFIED";
+        case SourceInfo_Extension_Component.COMPONENT_PARSER:
+            return "COMPONENT_PARSER";
+        case SourceInfo_Extension_Component.COMPONENT_TYPE_CHECKER:
+            return "COMPONENT_TYPE_CHECKER";
+        case SourceInfo_Extension_Component.COMPONENT_RUNTIME:
+            return "COMPONENT_RUNTIME";
+        case SourceInfo_Extension_Component.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseParsedExpr() {
+    return {
+        expr: undefined,
+        sourceInfo: undefined
+    };
+}
+/**
+ * An expression together with source information as returned by the parser.
+ * @name ParsedExpr
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.ParsedExpr
+ */
+export const ParsedExpr = {
+    typeUrl: "/google.api.expr.v1alpha1.ParsedExpr",
+    is(o) {
+        return o && o.$typeUrl === ParsedExpr.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === ParsedExpr.typeUrl;
+    },
+    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();
+        }
+        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;
+                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;
+        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);
+        }
+        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;
+        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.v1alpha1.ParsedExpr",
+            value: ParsedExpr.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(ParsedExpr.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+        SourceInfo.registerTypeUrl();
+    }
+};
+function createBaseExpr() {
+    return {
+        id: BigInt(0),
+        constExpr: 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.v1alpha1.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.v1alpha1.Expr.Select] expression, and the
+ * function declaration `startsWith`.
+ * @name Expr
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Expr
+ */
+export const Expr = {
+    typeUrl: "/google.api.expr.v1alpha1.Expr",
+    is(o) {
+        return o && (o.$typeUrl === Expr.typeUrl || typeof o.id === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Expr.typeUrl || typeof o.id === "bigint");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== BigInt(0)) {
+            writer.uint32(16).int64(message.id);
+        }
+        if (message.constExpr !== undefined) {
+            Constant.encode(message.constExpr, 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.int64();
+                    break;
+                case 3:
+                    message.constExpr = Constant.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 !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
+        message.constExpr = object.constExpr !== undefined && object.constExpr !== null ? Constant.fromPartial(object.constExpr) : 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 = BigInt(object.id);
+        }
+        if (object.const_expr !== undefined && object.const_expr !== null) {
+            message.constExpr = Constant.fromAmino(object.const_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 !== BigInt(0) ? message.id?.toString() : undefined;
+        obj.const_expr = message.constExpr ? Constant.toAmino(message.constExpr) : 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.v1alpha1.Expr",
+            value: Expr.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Expr.typeUrl)) {
+            return;
+        }
+        Constant.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.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Ident
+ */
+export const Expr_Ident = {
+    typeUrl: "/google.api.expr.v1alpha1.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.v1alpha1.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.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Select
+ */
+export const Expr_Select = {
+    typeUrl: "/google.api.expr.v1alpha1.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.v1alpha1.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.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Call
+ */
+export const Expr_Call = {
+    typeUrl: "/google.api.expr.v1alpha1.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.v1alpha1.Call",
+            value: Expr_Call.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Expr_Call.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+    }
+};
+function createBaseExpr_CreateList() {
+    return {
+        elements: [],
+        optionalIndices: []
+    };
+}
+/**
+ * A list creation expression.
+ *
+ * Lists may either be homogenous, e.g. `[1, 2, 3]`, or heterogeneous, e.g.
+ * `dyn([1, 'hello', 2.0])`
+ * @name Expr_CreateList
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.CreateList
+ */
+export const Expr_CreateList = {
+    typeUrl: "/google.api.expr.v1alpha1.CreateList",
+    is(o) {
+        return o && (o.$typeUrl === Expr_CreateList.typeUrl || Array.isArray(o.elements) && (!o.elements.length || Expr.is(o.elements[0])) && Array.isArray(o.optionalIndices) && (!o.optionalIndices.length || typeof o.optionalIndices[0] === "number"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Expr_CreateList.typeUrl || Array.isArray(o.elements) && (!o.elements.length || Expr.isAmino(o.elements[0])) && Array.isArray(o.optional_indices) && (!o.optional_indices.length || typeof o.optional_indices[0] === "number"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.elements) {
+            Expr.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        writer.uint32(18).fork();
+        for (const v of message.optionalIndices) {
+            writer.int32(v);
+        }
+        writer.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;
+                case 2:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.optionalIndices.push(reader.int32());
+                        }
+                    }
+                    else {
+                        message.optionalIndices.push(reader.int32());
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseExpr_CreateList();
+        message.elements = object.elements?.map(e => Expr.fromPartial(e)) || [];
+        message.optionalIndices = object.optionalIndices?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseExpr_CreateList();
+        message.elements = object.elements?.map(e => Expr.fromAmino(e)) || [];
+        message.optionalIndices = object.optional_indices?.map(e => 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;
+        }
+        if (message.optionalIndices) {
+            obj.optional_indices = message.optionalIndices.map(e => e);
+        }
+        else {
+            obj.optional_indices = message.optionalIndices;
+        }
+        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.v1alpha1.CreateList",
+            value: Expr_CreateList.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Expr_CreateList.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+    }
+};
+function createBaseExpr_CreateStruct() {
+    return {
+        messageName: "",
+        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.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.CreateStruct
+ */
+export const Expr_CreateStruct = {
+    typeUrl: "/google.api.expr.v1alpha1.CreateStruct",
+    is(o) {
+        return o && (o.$typeUrl === Expr_CreateStruct.typeUrl || typeof o.messageName === "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.message_name === "string" && Array.isArray(o.entries) && (!o.entries.length || Expr_CreateStruct_Entry.isAmino(o.entries[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.messageName !== "") {
+            writer.uint32(10).string(message.messageName);
+        }
+        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.messageName = 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.messageName = object.messageName ?? "";
+        message.entries = object.entries?.map(e => Expr_CreateStruct_Entry.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseExpr_CreateStruct();
+        if (object.message_name !== undefined && object.message_name !== null) {
+            message.messageName = object.message_name;
+        }
+        message.entries = object.entries?.map(e => Expr_CreateStruct_Entry.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.message_name = message.messageName === "" ? undefined : message.messageName;
+        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.v1alpha1.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: BigInt(0),
+        fieldKey: undefined,
+        mapKey: undefined,
+        value: undefined,
+        optionalEntry: false
+    };
+}
+/**
+ * Represents an entry.
+ * @name Expr_CreateStruct_Entry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Entry
+ */
+export const Expr_CreateStruct_Entry = {
+    typeUrl: "/google.api.expr.v1alpha1.Entry",
+    is(o) {
+        return o && (o.$typeUrl === Expr_CreateStruct_Entry.typeUrl || typeof o.id === "bigint" && typeof o.optionalEntry === "boolean");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Expr_CreateStruct_Entry.typeUrl || typeof o.id === "bigint" && typeof o.optional_entry === "boolean");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== BigInt(0)) {
+            writer.uint32(8).int64(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();
+        }
+        if (message.optionalEntry === true) {
+            writer.uint32(40).bool(message.optionalEntry);
+        }
+        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.int64();
+                    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;
+                case 5:
+                    message.optionalEntry = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseExpr_CreateStruct_Entry();
+        message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(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;
+        message.optionalEntry = object.optionalEntry ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseExpr_CreateStruct_Entry();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = BigInt(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);
+        }
+        if (object.optional_entry !== undefined && object.optional_entry !== null) {
+            message.optionalEntry = object.optional_entry;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id !== BigInt(0) ? message.id?.toString() : undefined;
+        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;
+        obj.optional_entry = message.optionalEntry === false ? undefined : message.optionalEntry;
+        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.v1alpha1.Entry",
+            value: Expr_CreateStruct_Entry.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Expr_CreateStruct_Entry.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+    }
+};
+function createBaseExpr_Comprehension() {
+    return {
+        iterVar: "",
+        iterVar2: "",
+        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`.
+ *
+ * Comprehensions for the standard environment macros evaluation can be best
+ * visualized as the following pseudocode:
+ *
+ * ```
+ * let `accu_var` = `accu_init`
+ * for (let `iter_var` in `iter_range`) {
+ *   if (!`loop_condition`) {
+ *     break
+ *   }
+ *   `accu_var` = `loop_step`
+ * }
+ * return `result`
+ * ```
+ *
+ * Comprehensions for the optional V2 macros which support map-to-map
+ * translation differ slightly from the standard environment macros in that
+ * they expose both the key or index in addition to the value for each list
+ * or map entry:
+ *
+ * ```
+ * let `accu_var` = `accu_init`
+ * for (let `iter_var`, `iter_var2` in `iter_range`) {
+ *   if (!`loop_condition`) {
+ *     break
+ *   }
+ *   `accu_var` = `loop_step`
+ * }
+ * return `result`
+ * ```
+ * @name Expr_Comprehension
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Comprehension
+ */
+export const Expr_Comprehension = {
+    typeUrl: "/google.api.expr.v1alpha1.Comprehension",
+    is(o) {
+        return o && (o.$typeUrl === Expr_Comprehension.typeUrl || typeof o.iterVar === "string" && typeof o.iterVar2 === "string" && typeof o.accuVar === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Expr_Comprehension.typeUrl || typeof o.iter_var === "string" && typeof o.iter_var2 === "string" && typeof o.accu_var === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.iterVar !== "") {
+            writer.uint32(10).string(message.iterVar);
+        }
+        if (message.iterVar2 !== "") {
+            writer.uint32(66).string(message.iterVar2);
+        }
+        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 8:
+                    message.iterVar2 = 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.iterVar2 = object.iterVar2 ?? "";
+        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_var2 !== undefined && object.iter_var2 !== null) {
+            message.iterVar2 = object.iter_var2;
+        }
+        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_var2 = message.iterVar2 === "" ? undefined : message.iterVar2;
+        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.v1alpha1.Comprehension",
+            value: Expr_Comprehension.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Expr_Comprehension.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+    }
+};
+function createBaseConstant() {
+    return {
+        nullValue: undefined,
+        boolValue: undefined,
+        int64Value: undefined,
+        uint64Value: undefined,
+        doubleValue: undefined,
+        stringValue: undefined,
+        bytesValue: undefined,
+        durationValue: undefined,
+        timestampValue: undefined
+    };
+}
+/**
+ * Represents a primitive literal.
+ *
+ * Named 'Constant' here for backwards compatibility.
+ *
+ * This is similar as 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.v1alpha1.Expr] elements which require
+ * evaluation and are thus not constant.
+ *
+ * Examples of literals include: `"hello"`, `b'bytes'`, `1u`, `4.2`, `-2`,
+ * `true`, `null`.
+ * @name Constant
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Constant
+ */
+export const Constant = {
+    typeUrl: "/google.api.expr.v1alpha1.Constant",
+    is(o) {
+        return o && o.$typeUrl === Constant.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === Constant.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);
+        }
+        if (message.durationValue !== undefined) {
+            Duration.encode(message.durationValue, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.timestampValue !== undefined) {
+            Timestamp.encode(toTimestamp(message.timestampValue), 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 = createBaseConstant();
+        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;
+                case 8:
+                    message.durationValue = Duration.decode(reader, reader.uint32());
+                    break;
+                case 9:
+                    message.timestampValue = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseConstant();
+        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;
+        message.durationValue = object.durationValue !== undefined && object.durationValue !== null ? Duration.fromPartial(object.durationValue) : undefined;
+        message.timestampValue = object.timestampValue ?? undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseConstant();
+        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);
+        }
+        if (object.duration_value !== undefined && object.duration_value !== null) {
+            message.durationValue = Duration.fromAmino(object.duration_value);
+        }
+        if (object.timestamp_value !== undefined && object.timestamp_value !== null) {
+            message.timestampValue = fromTimestamp(Timestamp.fromAmino(object.timestamp_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;
+        obj.duration_value = message.durationValue ? Duration.toAmino(message.durationValue) : undefined;
+        obj.timestamp_value = message.timestampValue ? Timestamp.toAmino(toTimestamp(message.timestampValue)) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Constant.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Constant.decode(message.value);
+    },
+    toProto(message) {
+        return Constant.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.Constant",
+            value: Constant.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseSourceInfo_PositionsEntry() {
+    return {
+        key: BigInt(0),
+        value: 0
+    };
+}
+/**
+ * @name SourceInfo_PositionsEntry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.undefined
+ */
+export const SourceInfo_PositionsEntry = {
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key !== BigInt(0)) {
+            writer.uint32(8).int64(message.key);
+        }
+        if (message.value !== 0) {
+            writer.uint32(16).int32(message.value);
+        }
+        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 = createBaseSourceInfo_PositionsEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.int64();
+                    break;
+                case 2:
+                    message.value = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSourceInfo_PositionsEntry();
+        message.key = object.key !== undefined && object.key !== null ? BigInt(object.key.toString()) : BigInt(0);
+        message.value = object.value ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseSourceInfo_PositionsEntry();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = BigInt(object.key);
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = object.value;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key !== BigInt(0) ? message.key?.toString() : undefined;
+        obj.value = message.value === 0 ? undefined : message.value;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return SourceInfo_PositionsEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return SourceInfo_PositionsEntry.decode(message.value);
+    },
+    toProto(message) {
+        return SourceInfo_PositionsEntry.encode(message).finish();
+    },
+    registerTypeUrl() { }
+};
+function createBaseSourceInfo_MacroCallsEntry() {
+    return {
+        key: BigInt(0),
+        value: undefined
+    };
+}
+/**
+ * @name SourceInfo_MacroCallsEntry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.undefined
+ */
+export const SourceInfo_MacroCallsEntry = {
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key !== BigInt(0)) {
+            writer.uint32(8).int64(message.key);
+        }
+        if (message.value !== undefined) {
+            Expr.encode(message.value, 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 = createBaseSourceInfo_MacroCallsEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.int64();
+                    break;
+                case 2:
+                    message.value = Expr.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSourceInfo_MacroCallsEntry();
+        message.key = object.key !== undefined && object.key !== null ? BigInt(object.key.toString()) : BigInt(0);
+        message.value = object.value !== undefined && object.value !== null ? Expr.fromPartial(object.value) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseSourceInfo_MacroCallsEntry();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = BigInt(object.key);
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = Expr.fromAmino(object.value);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key !== BigInt(0) ? message.key?.toString() : undefined;
+        obj.value = message.value ? Expr.toAmino(message.value) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return SourceInfo_MacroCallsEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return SourceInfo_MacroCallsEntry.decode(message.value);
+    },
+    toProto(message) {
+        return SourceInfo_MacroCallsEntry.encode(message).finish();
+    },
+    registerTypeUrl() {
+        Expr.registerTypeUrl();
+    }
+};
+function createBaseSourceInfo() {
+    return {
+        syntaxVersion: "",
+        location: "",
+        lineOffsets: [],
+        positions: {},
+        macroCalls: {},
+        extensions: []
+    };
+}
+/**
+ * Source information collected at parse time.
+ * @name SourceInfo
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.SourceInfo
+ */
+export const SourceInfo = {
+    typeUrl: "/google.api.expr.v1alpha1.SourceInfo",
+    is(o) {
+        return o && (o.$typeUrl === SourceInfo.typeUrl || typeof o.syntaxVersion === "string" && typeof o.location === "string" && Array.isArray(o.lineOffsets) && (!o.lineOffsets.length || typeof o.lineOffsets[0] === "number") && isSet(o.positions) && isSet(o.macroCalls) && Array.isArray(o.extensions) && (!o.extensions.length || SourceInfo_Extension.is(o.extensions[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === SourceInfo.typeUrl || typeof o.syntax_version === "string" && typeof o.location === "string" && Array.isArray(o.line_offsets) && (!o.line_offsets.length || typeof o.line_offsets[0] === "number") && isSet(o.positions) && isSet(o.macro_calls) && Array.isArray(o.extensions) && (!o.extensions.length || SourceInfo_Extension.isAmino(o.extensions[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.syntaxVersion !== "") {
+            writer.uint32(10).string(message.syntaxVersion);
+        }
+        if (message.location !== "") {
+            writer.uint32(18).string(message.location);
+        }
+        writer.uint32(26).fork();
+        for (const v of message.lineOffsets) {
+            writer.int32(v);
+        }
+        writer.ldelim();
+        Object.entries(message.positions).forEach(([key, value]) => {
+            SourceInfo_PositionsEntry.encode({
+                key: key,
+                value
+            }, writer.uint32(32).fork()).ldelim();
+        });
+        Object.entries(message.macroCalls).forEach(([key, value]) => {
+            SourceInfo_MacroCallsEntry.encode({
+                key: key,
+                value
+            }, writer.uint32(42).fork()).ldelim();
+        });
+        for (const v of message.extensions) {
+            SourceInfo_Extension.encode(v, writer.uint32(50).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 = createBaseSourceInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.syntaxVersion = reader.string();
+                    break;
+                case 2:
+                    message.location = reader.string();
+                    break;
+                case 3:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.lineOffsets.push(reader.int32());
+                        }
+                    }
+                    else {
+                        message.lineOffsets.push(reader.int32());
+                    }
+                    break;
+                case 4:
+                    const entry4 = SourceInfo_PositionsEntry.decode(reader, reader.uint32());
+                    if (entry4.value !== undefined) {
+                        message.positions[entry4.key] = entry4.value;
+                    }
+                    break;
+                case 5:
+                    const entry5 = SourceInfo_MacroCallsEntry.decode(reader, reader.uint32());
+                    if (entry5.value !== undefined) {
+                        message.macroCalls[entry5.key] = entry5.value;
+                    }
+                    break;
+                case 6:
+                    message.extensions.push(SourceInfo_Extension.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSourceInfo();
+        message.syntaxVersion = object.syntaxVersion ?? "";
+        message.location = object.location ?? "";
+        message.lineOffsets = object.lineOffsets?.map(e => e) || [];
+        message.positions = Object.entries(object.positions ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[Number(key)] = Number(value);
+            }
+            return acc;
+        }, {});
+        message.macroCalls = Object.entries(object.macroCalls ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[Number(key)] = Expr.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        message.extensions = object.extensions?.map(e => SourceInfo_Extension.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseSourceInfo();
+        if (object.syntax_version !== undefined && object.syntax_version !== null) {
+            message.syntaxVersion = object.syntax_version;
+        }
+        if (object.location !== undefined && object.location !== null) {
+            message.location = object.location;
+        }
+        message.lineOffsets = object.line_offsets?.map(e => e) || [];
+        message.positions = Object.entries(object.positions ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[Number(key)] = Number(value);
+            }
+            return acc;
+        }, {});
+        message.macroCalls = Object.entries(object.macro_calls ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[Number(key)] = Expr.fromAmino(value);
+            }
+            return acc;
+        }, {});
+        message.extensions = object.extensions?.map(e => SourceInfo_Extension.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.syntax_version = message.syntaxVersion === "" ? undefined : message.syntaxVersion;
+        obj.location = message.location === "" ? undefined : message.location;
+        if (message.lineOffsets) {
+            obj.line_offsets = message.lineOffsets.map(e => e);
+        }
+        else {
+            obj.line_offsets = message.lineOffsets;
+        }
+        obj.positions = {};
+        if (message.positions) {
+            Object.entries(message.positions).forEach(([k, v]) => {
+                obj.positions[k] = Math.round(v);
+            });
+        }
+        obj.macro_calls = {};
+        if (message.macroCalls) {
+            Object.entries(message.macroCalls).forEach(([k, v]) => {
+                obj.macro_calls[k] = Expr.toAmino(v);
+            });
+        }
+        if (message.extensions) {
+            obj.extensions = message.extensions.map(e => e ? SourceInfo_Extension.toAmino(e) : undefined);
+        }
+        else {
+            obj.extensions = message.extensions;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return SourceInfo.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return SourceInfo.decode(message.value);
+    },
+    toProto(message) {
+        return SourceInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.SourceInfo",
+            value: SourceInfo.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(SourceInfo.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+        SourceInfo_Extension.registerTypeUrl();
+    }
+};
+function createBaseSourceInfo_Extension() {
+    return {
+        id: "",
+        affectedComponents: [],
+        version: undefined
+    };
+}
+/**
+ * An extension that was requested for the source expression.
+ * @name SourceInfo_Extension
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Extension
+ */
+export const SourceInfo_Extension = {
+    typeUrl: "/google.api.expr.v1alpha1.Extension",
+    is(o) {
+        return o && (o.$typeUrl === SourceInfo_Extension.typeUrl || typeof o.id === "string" && Array.isArray(o.affectedComponents));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === SourceInfo_Extension.typeUrl || typeof o.id === "string" && Array.isArray(o.affected_components));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== "") {
+            writer.uint32(10).string(message.id);
+        }
+        writer.uint32(18).fork();
+        for (const v of message.affectedComponents) {
+            writer.int32(v);
+        }
+        writer.ldelim();
+        if (message.version !== undefined) {
+            SourceInfo_Extension_Version.encode(message.version, 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 = createBaseSourceInfo_Extension();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.string();
+                    break;
+                case 2:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.affectedComponents.push(reader.int32());
+                        }
+                    }
+                    else {
+                        message.affectedComponents.push(reader.int32());
+                    }
+                    break;
+                case 3:
+                    message.version = SourceInfo_Extension_Version.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSourceInfo_Extension();
+        message.id = object.id ?? "";
+        message.affectedComponents = object.affectedComponents?.map(e => e) || [];
+        message.version = object.version !== undefined && object.version !== null ? SourceInfo_Extension_Version.fromPartial(object.version) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseSourceInfo_Extension();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = object.id;
+        }
+        message.affectedComponents = object.affected_components?.map(e => e) || [];
+        if (object.version !== undefined && object.version !== null) {
+            message.version = SourceInfo_Extension_Version.fromAmino(object.version);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id === "" ? undefined : message.id;
+        if (message.affectedComponents) {
+            obj.affected_components = message.affectedComponents.map(e => e);
+        }
+        else {
+            obj.affected_components = message.affectedComponents;
+        }
+        obj.version = message.version ? SourceInfo_Extension_Version.toAmino(message.version) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return SourceInfo_Extension.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return SourceInfo_Extension.decode(message.value);
+    },
+    toProto(message) {
+        return SourceInfo_Extension.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.Extension",
+            value: SourceInfo_Extension.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(SourceInfo_Extension.typeUrl)) {
+            return;
+        }
+        SourceInfo_Extension_Version.registerTypeUrl();
+    }
+};
+function createBaseSourceInfo_Extension_Version() {
+    return {
+        major: BigInt(0),
+        minor: BigInt(0)
+    };
+}
+/**
+ * Version
+ * @name SourceInfo_Extension_Version
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Version
+ */
+export const SourceInfo_Extension_Version = {
+    typeUrl: "/google.api.expr.v1alpha1.Version",
+    is(o) {
+        return o && (o.$typeUrl === SourceInfo_Extension_Version.typeUrl || typeof o.major === "bigint" && typeof o.minor === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === SourceInfo_Extension_Version.typeUrl || typeof o.major === "bigint" && typeof o.minor === "bigint");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.major !== BigInt(0)) {
+            writer.uint32(8).int64(message.major);
+        }
+        if (message.minor !== BigInt(0)) {
+            writer.uint32(16).int64(message.minor);
+        }
+        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 = createBaseSourceInfo_Extension_Version();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.major = reader.int64();
+                    break;
+                case 2:
+                    message.minor = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSourceInfo_Extension_Version();
+        message.major = object.major !== undefined && object.major !== null ? BigInt(object.major.toString()) : BigInt(0);
+        message.minor = object.minor !== undefined && object.minor !== null ? BigInt(object.minor.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseSourceInfo_Extension_Version();
+        if (object.major !== undefined && object.major !== null) {
+            message.major = BigInt(object.major);
+        }
+        if (object.minor !== undefined && object.minor !== null) {
+            message.minor = BigInt(object.minor);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.major = message.major !== BigInt(0) ? message.major?.toString() : undefined;
+        obj.minor = message.minor !== BigInt(0) ? message.minor?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return SourceInfo_Extension_Version.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return SourceInfo_Extension_Version.decode(message.value);
+    },
+    toProto(message) {
+        return SourceInfo_Extension_Version.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.Version",
+            value: SourceInfo_Extension_Version.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseSourcePosition() {
+    return {
+        location: "",
+        offset: 0,
+        line: 0,
+        column: 0
+    };
+}
+/**
+ * A specific position in source.
+ * @name SourcePosition
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.SourcePosition
+ */
+export const SourcePosition = {
+    typeUrl: "/google.api.expr.v1alpha1.SourcePosition",
+    is(o) {
+        return o && (o.$typeUrl === SourcePosition.typeUrl || typeof o.location === "string" && typeof o.offset === "number" && typeof o.line === "number" && typeof o.column === "number");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === SourcePosition.typeUrl || typeof o.location === "string" && typeof o.offset === "number" && typeof o.line === "number" && typeof o.column === "number");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.location !== "") {
+            writer.uint32(10).string(message.location);
+        }
+        if (message.offset !== 0) {
+            writer.uint32(16).int32(message.offset);
+        }
+        if (message.line !== 0) {
+            writer.uint32(24).int32(message.line);
+        }
+        if (message.column !== 0) {
+            writer.uint32(32).int32(message.column);
+        }
+        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 = createBaseSourcePosition();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.location = reader.string();
+                    break;
+                case 2:
+                    message.offset = reader.int32();
+                    break;
+                case 3:
+                    message.line = reader.int32();
+                    break;
+                case 4:
+                    message.column = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSourcePosition();
+        message.location = object.location ?? "";
+        message.offset = object.offset ?? 0;
+        message.line = object.line ?? 0;
+        message.column = object.column ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseSourcePosition();
+        if (object.location !== undefined && object.location !== null) {
+            message.location = object.location;
+        }
+        if (object.offset !== undefined && object.offset !== null) {
+            message.offset = object.offset;
+        }
+        if (object.line !== undefined && object.line !== null) {
+            message.line = object.line;
+        }
+        if (object.column !== undefined && object.column !== null) {
+            message.column = object.column;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.location = message.location === "" ? undefined : message.location;
+        obj.offset = message.offset === 0 ? undefined : message.offset;
+        obj.line = message.line === 0 ? undefined : message.line;
+        obj.column = message.column === 0 ? undefined : message.column;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return SourcePosition.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return SourcePosition.decode(message.value);
+    },
+    toProto(message) {
+        return SourcePosition.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.SourcePosition",
+            value: SourcePosition.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};