@0xkaleab/sdk-js 0.2.7

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

@@ -0,0 +1,1634 @@
+// @ts-nocheck
+/* eslint-disable */
+import { SourceInfo, Expr, Constant } from "./syntax";
+import { Empty } from "../../../protobuf/empty";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { GlobalDecoderRegistry } from "../../../../registry";
+import { isSet } from "../../../../helpers";
+/** CEL primitive types. */
+export var Type_PrimitiveType;
+(function (Type_PrimitiveType) {
+    /** PRIMITIVE_TYPE_UNSPECIFIED - Unspecified type. */
+    Type_PrimitiveType[Type_PrimitiveType["PRIMITIVE_TYPE_UNSPECIFIED"] = 0] = "PRIMITIVE_TYPE_UNSPECIFIED";
+    /** BOOL - Boolean type. */
+    Type_PrimitiveType[Type_PrimitiveType["BOOL"] = 1] = "BOOL";
+    /**
+     * INT64 - Int64 type.
+     *
+     * Proto-based integer values are widened to int64.
+     */
+    Type_PrimitiveType[Type_PrimitiveType["INT64"] = 2] = "INT64";
+    /**
+     * UINT64 - Uint64 type.
+     *
+     * Proto-based unsigned integer values are widened to uint64.
+     */
+    Type_PrimitiveType[Type_PrimitiveType["UINT64"] = 3] = "UINT64";
+    /**
+     * DOUBLE - Double type.
+     *
+     * Proto-based float values are widened to number values.
+     */
+    Type_PrimitiveType[Type_PrimitiveType["DOUBLE"] = 4] = "DOUBLE";
+    /** STRING - String type. */
+    Type_PrimitiveType[Type_PrimitiveType["STRING"] = 5] = "STRING";
+    /** BYTES - Bytes type. */
+    Type_PrimitiveType[Type_PrimitiveType["BYTES"] = 6] = "BYTES";
+    Type_PrimitiveType[Type_PrimitiveType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Type_PrimitiveType || (Type_PrimitiveType = {}));
+export const Type_PrimitiveTypeAmino = Type_PrimitiveType;
+export function type_PrimitiveTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "PRIMITIVE_TYPE_UNSPECIFIED":
+            return Type_PrimitiveType.PRIMITIVE_TYPE_UNSPECIFIED;
+        case 1:
+        case "BOOL":
+            return Type_PrimitiveType.BOOL;
+        case 2:
+        case "INT64":
+            return Type_PrimitiveType.INT64;
+        case 3:
+        case "UINT64":
+            return Type_PrimitiveType.UINT64;
+        case 4:
+        case "DOUBLE":
+            return Type_PrimitiveType.DOUBLE;
+        case 5:
+        case "STRING":
+            return Type_PrimitiveType.STRING;
+        case 6:
+        case "BYTES":
+            return Type_PrimitiveType.BYTES;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return Type_PrimitiveType.UNRECOGNIZED;
+    }
+}
+export function type_PrimitiveTypeToJSON(object) {
+    switch (object) {
+        case Type_PrimitiveType.PRIMITIVE_TYPE_UNSPECIFIED:
+            return "PRIMITIVE_TYPE_UNSPECIFIED";
+        case Type_PrimitiveType.BOOL:
+            return "BOOL";
+        case Type_PrimitiveType.INT64:
+            return "INT64";
+        case Type_PrimitiveType.UINT64:
+            return "UINT64";
+        case Type_PrimitiveType.DOUBLE:
+            return "DOUBLE";
+        case Type_PrimitiveType.STRING:
+            return "STRING";
+        case Type_PrimitiveType.BYTES:
+            return "BYTES";
+        case Type_PrimitiveType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** Well-known protobuf types treated with first-class support in CEL. */
+export var Type_WellKnownType;
+(function (Type_WellKnownType) {
+    /** WELL_KNOWN_TYPE_UNSPECIFIED - Unspecified type. */
+    Type_WellKnownType[Type_WellKnownType["WELL_KNOWN_TYPE_UNSPECIFIED"] = 0] = "WELL_KNOWN_TYPE_UNSPECIFIED";
+    /**
+     * ANY - Well-known protobuf.Any type.
+     *
+     * Any types are a polymorphic message type. During type-checking they are
+     * treated like `DYN` types, but at runtime they are resolved to a specific
+     * message type specified at evaluation time.
+     */
+    Type_WellKnownType[Type_WellKnownType["ANY"] = 1] = "ANY";
+    /** TIMESTAMP - Well-known protobuf.Timestamp type, internally referenced as `timestamp`. */
+    Type_WellKnownType[Type_WellKnownType["TIMESTAMP"] = 2] = "TIMESTAMP";
+    /** DURATION - Well-known protobuf.Duration type, internally referenced as `duration`. */
+    Type_WellKnownType[Type_WellKnownType["DURATION"] = 3] = "DURATION";
+    Type_WellKnownType[Type_WellKnownType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Type_WellKnownType || (Type_WellKnownType = {}));
+export const Type_WellKnownTypeAmino = Type_WellKnownType;
+export function type_WellKnownTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "WELL_KNOWN_TYPE_UNSPECIFIED":
+            return Type_WellKnownType.WELL_KNOWN_TYPE_UNSPECIFIED;
+        case 1:
+        case "ANY":
+            return Type_WellKnownType.ANY;
+        case 2:
+        case "TIMESTAMP":
+            return Type_WellKnownType.TIMESTAMP;
+        case 3:
+        case "DURATION":
+            return Type_WellKnownType.DURATION;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return Type_WellKnownType.UNRECOGNIZED;
+    }
+}
+export function type_WellKnownTypeToJSON(object) {
+    switch (object) {
+        case Type_WellKnownType.WELL_KNOWN_TYPE_UNSPECIFIED:
+            return "WELL_KNOWN_TYPE_UNSPECIFIED";
+        case Type_WellKnownType.ANY:
+            return "ANY";
+        case Type_WellKnownType.TIMESTAMP:
+            return "TIMESTAMP";
+        case Type_WellKnownType.DURATION:
+            return "DURATION";
+        case Type_WellKnownType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseCheckedExpr_ReferenceMapEntry() {
+    return {
+        key: BigInt(0),
+        value: undefined
+    };
+}
+/**
+ * @name CheckedExpr_ReferenceMapEntry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.undefined
+ */
+export const CheckedExpr_ReferenceMapEntry = {
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key !== BigInt(0)) {
+            writer.uint32(8).int64(message.key);
+        }
+        if (message.value !== undefined) {
+            Reference.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 = createBaseCheckedExpr_ReferenceMapEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.int64();
+                    break;
+                case 2:
+                    message.value = Reference.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCheckedExpr_ReferenceMapEntry();
+        message.key = object.key !== undefined && object.key !== null ? BigInt(object.key.toString()) : BigInt(0);
+        message.value = object.value !== undefined && object.value !== null ? Reference.fromPartial(object.value) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseCheckedExpr_ReferenceMapEntry();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = BigInt(object.key);
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = Reference.fromAmino(object.value);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key !== BigInt(0) ? message.key?.toString() : undefined;
+        obj.value = message.value ? Reference.toAmino(message.value) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return CheckedExpr_ReferenceMapEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return CheckedExpr_ReferenceMapEntry.decode(message.value);
+    },
+    toProto(message) {
+        return CheckedExpr_ReferenceMapEntry.encode(message).finish();
+    },
+    registerTypeUrl() {
+        Reference.registerTypeUrl();
+    }
+};
+function createBaseCheckedExpr_TypeMapEntry() {
+    return {
+        key: BigInt(0),
+        value: undefined
+    };
+}
+/**
+ * @name CheckedExpr_TypeMapEntry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.undefined
+ */
+export const CheckedExpr_TypeMapEntry = {
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key !== BigInt(0)) {
+            writer.uint32(8).int64(message.key);
+        }
+        if (message.value !== undefined) {
+            Type.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 = createBaseCheckedExpr_TypeMapEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.int64();
+                    break;
+                case 2:
+                    message.value = Type.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCheckedExpr_TypeMapEntry();
+        message.key = object.key !== undefined && object.key !== null ? BigInt(object.key.toString()) : BigInt(0);
+        message.value = object.value !== undefined && object.value !== null ? Type.fromPartial(object.value) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseCheckedExpr_TypeMapEntry();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = BigInt(object.key);
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = Type.fromAmino(object.value);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key !== BigInt(0) ? message.key?.toString() : undefined;
+        obj.value = message.value ? Type.toAmino(message.value) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return CheckedExpr_TypeMapEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return CheckedExpr_TypeMapEntry.decode(message.value);
+    },
+    toProto(message) {
+        return CheckedExpr_TypeMapEntry.encode(message).finish();
+    },
+    registerTypeUrl() {
+        Type.registerTypeUrl();
+    }
+};
+function createBaseCheckedExpr() {
+    return {
+        referenceMap: {},
+        typeMap: {},
+        sourceInfo: undefined,
+        exprVersion: "",
+        expr: undefined
+    };
+}
+/**
+ * A CEL expression which has been successfully type checked.
+ * @name CheckedExpr
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.CheckedExpr
+ */
+export const CheckedExpr = {
+    typeUrl: "/google.api.expr.v1alpha1.CheckedExpr",
+    is(o) {
+        return o && (o.$typeUrl === CheckedExpr.typeUrl || isSet(o.referenceMap) && isSet(o.typeMap) && typeof o.exprVersion === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === CheckedExpr.typeUrl || isSet(o.reference_map) && isSet(o.type_map) && typeof o.expr_version === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        Object.entries(message.referenceMap).forEach(([key, value]) => {
+            CheckedExpr_ReferenceMapEntry.encode({
+                key: key,
+                value
+            }, writer.uint32(18).fork()).ldelim();
+        });
+        Object.entries(message.typeMap).forEach(([key, value]) => {
+            CheckedExpr_TypeMapEntry.encode({
+                key: key,
+                value
+            }, writer.uint32(26).fork()).ldelim();
+        });
+        if (message.sourceInfo !== undefined) {
+            SourceInfo.encode(message.sourceInfo, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.exprVersion !== "") {
+            writer.uint32(50).string(message.exprVersion);
+        }
+        if (message.expr !== undefined) {
+            Expr.encode(message.expr, 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 = createBaseCheckedExpr();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2:
+                    const entry2 = CheckedExpr_ReferenceMapEntry.decode(reader, reader.uint32());
+                    if (entry2.value !== undefined) {
+                        message.referenceMap[entry2.key] = entry2.value;
+                    }
+                    break;
+                case 3:
+                    const entry3 = CheckedExpr_TypeMapEntry.decode(reader, reader.uint32());
+                    if (entry3.value !== undefined) {
+                        message.typeMap[entry3.key] = entry3.value;
+                    }
+                    break;
+                case 5:
+                    message.sourceInfo = SourceInfo.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.exprVersion = reader.string();
+                    break;
+                case 4:
+                    message.expr = Expr.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCheckedExpr();
+        message.referenceMap = Object.entries(object.referenceMap ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[Number(key)] = Reference.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        message.typeMap = Object.entries(object.typeMap ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[Number(key)] = Type.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        message.sourceInfo = object.sourceInfo !== undefined && object.sourceInfo !== null ? SourceInfo.fromPartial(object.sourceInfo) : undefined;
+        message.exprVersion = object.exprVersion ?? "";
+        message.expr = object.expr !== undefined && object.expr !== null ? Expr.fromPartial(object.expr) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseCheckedExpr();
+        message.referenceMap = Object.entries(object.reference_map ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[Number(key)] = Reference.fromAmino(value);
+            }
+            return acc;
+        }, {});
+        message.typeMap = Object.entries(object.type_map ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[Number(key)] = Type.fromAmino(value);
+            }
+            return acc;
+        }, {});
+        if (object.source_info !== undefined && object.source_info !== null) {
+            message.sourceInfo = SourceInfo.fromAmino(object.source_info);
+        }
+        if (object.expr_version !== undefined && object.expr_version !== null) {
+            message.exprVersion = object.expr_version;
+        }
+        if (object.expr !== undefined && object.expr !== null) {
+            message.expr = Expr.fromAmino(object.expr);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.reference_map = {};
+        if (message.referenceMap) {
+            Object.entries(message.referenceMap).forEach(([k, v]) => {
+                obj.reference_map[k] = Reference.toAmino(v);
+            });
+        }
+        obj.type_map = {};
+        if (message.typeMap) {
+            Object.entries(message.typeMap).forEach(([k, v]) => {
+                obj.type_map[k] = Type.toAmino(v);
+            });
+        }
+        obj.source_info = message.sourceInfo ? SourceInfo.toAmino(message.sourceInfo) : undefined;
+        obj.expr_version = message.exprVersion === "" ? undefined : message.exprVersion;
+        obj.expr = message.expr ? Expr.toAmino(message.expr) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return CheckedExpr.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return CheckedExpr.decode(message.value);
+    },
+    toProto(message) {
+        return CheckedExpr.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.CheckedExpr",
+            value: CheckedExpr.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(CheckedExpr.typeUrl)) {
+            return;
+        }
+        Reference.registerTypeUrl();
+        Type.registerTypeUrl();
+        SourceInfo.registerTypeUrl();
+        Expr.registerTypeUrl();
+    }
+};
+function createBaseType() {
+    return {
+        dyn: undefined,
+        null: undefined,
+        primitive: undefined,
+        wrapper: undefined,
+        wellKnown: undefined,
+        listType: undefined,
+        mapType: undefined,
+        function: undefined,
+        messageType: undefined,
+        typeParam: undefined,
+        type: undefined,
+        error: undefined,
+        abstractType: undefined
+    };
+}
+/**
+ * Represents a CEL type.
+ * @name Type
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Type
+ */
+export const Type = {
+    typeUrl: "/google.api.expr.v1alpha1.Type",
+    is(o) {
+        return o && o.$typeUrl === Type.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === Type.typeUrl;
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.dyn !== undefined) {
+            Empty.encode(message.dyn, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.null !== undefined) {
+            writer.uint32(16).int32(message.null);
+        }
+        if (message.primitive !== undefined) {
+            writer.uint32(24).int32(message.primitive);
+        }
+        if (message.wrapper !== undefined) {
+            writer.uint32(32).int32(message.wrapper);
+        }
+        if (message.wellKnown !== undefined) {
+            writer.uint32(40).int32(message.wellKnown);
+        }
+        if (message.listType !== undefined) {
+            Type_ListType.encode(message.listType, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.mapType !== undefined) {
+            Type_MapType.encode(message.mapType, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.function !== undefined) {
+            Type_FunctionType.encode(message.function, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.messageType !== undefined) {
+            writer.uint32(74).string(message.messageType);
+        }
+        if (message.typeParam !== undefined) {
+            writer.uint32(82).string(message.typeParam);
+        }
+        if (message.type !== undefined) {
+            Type.encode(message.type, writer.uint32(90).fork()).ldelim();
+        }
+        if (message.error !== undefined) {
+            Empty.encode(message.error, writer.uint32(98).fork()).ldelim();
+        }
+        if (message.abstractType !== undefined) {
+            Type_AbstractType.encode(message.abstractType, writer.uint32(114).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 = createBaseType();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.dyn = Empty.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.null = reader.int32();
+                    break;
+                case 3:
+                    message.primitive = reader.int32();
+                    break;
+                case 4:
+                    message.wrapper = reader.int32();
+                    break;
+                case 5:
+                    message.wellKnown = reader.int32();
+                    break;
+                case 6:
+                    message.listType = Type_ListType.decode(reader, reader.uint32());
+                    break;
+                case 7:
+                    message.mapType = Type_MapType.decode(reader, reader.uint32());
+                    break;
+                case 8:
+                    message.function = Type_FunctionType.decode(reader, reader.uint32());
+                    break;
+                case 9:
+                    message.messageType = reader.string();
+                    break;
+                case 10:
+                    message.typeParam = reader.string();
+                    break;
+                case 11:
+                    message.type = Type.decode(reader, reader.uint32());
+                    break;
+                case 12:
+                    message.error = Empty.decode(reader, reader.uint32());
+                    break;
+                case 14:
+                    message.abstractType = Type_AbstractType.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseType();
+        message.dyn = object.dyn !== undefined && object.dyn !== null ? Empty.fromPartial(object.dyn) : undefined;
+        message.null = object.null ?? undefined;
+        message.primitive = object.primitive ?? undefined;
+        message.wrapper = object.wrapper ?? undefined;
+        message.wellKnown = object.wellKnown ?? undefined;
+        message.listType = object.listType !== undefined && object.listType !== null ? Type_ListType.fromPartial(object.listType) : undefined;
+        message.mapType = object.mapType !== undefined && object.mapType !== null ? Type_MapType.fromPartial(object.mapType) : undefined;
+        message.function = object.function !== undefined && object.function !== null ? Type_FunctionType.fromPartial(object.function) : undefined;
+        message.messageType = object.messageType ?? undefined;
+        message.typeParam = object.typeParam ?? undefined;
+        message.type = object.type !== undefined && object.type !== null ? Type.fromPartial(object.type) : undefined;
+        message.error = object.error !== undefined && object.error !== null ? Empty.fromPartial(object.error) : undefined;
+        message.abstractType = object.abstractType !== undefined && object.abstractType !== null ? Type_AbstractType.fromPartial(object.abstractType) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseType();
+        if (object.dyn !== undefined && object.dyn !== null) {
+            message.dyn = Empty.fromAmino(object.dyn);
+        }
+        if (object.null !== undefined && object.null !== null) {
+            message.null = object.null;
+        }
+        if (object.primitive !== undefined && object.primitive !== null) {
+            message.primitive = object.primitive;
+        }
+        if (object.wrapper !== undefined && object.wrapper !== null) {
+            message.wrapper = object.wrapper;
+        }
+        if (object.well_known !== undefined && object.well_known !== null) {
+            message.wellKnown = object.well_known;
+        }
+        if (object.list_type !== undefined && object.list_type !== null) {
+            message.listType = Type_ListType.fromAmino(object.list_type);
+        }
+        if (object.map_type !== undefined && object.map_type !== null) {
+            message.mapType = Type_MapType.fromAmino(object.map_type);
+        }
+        if (object.function !== undefined && object.function !== null) {
+            message.function = Type_FunctionType.fromAmino(object.function);
+        }
+        if (object.message_type !== undefined && object.message_type !== null) {
+            message.messageType = object.message_type;
+        }
+        if (object.type_param !== undefined && object.type_param !== null) {
+            message.typeParam = object.type_param;
+        }
+        if (object.type !== undefined && object.type !== null) {
+            message.type = Type.fromAmino(object.type);
+        }
+        if (object.error !== undefined && object.error !== null) {
+            message.error = Empty.fromAmino(object.error);
+        }
+        if (object.abstract_type !== undefined && object.abstract_type !== null) {
+            message.abstractType = Type_AbstractType.fromAmino(object.abstract_type);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.dyn = message.dyn ? Empty.toAmino(message.dyn) : undefined;
+        obj.null = message.null === null ? undefined : message.null;
+        obj.primitive = message.primitive === null ? undefined : message.primitive;
+        obj.wrapper = message.wrapper === null ? undefined : message.wrapper;
+        obj.well_known = message.wellKnown === null ? undefined : message.wellKnown;
+        obj.list_type = message.listType ? Type_ListType.toAmino(message.listType) : undefined;
+        obj.map_type = message.mapType ? Type_MapType.toAmino(message.mapType) : undefined;
+        obj.function = message.function ? Type_FunctionType.toAmino(message.function) : undefined;
+        obj.message_type = message.messageType === null ? undefined : message.messageType;
+        obj.type_param = message.typeParam === null ? undefined : message.typeParam;
+        obj.type = message.type ? Type.toAmino(message.type) : undefined;
+        obj.error = message.error ? Empty.toAmino(message.error) : undefined;
+        obj.abstract_type = message.abstractType ? Type_AbstractType.toAmino(message.abstractType) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Type.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Type.decode(message.value);
+    },
+    toProto(message) {
+        return Type.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.Type",
+            value: Type.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Type.typeUrl)) {
+            return;
+        }
+        Empty.registerTypeUrl();
+        Type_ListType.registerTypeUrl();
+        Type_MapType.registerTypeUrl();
+        Type_FunctionType.registerTypeUrl();
+        Type.registerTypeUrl();
+        Type_AbstractType.registerTypeUrl();
+    }
+};
+function createBaseType_ListType() {
+    return {
+        elemType: undefined
+    };
+}
+/**
+ * List type with typed elements, e.g. `list<example.proto.MyMessage>`.
+ * @name Type_ListType
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.ListType
+ */
+export const Type_ListType = {
+    typeUrl: "/google.api.expr.v1alpha1.ListType",
+    is(o) {
+        return o && o.$typeUrl === Type_ListType.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === Type_ListType.typeUrl;
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.elemType !== undefined) {
+            Type.encode(message.elemType, 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 = createBaseType_ListType();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.elemType = Type.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseType_ListType();
+        message.elemType = object.elemType !== undefined && object.elemType !== null ? Type.fromPartial(object.elemType) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseType_ListType();
+        if (object.elem_type !== undefined && object.elem_type !== null) {
+            message.elemType = Type.fromAmino(object.elem_type);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.elem_type = message.elemType ? Type.toAmino(message.elemType) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Type_ListType.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Type_ListType.decode(message.value);
+    },
+    toProto(message) {
+        return Type_ListType.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.ListType",
+            value: Type_ListType.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Type_ListType.typeUrl)) {
+            return;
+        }
+        Type.registerTypeUrl();
+    }
+};
+function createBaseType_MapType() {
+    return {
+        keyType: undefined,
+        valueType: undefined
+    };
+}
+/**
+ * Map type with parameterized key and value types, e.g. `map<string, int>`.
+ * @name Type_MapType
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.MapType
+ */
+export const Type_MapType = {
+    typeUrl: "/google.api.expr.v1alpha1.MapType",
+    is(o) {
+        return o && o.$typeUrl === Type_MapType.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === Type_MapType.typeUrl;
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.keyType !== undefined) {
+            Type.encode(message.keyType, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.valueType !== undefined) {
+            Type.encode(message.valueType, 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 = createBaseType_MapType();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.keyType = Type.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.valueType = Type.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseType_MapType();
+        message.keyType = object.keyType !== undefined && object.keyType !== null ? Type.fromPartial(object.keyType) : undefined;
+        message.valueType = object.valueType !== undefined && object.valueType !== null ? Type.fromPartial(object.valueType) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseType_MapType();
+        if (object.key_type !== undefined && object.key_type !== null) {
+            message.keyType = Type.fromAmino(object.key_type);
+        }
+        if (object.value_type !== undefined && object.value_type !== null) {
+            message.valueType = Type.fromAmino(object.value_type);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key_type = message.keyType ? Type.toAmino(message.keyType) : undefined;
+        obj.value_type = message.valueType ? Type.toAmino(message.valueType) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Type_MapType.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Type_MapType.decode(message.value);
+    },
+    toProto(message) {
+        return Type_MapType.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.MapType",
+            value: Type_MapType.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Type_MapType.typeUrl)) {
+            return;
+        }
+        Type.registerTypeUrl();
+    }
+};
+function createBaseType_FunctionType() {
+    return {
+        resultType: undefined,
+        argTypes: []
+    };
+}
+/**
+ * Function type with result and arg types.
+ * @name Type_FunctionType
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.FunctionType
+ */
+export const Type_FunctionType = {
+    typeUrl: "/google.api.expr.v1alpha1.FunctionType",
+    is(o) {
+        return o && (o.$typeUrl === Type_FunctionType.typeUrl || Array.isArray(o.argTypes) && (!o.argTypes.length || Type.is(o.argTypes[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Type_FunctionType.typeUrl || Array.isArray(o.arg_types) && (!o.arg_types.length || Type.isAmino(o.arg_types[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.resultType !== undefined) {
+            Type.encode(message.resultType, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.argTypes) {
+            Type.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 = createBaseType_FunctionType();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.resultType = Type.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.argTypes.push(Type.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseType_FunctionType();
+        message.resultType = object.resultType !== undefined && object.resultType !== null ? Type.fromPartial(object.resultType) : undefined;
+        message.argTypes = object.argTypes?.map(e => Type.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseType_FunctionType();
+        if (object.result_type !== undefined && object.result_type !== null) {
+            message.resultType = Type.fromAmino(object.result_type);
+        }
+        message.argTypes = object.arg_types?.map(e => Type.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.result_type = message.resultType ? Type.toAmino(message.resultType) : undefined;
+        if (message.argTypes) {
+            obj.arg_types = message.argTypes.map(e => e ? Type.toAmino(e) : undefined);
+        }
+        else {
+            obj.arg_types = message.argTypes;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Type_FunctionType.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Type_FunctionType.decode(message.value);
+    },
+    toProto(message) {
+        return Type_FunctionType.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.FunctionType",
+            value: Type_FunctionType.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Type_FunctionType.typeUrl)) {
+            return;
+        }
+        Type.registerTypeUrl();
+    }
+};
+function createBaseType_AbstractType() {
+    return {
+        name: "",
+        parameterTypes: []
+    };
+}
+/**
+ * Application defined abstract type.
+ * @name Type_AbstractType
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.AbstractType
+ */
+export const Type_AbstractType = {
+    typeUrl: "/google.api.expr.v1alpha1.AbstractType",
+    is(o) {
+        return o && (o.$typeUrl === Type_AbstractType.typeUrl || typeof o.name === "string" && Array.isArray(o.parameterTypes) && (!o.parameterTypes.length || Type.is(o.parameterTypes[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Type_AbstractType.typeUrl || typeof o.name === "string" && Array.isArray(o.parameter_types) && (!o.parameter_types.length || Type.isAmino(o.parameter_types[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        for (const v of message.parameterTypes) {
+            Type.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 = createBaseType_AbstractType();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.parameterTypes.push(Type.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseType_AbstractType();
+        message.name = object.name ?? "";
+        message.parameterTypes = object.parameterTypes?.map(e => Type.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseType_AbstractType();
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        message.parameterTypes = object.parameter_types?.map(e => Type.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name === "" ? undefined : message.name;
+        if (message.parameterTypes) {
+            obj.parameter_types = message.parameterTypes.map(e => e ? Type.toAmino(e) : undefined);
+        }
+        else {
+            obj.parameter_types = message.parameterTypes;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Type_AbstractType.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Type_AbstractType.decode(message.value);
+    },
+    toProto(message) {
+        return Type_AbstractType.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.AbstractType",
+            value: Type_AbstractType.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Type_AbstractType.typeUrl)) {
+            return;
+        }
+        Type.registerTypeUrl();
+    }
+};
+function createBaseDecl() {
+    return {
+        name: "",
+        ident: undefined,
+        function: undefined
+    };
+}
+/**
+ * Represents a declaration of a named value or function.
+ *
+ * A declaration is part of the contract between the expression, the agent
+ * evaluating that expression, and the caller requesting evaluation.
+ * @name Decl
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Decl
+ */
+export const Decl = {
+    typeUrl: "/google.api.expr.v1alpha1.Decl",
+    is(o) {
+        return o && (o.$typeUrl === Decl.typeUrl || typeof o.name === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Decl.typeUrl || typeof o.name === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.ident !== undefined) {
+            Decl_IdentDecl.encode(message.ident, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.function !== undefined) {
+            Decl_FunctionDecl.encode(message.function, 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 = createBaseDecl();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.ident = Decl_IdentDecl.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.function = Decl_FunctionDecl.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDecl();
+        message.name = object.name ?? "";
+        message.ident = object.ident !== undefined && object.ident !== null ? Decl_IdentDecl.fromPartial(object.ident) : undefined;
+        message.function = object.function !== undefined && object.function !== null ? Decl_FunctionDecl.fromPartial(object.function) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDecl();
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.ident !== undefined && object.ident !== null) {
+            message.ident = Decl_IdentDecl.fromAmino(object.ident);
+        }
+        if (object.function !== undefined && object.function !== null) {
+            message.function = Decl_FunctionDecl.fromAmino(object.function);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name === "" ? undefined : message.name;
+        obj.ident = message.ident ? Decl_IdentDecl.toAmino(message.ident) : undefined;
+        obj.function = message.function ? Decl_FunctionDecl.toAmino(message.function) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Decl.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Decl.decode(message.value);
+    },
+    toProto(message) {
+        return Decl.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.Decl",
+            value: Decl.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Decl.typeUrl)) {
+            return;
+        }
+        Decl_IdentDecl.registerTypeUrl();
+        Decl_FunctionDecl.registerTypeUrl();
+    }
+};
+function createBaseDecl_IdentDecl() {
+    return {
+        type: undefined,
+        value: undefined,
+        doc: ""
+    };
+}
+/**
+ * Identifier declaration which specifies its type and optional `Expr` value.
+ *
+ * An identifier without a value is a declaration that must be provided at
+ * evaluation time. An identifier with a value should resolve to a constant,
+ * but may be used in conjunction with other identifiers bound at evaluation
+ * time.
+ * @name Decl_IdentDecl
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.IdentDecl
+ */
+export const Decl_IdentDecl = {
+    typeUrl: "/google.api.expr.v1alpha1.IdentDecl",
+    is(o) {
+        return o && (o.$typeUrl === Decl_IdentDecl.typeUrl || typeof o.doc === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Decl_IdentDecl.typeUrl || typeof o.doc === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.type !== undefined) {
+            Type.encode(message.type, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.value !== undefined) {
+            Constant.encode(message.value, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.doc !== "") {
+            writer.uint32(26).string(message.doc);
+        }
+        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 = createBaseDecl_IdentDecl();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.type = Type.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.value = Constant.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.doc = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDecl_IdentDecl();
+        message.type = object.type !== undefined && object.type !== null ? Type.fromPartial(object.type) : undefined;
+        message.value = object.value !== undefined && object.value !== null ? Constant.fromPartial(object.value) : undefined;
+        message.doc = object.doc ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDecl_IdentDecl();
+        if (object.type !== undefined && object.type !== null) {
+            message.type = Type.fromAmino(object.type);
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = Constant.fromAmino(object.value);
+        }
+        if (object.doc !== undefined && object.doc !== null) {
+            message.doc = object.doc;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.type = message.type ? Type.toAmino(message.type) : undefined;
+        obj.value = message.value ? Constant.toAmino(message.value) : undefined;
+        obj.doc = message.doc === "" ? undefined : message.doc;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Decl_IdentDecl.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Decl_IdentDecl.decode(message.value);
+    },
+    toProto(message) {
+        return Decl_IdentDecl.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.IdentDecl",
+            value: Decl_IdentDecl.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Decl_IdentDecl.typeUrl)) {
+            return;
+        }
+        Type.registerTypeUrl();
+        Constant.registerTypeUrl();
+    }
+};
+function createBaseDecl_FunctionDecl() {
+    return {
+        overloads: []
+    };
+}
+/**
+ * Function declaration specifies one or more overloads which indicate the
+ * function's parameter types and return type.
+ *
+ * Functions have no observable side-effects (there may be side-effects like
+ * logging which are not observable from CEL).
+ * @name Decl_FunctionDecl
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.FunctionDecl
+ */
+export const Decl_FunctionDecl = {
+    typeUrl: "/google.api.expr.v1alpha1.FunctionDecl",
+    is(o) {
+        return o && (o.$typeUrl === Decl_FunctionDecl.typeUrl || Array.isArray(o.overloads) && (!o.overloads.length || Decl_FunctionDecl_Overload.is(o.overloads[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Decl_FunctionDecl.typeUrl || Array.isArray(o.overloads) && (!o.overloads.length || Decl_FunctionDecl_Overload.isAmino(o.overloads[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.overloads) {
+            Decl_FunctionDecl_Overload.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 = createBaseDecl_FunctionDecl();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.overloads.push(Decl_FunctionDecl_Overload.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDecl_FunctionDecl();
+        message.overloads = object.overloads?.map(e => Decl_FunctionDecl_Overload.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDecl_FunctionDecl();
+        message.overloads = object.overloads?.map(e => Decl_FunctionDecl_Overload.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.overloads) {
+            obj.overloads = message.overloads.map(e => e ? Decl_FunctionDecl_Overload.toAmino(e) : undefined);
+        }
+        else {
+            obj.overloads = message.overloads;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Decl_FunctionDecl.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Decl_FunctionDecl.decode(message.value);
+    },
+    toProto(message) {
+        return Decl_FunctionDecl.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.FunctionDecl",
+            value: Decl_FunctionDecl.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Decl_FunctionDecl.typeUrl)) {
+            return;
+        }
+        Decl_FunctionDecl_Overload.registerTypeUrl();
+    }
+};
+function createBaseDecl_FunctionDecl_Overload() {
+    return {
+        overloadId: "",
+        params: [],
+        typeParams: [],
+        resultType: undefined,
+        isInstanceFunction: false,
+        doc: ""
+    };
+}
+/**
+ * An overload indicates a function's parameter types and return type, and
+ * may optionally include a function body described in terms of
+ * [Expr][google.api.expr.v1alpha1.Expr] values.
+ *
+ * Functions overloads are declared in either a function or method
+ * call-style. For methods, the `params[0]` is the expected type of the
+ * target receiver.
+ *
+ * Overloads must have non-overlapping argument types after erasure of all
+ * parameterized type variables (similar as type erasure in Java).
+ * @name Decl_FunctionDecl_Overload
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Overload
+ */
+export const Decl_FunctionDecl_Overload = {
+    typeUrl: "/google.api.expr.v1alpha1.Overload",
+    is(o) {
+        return o && (o.$typeUrl === Decl_FunctionDecl_Overload.typeUrl || typeof o.overloadId === "string" && Array.isArray(o.params) && (!o.params.length || Type.is(o.params[0])) && Array.isArray(o.typeParams) && (!o.typeParams.length || typeof o.typeParams[0] === "string") && typeof o.isInstanceFunction === "boolean" && typeof o.doc === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Decl_FunctionDecl_Overload.typeUrl || typeof o.overload_id === "string" && Array.isArray(o.params) && (!o.params.length || Type.isAmino(o.params[0])) && Array.isArray(o.type_params) && (!o.type_params.length || typeof o.type_params[0] === "string") && typeof o.is_instance_function === "boolean" && typeof o.doc === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.overloadId !== "") {
+            writer.uint32(10).string(message.overloadId);
+        }
+        for (const v of message.params) {
+            Type.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.typeParams) {
+            writer.uint32(26).string(v);
+        }
+        if (message.resultType !== undefined) {
+            Type.encode(message.resultType, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.isInstanceFunction === true) {
+            writer.uint32(40).bool(message.isInstanceFunction);
+        }
+        if (message.doc !== "") {
+            writer.uint32(50).string(message.doc);
+        }
+        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 = createBaseDecl_FunctionDecl_Overload();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.overloadId = reader.string();
+                    break;
+                case 2:
+                    message.params.push(Type.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.typeParams.push(reader.string());
+                    break;
+                case 4:
+                    message.resultType = Type.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.isInstanceFunction = reader.bool();
+                    break;
+                case 6:
+                    message.doc = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDecl_FunctionDecl_Overload();
+        message.overloadId = object.overloadId ?? "";
+        message.params = object.params?.map(e => Type.fromPartial(e)) || [];
+        message.typeParams = object.typeParams?.map(e => e) || [];
+        message.resultType = object.resultType !== undefined && object.resultType !== null ? Type.fromPartial(object.resultType) : undefined;
+        message.isInstanceFunction = object.isInstanceFunction ?? false;
+        message.doc = object.doc ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDecl_FunctionDecl_Overload();
+        if (object.overload_id !== undefined && object.overload_id !== null) {
+            message.overloadId = object.overload_id;
+        }
+        message.params = object.params?.map(e => Type.fromAmino(e)) || [];
+        message.typeParams = object.type_params?.map(e => e) || [];
+        if (object.result_type !== undefined && object.result_type !== null) {
+            message.resultType = Type.fromAmino(object.result_type);
+        }
+        if (object.is_instance_function !== undefined && object.is_instance_function !== null) {
+            message.isInstanceFunction = object.is_instance_function;
+        }
+        if (object.doc !== undefined && object.doc !== null) {
+            message.doc = object.doc;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.overload_id = message.overloadId === "" ? undefined : message.overloadId;
+        if (message.params) {
+            obj.params = message.params.map(e => e ? Type.toAmino(e) : undefined);
+        }
+        else {
+            obj.params = message.params;
+        }
+        if (message.typeParams) {
+            obj.type_params = message.typeParams.map(e => e);
+        }
+        else {
+            obj.type_params = message.typeParams;
+        }
+        obj.result_type = message.resultType ? Type.toAmino(message.resultType) : undefined;
+        obj.is_instance_function = message.isInstanceFunction === false ? undefined : message.isInstanceFunction;
+        obj.doc = message.doc === "" ? undefined : message.doc;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Decl_FunctionDecl_Overload.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Decl_FunctionDecl_Overload.decode(message.value);
+    },
+    toProto(message) {
+        return Decl_FunctionDecl_Overload.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.Overload",
+            value: Decl_FunctionDecl_Overload.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Decl_FunctionDecl_Overload.typeUrl)) {
+            return;
+        }
+        Type.registerTypeUrl();
+    }
+};
+function createBaseReference() {
+    return {
+        name: "",
+        overloadId: [],
+        value: undefined
+    };
+}
+/**
+ * Describes a resolved reference to a declaration.
+ * @name Reference
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Reference
+ */
+export const Reference = {
+    typeUrl: "/google.api.expr.v1alpha1.Reference",
+    is(o) {
+        return o && (o.$typeUrl === Reference.typeUrl || typeof o.name === "string" && Array.isArray(o.overloadId) && (!o.overloadId.length || typeof o.overloadId[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Reference.typeUrl || typeof o.name === "string" && Array.isArray(o.overload_id) && (!o.overload_id.length || typeof o.overload_id[0] === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        for (const v of message.overloadId) {
+            writer.uint32(26).string(v);
+        }
+        if (message.value !== undefined) {
+            Constant.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 = createBaseReference();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 3:
+                    message.overloadId.push(reader.string());
+                    break;
+                case 4:
+                    message.value = Constant.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseReference();
+        message.name = object.name ?? "";
+        message.overloadId = object.overloadId?.map(e => e) || [];
+        message.value = object.value !== undefined && object.value !== null ? Constant.fromPartial(object.value) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseReference();
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        message.overloadId = object.overload_id?.map(e => e) || [];
+        if (object.value !== undefined && object.value !== null) {
+            message.value = Constant.fromAmino(object.value);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name === "" ? undefined : message.name;
+        if (message.overloadId) {
+            obj.overload_id = message.overloadId.map(e => e);
+        }
+        else {
+            obj.overload_id = message.overloadId;
+        }
+        obj.value = message.value ? Constant.toAmino(message.value) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Reference.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Reference.decode(message.value);
+    },
+    toProto(message) {
+        return Reference.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.Reference",
+            value: Reference.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Reference.typeUrl)) {
+            return;
+        }
+        Constant.registerTypeUrl();
+    }
+};