@0xkaleab/sdk-js 0.2.7

package/dist/cjs/codegen/google/api/expr/v1alpha1/value.js

@@ -0,0 +1,579 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapValue_Entry = exports.MapValue = exports.ListValue = exports.EnumValue = exports.Value = void 0;
+const any_1 = require("../../../protobuf/any");
+const binary_1 = require("../../../../binary");
+const registry_1 = require("../../../../registry");
+const helpers_1 = require("../../../../helpers");
+function createBaseValue() {
+    return {
+        nullValue: undefined,
+        boolValue: undefined,
+        int64Value: undefined,
+        uint64Value: undefined,
+        doubleValue: undefined,
+        stringValue: undefined,
+        bytesValue: undefined,
+        enumValue: undefined,
+        objectValue: undefined,
+        mapValue: undefined,
+        listValue: undefined,
+        typeValue: undefined
+    };
+}
+/**
+ * Represents a CEL value.
+ *
+ * This is similar to `google.protobuf.Value`, but can represent CEL's full
+ * range of values.
+ * @name Value
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Value
+ */
+exports.Value = {
+    typeUrl: "/google.api.expr.v1alpha1.Value",
+    is(o) {
+        return o && o.$typeUrl === exports.Value.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.Value.typeUrl;
+    },
+    encode(message, writer = binary_1.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.enumValue !== undefined) {
+            exports.EnumValue.encode(message.enumValue, writer.uint32(74).fork()).ldelim();
+        }
+        if (message.objectValue !== undefined) {
+            any_1.Any.encode(message.objectValue, writer.uint32(82).fork()).ldelim();
+        }
+        if (message.mapValue !== undefined) {
+            exports.MapValue.encode(message.mapValue, writer.uint32(90).fork()).ldelim();
+        }
+        if (message.listValue !== undefined) {
+            exports.ListValue.encode(message.listValue, writer.uint32(98).fork()).ldelim();
+        }
+        if (message.typeValue !== undefined) {
+            writer.uint32(122).string(message.typeValue);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseValue();
+        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 9:
+                    message.enumValue = exports.EnumValue.decode(reader, reader.uint32());
+                    break;
+                case 10:
+                    message.objectValue = any_1.Any.decode(reader, reader.uint32());
+                    break;
+                case 11:
+                    message.mapValue = exports.MapValue.decode(reader, reader.uint32());
+                    break;
+                case 12:
+                    message.listValue = exports.ListValue.decode(reader, reader.uint32());
+                    break;
+                case 15:
+                    message.typeValue = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseValue();
+        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.enumValue = object.enumValue !== undefined && object.enumValue !== null ? exports.EnumValue.fromPartial(object.enumValue) : undefined;
+        message.objectValue = object.objectValue !== undefined && object.objectValue !== null ? any_1.Any.fromPartial(object.objectValue) : undefined;
+        message.mapValue = object.mapValue !== undefined && object.mapValue !== null ? exports.MapValue.fromPartial(object.mapValue) : undefined;
+        message.listValue = object.listValue !== undefined && object.listValue !== null ? exports.ListValue.fromPartial(object.listValue) : undefined;
+        message.typeValue = object.typeValue ?? undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseValue();
+        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 = (0, helpers_1.bytesFromBase64)(object.bytes_value);
+        }
+        if (object.enum_value !== undefined && object.enum_value !== null) {
+            message.enumValue = exports.EnumValue.fromAmino(object.enum_value);
+        }
+        if (object.object_value !== undefined && object.object_value !== null) {
+            message.objectValue = any_1.Any.fromAmino(object.object_value);
+        }
+        if (object.map_value !== undefined && object.map_value !== null) {
+            message.mapValue = exports.MapValue.fromAmino(object.map_value);
+        }
+        if (object.list_value !== undefined && object.list_value !== null) {
+            message.listValue = exports.ListValue.fromAmino(object.list_value);
+        }
+        if (object.type_value !== undefined && object.type_value !== null) {
+            message.typeValue = object.type_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 ? (0, helpers_1.base64FromBytes)(message.bytesValue) : undefined;
+        obj.enum_value = message.enumValue ? exports.EnumValue.toAmino(message.enumValue) : undefined;
+        obj.object_value = message.objectValue ? any_1.Any.toAmino(message.objectValue) : undefined;
+        obj.map_value = message.mapValue ? exports.MapValue.toAmino(message.mapValue) : undefined;
+        obj.list_value = message.listValue ? exports.ListValue.toAmino(message.listValue) : undefined;
+        obj.type_value = message.typeValue === null ? undefined : message.typeValue;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Value.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Value.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Value.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.Value",
+            value: exports.Value.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.Value.typeUrl)) {
+            return;
+        }
+        exports.MapValue.registerTypeUrl();
+        exports.ListValue.registerTypeUrl();
+    }
+};
+function createBaseEnumValue() {
+    return {
+        type: "",
+        value: 0
+    };
+}
+/**
+ * An enum value.
+ * @name EnumValue
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.EnumValue
+ */
+exports.EnumValue = {
+    typeUrl: "/google.api.expr.v1alpha1.EnumValue",
+    is(o) {
+        return o && (o.$typeUrl === exports.EnumValue.typeUrl || typeof o.type === "string" && typeof o.value === "number");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.EnumValue.typeUrl || typeof o.type === "string" && typeof o.value === "number");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.type !== "") {
+            writer.uint32(10).string(message.type);
+        }
+        if (message.value !== 0) {
+            writer.uint32(16).int32(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEnumValue();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.type = reader.string();
+                    break;
+                case 2:
+                    message.value = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseEnumValue();
+        message.type = object.type ?? "";
+        message.value = object.value ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseEnumValue();
+        if (object.type !== undefined && object.type !== null) {
+            message.type = object.type;
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = object.value;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.type = message.type === "" ? undefined : message.type;
+        obj.value = message.value === 0 ? undefined : message.value;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.EnumValue.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.EnumValue.decode(message.value);
+    },
+    toProto(message) {
+        return exports.EnumValue.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.EnumValue",
+            value: exports.EnumValue.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseListValue() {
+    return {
+        values: []
+    };
+}
+/**
+ * A list.
+ *
+ * Wrapped in a message so 'not set' and empty can be differentiated, which is
+ * required for use in a 'oneof'.
+ * @name ListValue
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.ListValue
+ */
+exports.ListValue = {
+    typeUrl: "/google.api.expr.v1alpha1.ListValue",
+    is(o) {
+        return o && (o.$typeUrl === exports.ListValue.typeUrl || Array.isArray(o.values) && (!o.values.length || exports.Value.is(o.values[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.ListValue.typeUrl || Array.isArray(o.values) && (!o.values.length || exports.Value.isAmino(o.values[0])));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.values) {
+            exports.Value.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseListValue();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.values.push(exports.Value.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseListValue();
+        message.values = object.values?.map(e => exports.Value.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseListValue();
+        message.values = object.values?.map(e => exports.Value.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.values) {
+            obj.values = message.values.map(e => e ? exports.Value.toAmino(e) : undefined);
+        }
+        else {
+            obj.values = message.values;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ListValue.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.ListValue.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ListValue.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.ListValue",
+            value: exports.ListValue.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.ListValue.typeUrl)) {
+            return;
+        }
+        exports.Value.registerTypeUrl();
+    }
+};
+function createBaseMapValue() {
+    return {
+        entries: []
+    };
+}
+/**
+ * A map.
+ *
+ * Wrapped in a message so 'not set' and empty can be differentiated, which is
+ * required for use in a 'oneof'.
+ * @name MapValue
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.MapValue
+ */
+exports.MapValue = {
+    typeUrl: "/google.api.expr.v1alpha1.MapValue",
+    is(o) {
+        return o && (o.$typeUrl === exports.MapValue.typeUrl || Array.isArray(o.entries) && (!o.entries.length || exports.MapValue_Entry.is(o.entries[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.MapValue.typeUrl || Array.isArray(o.entries) && (!o.entries.length || exports.MapValue_Entry.isAmino(o.entries[0])));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.entries) {
+            exports.MapValue_Entry.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMapValue();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.entries.push(exports.MapValue_Entry.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMapValue();
+        message.entries = object.entries?.map(e => exports.MapValue_Entry.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMapValue();
+        message.entries = object.entries?.map(e => exports.MapValue_Entry.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.entries) {
+            obj.entries = message.entries.map(e => e ? exports.MapValue_Entry.toAmino(e) : undefined);
+        }
+        else {
+            obj.entries = message.entries;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MapValue.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.MapValue.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MapValue.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.MapValue",
+            value: exports.MapValue.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.MapValue.typeUrl)) {
+            return;
+        }
+        exports.MapValue_Entry.registerTypeUrl();
+    }
+};
+function createBaseMapValue_Entry() {
+    return {
+        key: undefined,
+        value: undefined
+    };
+}
+/**
+ * An entry in the map.
+ * @name MapValue_Entry
+ * @package google.api.expr.v1alpha1
+ * @see proto type: google.api.expr.v1alpha1.Entry
+ */
+exports.MapValue_Entry = {
+    typeUrl: "/google.api.expr.v1alpha1.Entry",
+    is(o) {
+        return o && o.$typeUrl === exports.MapValue_Entry.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.MapValue_Entry.typeUrl;
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.key !== undefined) {
+            exports.Value.encode(message.key, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.value !== undefined) {
+            exports.Value.encode(message.value, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMapValue_Entry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = exports.Value.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.value = exports.Value.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMapValue_Entry();
+        message.key = object.key !== undefined && object.key !== null ? exports.Value.fromPartial(object.key) : undefined;
+        message.value = object.value !== undefined && object.value !== null ? exports.Value.fromPartial(object.value) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMapValue_Entry();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = exports.Value.fromAmino(object.key);
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = exports.Value.fromAmino(object.value);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? exports.Value.toAmino(message.key) : undefined;
+        obj.value = message.value ? exports.Value.toAmino(message.value) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MapValue_Entry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.MapValue_Entry.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MapValue_Entry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.expr.v1alpha1.Entry",
+            value: exports.MapValue_Entry.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.MapValue_Entry.typeUrl)) {
+            return;
+        }
+        exports.Value.registerTypeUrl();
+    }
+};