@0xkaleab/sdk-js 0.2.7

package/dist/esm/codegen/google/rpc/error_details.js

@@ -0,0 +1,1605 @@
+// @ts-nocheck
+/* eslint-disable */
+import { Duration } from "../protobuf/duration";
+import { BinaryReader, BinaryWriter } from "../../binary";
+import { isSet } from "../../helpers";
+import { GlobalDecoderRegistry } from "../../registry";
+function createBaseErrorInfo_MetadataEntry() {
+    return {
+        key: "",
+        value: ""
+    };
+}
+/**
+ * @name ErrorInfo_MetadataEntry
+ * @package google.rpc
+ * @see proto type: google.rpc.undefined
+ */
+export const ErrorInfo_MetadataEntry = {
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(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 = createBaseErrorInfo_MetadataEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.value = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseErrorInfo_MetadataEntry();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseErrorInfo_MetadataEntry();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = object.key;
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = object.value;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key === "" ? undefined : message.key;
+        obj.value = message.value === "" ? undefined : message.value;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ErrorInfo_MetadataEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ErrorInfo_MetadataEntry.decode(message.value);
+    },
+    toProto(message) {
+        return ErrorInfo_MetadataEntry.encode(message).finish();
+    },
+    registerTypeUrl() { }
+};
+function createBaseErrorInfo() {
+    return {
+        reason: "",
+        domain: "",
+        metadata: {}
+    };
+}
+/**
+ * Describes the cause of the error with structured details.
+ *
+ * Example of an error when contacting the "pubsub.googleapis.com" API when it
+ * is not enabled:
+ *
+ *     { "reason": "API_DISABLED"
+ *       "domain": "googleapis.com"
+ *       "metadata": {
+ *         "resource": "projects/123",
+ *         "service": "pubsub.googleapis.com"
+ *       }
+ *     }
+ *
+ * This response indicates that the pubsub.googleapis.com API is not enabled.
+ *
+ * Example of an error that is returned when attempting to create a Spanner
+ * instance in a region that is out of stock:
+ *
+ *     { "reason": "STOCKOUT"
+ *       "domain": "spanner.googleapis.com",
+ *       "metadata": {
+ *         "availableRegions": "us-central1,us-east2"
+ *       }
+ *     }
+ * @name ErrorInfo
+ * @package google.rpc
+ * @see proto type: google.rpc.ErrorInfo
+ */
+export const ErrorInfo = {
+    typeUrl: "/google.rpc.ErrorInfo",
+    is(o) {
+        return o && (o.$typeUrl === ErrorInfo.typeUrl || typeof o.reason === "string" && typeof o.domain === "string" && isSet(o.metadata));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === ErrorInfo.typeUrl || typeof o.reason === "string" && typeof o.domain === "string" && isSet(o.metadata));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.reason !== "") {
+            writer.uint32(10).string(message.reason);
+        }
+        if (message.domain !== "") {
+            writer.uint32(18).string(message.domain);
+        }
+        Object.entries(message.metadata).forEach(([key, value]) => {
+            ErrorInfo_MetadataEntry.encode({
+                key: key,
+                value
+            }, 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 = createBaseErrorInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.reason = reader.string();
+                    break;
+                case 2:
+                    message.domain = reader.string();
+                    break;
+                case 3:
+                    const entry3 = ErrorInfo_MetadataEntry.decode(reader, reader.uint32());
+                    if (entry3.value !== undefined) {
+                        message.metadata[entry3.key] = entry3.value;
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseErrorInfo();
+        message.reason = object.reason ?? "";
+        message.domain = object.domain ?? "";
+        message.metadata = Object.entries(object.metadata ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = String(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseErrorInfo();
+        if (object.reason !== undefined && object.reason !== null) {
+            message.reason = object.reason;
+        }
+        if (object.domain !== undefined && object.domain !== null) {
+            message.domain = object.domain;
+        }
+        message.metadata = Object.entries(object.metadata ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = String(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.reason = message.reason === "" ? undefined : message.reason;
+        obj.domain = message.domain === "" ? undefined : message.domain;
+        obj.metadata = {};
+        if (message.metadata) {
+            Object.entries(message.metadata).forEach(([k, v]) => {
+                obj.metadata[k] = v;
+            });
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ErrorInfo.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ErrorInfo.decode(message.value);
+    },
+    toProto(message) {
+        return ErrorInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.ErrorInfo",
+            value: ErrorInfo.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseRetryInfo() {
+    return {
+        retryDelay: undefined
+    };
+}
+/**
+ * Describes when the clients can retry a failed request. Clients could ignore
+ * the recommendation here or retry when this information is missing from error
+ * responses.
+ *
+ * It's always recommended that clients should use exponential backoff when
+ * retrying.
+ *
+ * Clients should wait until `retry_delay` amount of time has passed since
+ * receiving the error response before retrying.  If retrying requests also
+ * fail, clients should use an exponential backoff scheme to gradually increase
+ * the delay between retries based on `retry_delay`, until either a maximum
+ * number of retries have been reached or a maximum retry delay cap has been
+ * reached.
+ * @name RetryInfo
+ * @package google.rpc
+ * @see proto type: google.rpc.RetryInfo
+ */
+export const RetryInfo = {
+    typeUrl: "/google.rpc.RetryInfo",
+    is(o) {
+        return o && o.$typeUrl === RetryInfo.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === RetryInfo.typeUrl;
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.retryDelay !== undefined) {
+            Duration.encode(message.retryDelay, 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 = createBaseRetryInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.retryDelay = Duration.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRetryInfo();
+        message.retryDelay = object.retryDelay !== undefined && object.retryDelay !== null ? Duration.fromPartial(object.retryDelay) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRetryInfo();
+        if (object.retry_delay !== undefined && object.retry_delay !== null) {
+            message.retryDelay = Duration.fromAmino(object.retry_delay);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.retry_delay = message.retryDelay ? Duration.toAmino(message.retryDelay) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return RetryInfo.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return RetryInfo.decode(message.value);
+    },
+    toProto(message) {
+        return RetryInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.RetryInfo",
+            value: RetryInfo.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseDebugInfo() {
+    return {
+        stackEntries: [],
+        detail: ""
+    };
+}
+/**
+ * Describes additional debugging info.
+ * @name DebugInfo
+ * @package google.rpc
+ * @see proto type: google.rpc.DebugInfo
+ */
+export const DebugInfo = {
+    typeUrl: "/google.rpc.DebugInfo",
+    is(o) {
+        return o && (o.$typeUrl === DebugInfo.typeUrl || Array.isArray(o.stackEntries) && (!o.stackEntries.length || typeof o.stackEntries[0] === "string") && typeof o.detail === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === DebugInfo.typeUrl || Array.isArray(o.stack_entries) && (!o.stack_entries.length || typeof o.stack_entries[0] === "string") && typeof o.detail === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.stackEntries) {
+            writer.uint32(10).string(v);
+        }
+        if (message.detail !== "") {
+            writer.uint32(18).string(message.detail);
+        }
+        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 = createBaseDebugInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.stackEntries.push(reader.string());
+                    break;
+                case 2:
+                    message.detail = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDebugInfo();
+        message.stackEntries = object.stackEntries?.map(e => e) || [];
+        message.detail = object.detail ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDebugInfo();
+        message.stackEntries = object.stack_entries?.map(e => e) || [];
+        if (object.detail !== undefined && object.detail !== null) {
+            message.detail = object.detail;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.stackEntries) {
+            obj.stack_entries = message.stackEntries.map(e => e);
+        }
+        else {
+            obj.stack_entries = message.stackEntries;
+        }
+        obj.detail = message.detail === "" ? undefined : message.detail;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return DebugInfo.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return DebugInfo.decode(message.value);
+    },
+    toProto(message) {
+        return DebugInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.DebugInfo",
+            value: DebugInfo.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseQuotaFailure() {
+    return {
+        violations: []
+    };
+}
+/**
+ * Describes how a quota check failed.
+ *
+ * For example if a daily limit was exceeded for the calling project,
+ * a service could respond with a QuotaFailure detail containing the project
+ * id and the description of the quota limit that was exceeded.  If the
+ * calling project hasn't enabled the service in the developer console, then
+ * a service could respond with the project id and set `service_disabled`
+ * to true.
+ *
+ * Also see RetryInfo and Help types for other details about handling a
+ * quota failure.
+ * @name QuotaFailure
+ * @package google.rpc
+ * @see proto type: google.rpc.QuotaFailure
+ */
+export const QuotaFailure = {
+    typeUrl: "/google.rpc.QuotaFailure",
+    is(o) {
+        return o && (o.$typeUrl === QuotaFailure.typeUrl || Array.isArray(o.violations) && (!o.violations.length || QuotaFailure_Violation.is(o.violations[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === QuotaFailure.typeUrl || Array.isArray(o.violations) && (!o.violations.length || QuotaFailure_Violation.isAmino(o.violations[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.violations) {
+            QuotaFailure_Violation.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 = createBaseQuotaFailure();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.violations.push(QuotaFailure_Violation.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQuotaFailure();
+        message.violations = object.violations?.map(e => QuotaFailure_Violation.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQuotaFailure();
+        message.violations = object.violations?.map(e => QuotaFailure_Violation.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.violations) {
+            obj.violations = message.violations.map(e => e ? QuotaFailure_Violation.toAmino(e) : undefined);
+        }
+        else {
+            obj.violations = message.violations;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QuotaFailure.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QuotaFailure.decode(message.value);
+    },
+    toProto(message) {
+        return QuotaFailure.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.QuotaFailure",
+            value: QuotaFailure.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QuotaFailure.typeUrl)) {
+            return;
+        }
+        QuotaFailure_Violation.registerTypeUrl();
+    }
+};
+function createBaseQuotaFailure_Violation_QuotaDimensionsEntry() {
+    return {
+        key: "",
+        value: ""
+    };
+}
+/**
+ * @name QuotaFailure_Violation_QuotaDimensionsEntry
+ * @package google.rpc
+ * @see proto type: google.rpc.undefined
+ */
+export const QuotaFailure_Violation_QuotaDimensionsEntry = {
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(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 = createBaseQuotaFailure_Violation_QuotaDimensionsEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.value = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQuotaFailure_Violation_QuotaDimensionsEntry();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQuotaFailure_Violation_QuotaDimensionsEntry();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = object.key;
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = object.value;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key === "" ? undefined : message.key;
+        obj.value = message.value === "" ? undefined : message.value;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QuotaFailure_Violation_QuotaDimensionsEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QuotaFailure_Violation_QuotaDimensionsEntry.decode(message.value);
+    },
+    toProto(message) {
+        return QuotaFailure_Violation_QuotaDimensionsEntry.encode(message).finish();
+    },
+    registerTypeUrl() { }
+};
+function createBaseQuotaFailure_Violation() {
+    return {
+        subject: "",
+        description: "",
+        apiService: "",
+        quotaMetric: "",
+        quotaId: "",
+        quotaDimensions: {},
+        quotaValue: BigInt(0),
+        futureQuotaValue: undefined
+    };
+}
+/**
+ * A message type used to describe a single quota violation.  For example, a
+ * daily quota or a custom quota that was exceeded.
+ * @name QuotaFailure_Violation
+ * @package google.rpc
+ * @see proto type: google.rpc.Violation
+ */
+export const QuotaFailure_Violation = {
+    typeUrl: "/google.rpc.Violation",
+    is(o) {
+        return o && (o.$typeUrl === QuotaFailure_Violation.typeUrl || typeof o.subject === "string" && typeof o.description === "string" && typeof o.apiService === "string" && typeof o.quotaMetric === "string" && typeof o.quotaId === "string" && isSet(o.quotaDimensions) && typeof o.quotaValue === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === QuotaFailure_Violation.typeUrl || typeof o.subject === "string" && typeof o.description === "string" && typeof o.api_service === "string" && typeof o.quota_metric === "string" && typeof o.quota_id === "string" && isSet(o.quota_dimensions) && typeof o.quota_value === "bigint");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.subject !== "") {
+            writer.uint32(10).string(message.subject);
+        }
+        if (message.description !== "") {
+            writer.uint32(18).string(message.description);
+        }
+        if (message.apiService !== "") {
+            writer.uint32(26).string(message.apiService);
+        }
+        if (message.quotaMetric !== "") {
+            writer.uint32(34).string(message.quotaMetric);
+        }
+        if (message.quotaId !== "") {
+            writer.uint32(42).string(message.quotaId);
+        }
+        Object.entries(message.quotaDimensions).forEach(([key, value]) => {
+            QuotaFailure_Violation_QuotaDimensionsEntry.encode({
+                key: key,
+                value
+            }, writer.uint32(50).fork()).ldelim();
+        });
+        if (message.quotaValue !== BigInt(0)) {
+            writer.uint32(56).int64(message.quotaValue);
+        }
+        if (message.futureQuotaValue !== undefined) {
+            writer.uint32(64).int64(message.futureQuotaValue);
+        }
+        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 = createBaseQuotaFailure_Violation();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.subject = reader.string();
+                    break;
+                case 2:
+                    message.description = reader.string();
+                    break;
+                case 3:
+                    message.apiService = reader.string();
+                    break;
+                case 4:
+                    message.quotaMetric = reader.string();
+                    break;
+                case 5:
+                    message.quotaId = reader.string();
+                    break;
+                case 6:
+                    const entry6 = QuotaFailure_Violation_QuotaDimensionsEntry.decode(reader, reader.uint32());
+                    if (entry6.value !== undefined) {
+                        message.quotaDimensions[entry6.key] = entry6.value;
+                    }
+                    break;
+                case 7:
+                    message.quotaValue = reader.int64();
+                    break;
+                case 8:
+                    message.futureQuotaValue = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQuotaFailure_Violation();
+        message.subject = object.subject ?? "";
+        message.description = object.description ?? "";
+        message.apiService = object.apiService ?? "";
+        message.quotaMetric = object.quotaMetric ?? "";
+        message.quotaId = object.quotaId ?? "";
+        message.quotaDimensions = Object.entries(object.quotaDimensions ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = String(value);
+            }
+            return acc;
+        }, {});
+        message.quotaValue = object.quotaValue !== undefined && object.quotaValue !== null ? BigInt(object.quotaValue.toString()) : BigInt(0);
+        message.futureQuotaValue = object.futureQuotaValue !== undefined && object.futureQuotaValue !== null ? BigInt(object.futureQuotaValue.toString()) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQuotaFailure_Violation();
+        if (object.subject !== undefined && object.subject !== null) {
+            message.subject = object.subject;
+        }
+        if (object.description !== undefined && object.description !== null) {
+            message.description = object.description;
+        }
+        if (object.api_service !== undefined && object.api_service !== null) {
+            message.apiService = object.api_service;
+        }
+        if (object.quota_metric !== undefined && object.quota_metric !== null) {
+            message.quotaMetric = object.quota_metric;
+        }
+        if (object.quota_id !== undefined && object.quota_id !== null) {
+            message.quotaId = object.quota_id;
+        }
+        message.quotaDimensions = Object.entries(object.quota_dimensions ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = String(value);
+            }
+            return acc;
+        }, {});
+        if (object.quota_value !== undefined && object.quota_value !== null) {
+            message.quotaValue = BigInt(object.quota_value);
+        }
+        if (object.future_quota_value !== undefined && object.future_quota_value !== null) {
+            message.futureQuotaValue = BigInt(object.future_quota_value);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.subject = message.subject === "" ? undefined : message.subject;
+        obj.description = message.description === "" ? undefined : message.description;
+        obj.api_service = message.apiService === "" ? undefined : message.apiService;
+        obj.quota_metric = message.quotaMetric === "" ? undefined : message.quotaMetric;
+        obj.quota_id = message.quotaId === "" ? undefined : message.quotaId;
+        obj.quota_dimensions = {};
+        if (message.quotaDimensions) {
+            Object.entries(message.quotaDimensions).forEach(([k, v]) => {
+                obj.quota_dimensions[k] = v;
+            });
+        }
+        obj.quota_value = message.quotaValue !== BigInt(0) ? message.quotaValue?.toString() : undefined;
+        obj.future_quota_value = message.futureQuotaValue !== BigInt(0) ? message.futureQuotaValue?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QuotaFailure_Violation.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QuotaFailure_Violation.decode(message.value);
+    },
+    toProto(message) {
+        return QuotaFailure_Violation.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.Violation",
+            value: QuotaFailure_Violation.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBasePreconditionFailure() {
+    return {
+        violations: []
+    };
+}
+/**
+ * Describes what preconditions have failed.
+ *
+ * For example, if an RPC failed because it required the Terms of Service to be
+ * acknowledged, it could list the terms of service violation in the
+ * PreconditionFailure message.
+ * @name PreconditionFailure
+ * @package google.rpc
+ * @see proto type: google.rpc.PreconditionFailure
+ */
+export const PreconditionFailure = {
+    typeUrl: "/google.rpc.PreconditionFailure",
+    is(o) {
+        return o && (o.$typeUrl === PreconditionFailure.typeUrl || Array.isArray(o.violations) && (!o.violations.length || PreconditionFailure_Violation.is(o.violations[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === PreconditionFailure.typeUrl || Array.isArray(o.violations) && (!o.violations.length || PreconditionFailure_Violation.isAmino(o.violations[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.violations) {
+            PreconditionFailure_Violation.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 = createBasePreconditionFailure();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.violations.push(PreconditionFailure_Violation.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePreconditionFailure();
+        message.violations = object.violations?.map(e => PreconditionFailure_Violation.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePreconditionFailure();
+        message.violations = object.violations?.map(e => PreconditionFailure_Violation.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.violations) {
+            obj.violations = message.violations.map(e => e ? PreconditionFailure_Violation.toAmino(e) : undefined);
+        }
+        else {
+            obj.violations = message.violations;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PreconditionFailure.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return PreconditionFailure.decode(message.value);
+    },
+    toProto(message) {
+        return PreconditionFailure.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.PreconditionFailure",
+            value: PreconditionFailure.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(PreconditionFailure.typeUrl)) {
+            return;
+        }
+        PreconditionFailure_Violation.registerTypeUrl();
+    }
+};
+function createBasePreconditionFailure_Violation() {
+    return {
+        type: "",
+        subject: "",
+        description: ""
+    };
+}
+/**
+ * A message type used to describe a single precondition failure.
+ * @name PreconditionFailure_Violation
+ * @package google.rpc
+ * @see proto type: google.rpc.Violation
+ */
+export const PreconditionFailure_Violation = {
+    typeUrl: "/google.rpc.Violation",
+    is(o) {
+        return o && (o.$typeUrl === PreconditionFailure_Violation.typeUrl || typeof o.type === "string" && typeof o.subject === "string" && typeof o.description === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === PreconditionFailure_Violation.typeUrl || typeof o.type === "string" && typeof o.subject === "string" && typeof o.description === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.type !== "") {
+            writer.uint32(10).string(message.type);
+        }
+        if (message.subject !== "") {
+            writer.uint32(18).string(message.subject);
+        }
+        if (message.description !== "") {
+            writer.uint32(26).string(message.description);
+        }
+        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 = createBasePreconditionFailure_Violation();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.type = reader.string();
+                    break;
+                case 2:
+                    message.subject = reader.string();
+                    break;
+                case 3:
+                    message.description = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePreconditionFailure_Violation();
+        message.type = object.type ?? "";
+        message.subject = object.subject ?? "";
+        message.description = object.description ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePreconditionFailure_Violation();
+        if (object.type !== undefined && object.type !== null) {
+            message.type = object.type;
+        }
+        if (object.subject !== undefined && object.subject !== null) {
+            message.subject = object.subject;
+        }
+        if (object.description !== undefined && object.description !== null) {
+            message.description = object.description;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.type = message.type === "" ? undefined : message.type;
+        obj.subject = message.subject === "" ? undefined : message.subject;
+        obj.description = message.description === "" ? undefined : message.description;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PreconditionFailure_Violation.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return PreconditionFailure_Violation.decode(message.value);
+    },
+    toProto(message) {
+        return PreconditionFailure_Violation.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.Violation",
+            value: PreconditionFailure_Violation.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseBadRequest() {
+    return {
+        fieldViolations: []
+    };
+}
+/**
+ * Describes violations in a client request. This error type focuses on the
+ * syntactic aspects of the request.
+ * @name BadRequest
+ * @package google.rpc
+ * @see proto type: google.rpc.BadRequest
+ */
+export const BadRequest = {
+    typeUrl: "/google.rpc.BadRequest",
+    is(o) {
+        return o && (o.$typeUrl === BadRequest.typeUrl || Array.isArray(o.fieldViolations) && (!o.fieldViolations.length || BadRequest_FieldViolation.is(o.fieldViolations[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === BadRequest.typeUrl || Array.isArray(o.field_violations) && (!o.field_violations.length || BadRequest_FieldViolation.isAmino(o.field_violations[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.fieldViolations) {
+            BadRequest_FieldViolation.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 = createBaseBadRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.fieldViolations.push(BadRequest_FieldViolation.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseBadRequest();
+        message.fieldViolations = object.fieldViolations?.map(e => BadRequest_FieldViolation.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseBadRequest();
+        message.fieldViolations = object.field_violations?.map(e => BadRequest_FieldViolation.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.fieldViolations) {
+            obj.field_violations = message.fieldViolations.map(e => e ? BadRequest_FieldViolation.toAmino(e) : undefined);
+        }
+        else {
+            obj.field_violations = message.fieldViolations;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return BadRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return BadRequest.decode(message.value);
+    },
+    toProto(message) {
+        return BadRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.BadRequest",
+            value: BadRequest.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(BadRequest.typeUrl)) {
+            return;
+        }
+        BadRequest_FieldViolation.registerTypeUrl();
+    }
+};
+function createBaseBadRequest_FieldViolation() {
+    return {
+        field: "",
+        description: "",
+        reason: "",
+        localizedMessage: undefined
+    };
+}
+/**
+ * A message type used to describe a single bad request field.
+ * @name BadRequest_FieldViolation
+ * @package google.rpc
+ * @see proto type: google.rpc.FieldViolation
+ */
+export const BadRequest_FieldViolation = {
+    typeUrl: "/google.rpc.FieldViolation",
+    is(o) {
+        return o && (o.$typeUrl === BadRequest_FieldViolation.typeUrl || typeof o.field === "string" && typeof o.description === "string" && typeof o.reason === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === BadRequest_FieldViolation.typeUrl || typeof o.field === "string" && typeof o.description === "string" && typeof o.reason === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.field !== "") {
+            writer.uint32(10).string(message.field);
+        }
+        if (message.description !== "") {
+            writer.uint32(18).string(message.description);
+        }
+        if (message.reason !== "") {
+            writer.uint32(26).string(message.reason);
+        }
+        if (message.localizedMessage !== undefined) {
+            LocalizedMessage.encode(message.localizedMessage, 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 = createBaseBadRequest_FieldViolation();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.field = reader.string();
+                    break;
+                case 2:
+                    message.description = reader.string();
+                    break;
+                case 3:
+                    message.reason = reader.string();
+                    break;
+                case 4:
+                    message.localizedMessage = LocalizedMessage.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseBadRequest_FieldViolation();
+        message.field = object.field ?? "";
+        message.description = object.description ?? "";
+        message.reason = object.reason ?? "";
+        message.localizedMessage = object.localizedMessage !== undefined && object.localizedMessage !== null ? LocalizedMessage.fromPartial(object.localizedMessage) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseBadRequest_FieldViolation();
+        if (object.field !== undefined && object.field !== null) {
+            message.field = object.field;
+        }
+        if (object.description !== undefined && object.description !== null) {
+            message.description = object.description;
+        }
+        if (object.reason !== undefined && object.reason !== null) {
+            message.reason = object.reason;
+        }
+        if (object.localized_message !== undefined && object.localized_message !== null) {
+            message.localizedMessage = LocalizedMessage.fromAmino(object.localized_message);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.field = message.field === "" ? undefined : message.field;
+        obj.description = message.description === "" ? undefined : message.description;
+        obj.reason = message.reason === "" ? undefined : message.reason;
+        obj.localized_message = message.localizedMessage ? LocalizedMessage.toAmino(message.localizedMessage) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return BadRequest_FieldViolation.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return BadRequest_FieldViolation.decode(message.value);
+    },
+    toProto(message) {
+        return BadRequest_FieldViolation.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.FieldViolation",
+            value: BadRequest_FieldViolation.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(BadRequest_FieldViolation.typeUrl)) {
+            return;
+        }
+        LocalizedMessage.registerTypeUrl();
+    }
+};
+function createBaseRequestInfo() {
+    return {
+        requestId: "",
+        servingData: ""
+    };
+}
+/**
+ * Contains metadata about the request that clients can attach when filing a bug
+ * or providing other forms of feedback.
+ * @name RequestInfo
+ * @package google.rpc
+ * @see proto type: google.rpc.RequestInfo
+ */
+export const RequestInfo = {
+    typeUrl: "/google.rpc.RequestInfo",
+    is(o) {
+        return o && (o.$typeUrl === RequestInfo.typeUrl || typeof o.requestId === "string" && typeof o.servingData === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === RequestInfo.typeUrl || typeof o.request_id === "string" && typeof o.serving_data === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.requestId !== "") {
+            writer.uint32(10).string(message.requestId);
+        }
+        if (message.servingData !== "") {
+            writer.uint32(18).string(message.servingData);
+        }
+        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 = createBaseRequestInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.requestId = reader.string();
+                    break;
+                case 2:
+                    message.servingData = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRequestInfo();
+        message.requestId = object.requestId ?? "";
+        message.servingData = object.servingData ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRequestInfo();
+        if (object.request_id !== undefined && object.request_id !== null) {
+            message.requestId = object.request_id;
+        }
+        if (object.serving_data !== undefined && object.serving_data !== null) {
+            message.servingData = object.serving_data;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.request_id = message.requestId === "" ? undefined : message.requestId;
+        obj.serving_data = message.servingData === "" ? undefined : message.servingData;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return RequestInfo.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return RequestInfo.decode(message.value);
+    },
+    toProto(message) {
+        return RequestInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.RequestInfo",
+            value: RequestInfo.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseResourceInfo() {
+    return {
+        resourceType: "",
+        resourceName: "",
+        owner: "",
+        description: ""
+    };
+}
+/**
+ * Describes the resource that is being accessed.
+ * @name ResourceInfo
+ * @package google.rpc
+ * @see proto type: google.rpc.ResourceInfo
+ */
+export const ResourceInfo = {
+    typeUrl: "/google.rpc.ResourceInfo",
+    is(o) {
+        return o && (o.$typeUrl === ResourceInfo.typeUrl || typeof o.resourceType === "string" && typeof o.resourceName === "string" && typeof o.owner === "string" && typeof o.description === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === ResourceInfo.typeUrl || typeof o.resource_type === "string" && typeof o.resource_name === "string" && typeof o.owner === "string" && typeof o.description === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.resourceType !== "") {
+            writer.uint32(10).string(message.resourceType);
+        }
+        if (message.resourceName !== "") {
+            writer.uint32(18).string(message.resourceName);
+        }
+        if (message.owner !== "") {
+            writer.uint32(26).string(message.owner);
+        }
+        if (message.description !== "") {
+            writer.uint32(34).string(message.description);
+        }
+        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 = createBaseResourceInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.resourceType = reader.string();
+                    break;
+                case 2:
+                    message.resourceName = reader.string();
+                    break;
+                case 3:
+                    message.owner = reader.string();
+                    break;
+                case 4:
+                    message.description = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseResourceInfo();
+        message.resourceType = object.resourceType ?? "";
+        message.resourceName = object.resourceName ?? "";
+        message.owner = object.owner ?? "";
+        message.description = object.description ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseResourceInfo();
+        if (object.resource_type !== undefined && object.resource_type !== null) {
+            message.resourceType = object.resource_type;
+        }
+        if (object.resource_name !== undefined && object.resource_name !== null) {
+            message.resourceName = object.resource_name;
+        }
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.description !== undefined && object.description !== null) {
+            message.description = object.description;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.resource_type = message.resourceType === "" ? undefined : message.resourceType;
+        obj.resource_name = message.resourceName === "" ? undefined : message.resourceName;
+        obj.owner = message.owner === "" ? undefined : message.owner;
+        obj.description = message.description === "" ? undefined : message.description;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ResourceInfo.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ResourceInfo.decode(message.value);
+    },
+    toProto(message) {
+        return ResourceInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.ResourceInfo",
+            value: ResourceInfo.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseHelp() {
+    return {
+        links: []
+    };
+}
+/**
+ * Provides links to documentation or for performing an out of band action.
+ *
+ * For example, if a quota check failed with an error indicating the calling
+ * project hasn't enabled the accessed service, this can contain a URL pointing
+ * directly to the right place in the developer console to flip the bit.
+ * @name Help
+ * @package google.rpc
+ * @see proto type: google.rpc.Help
+ */
+export const Help = {
+    typeUrl: "/google.rpc.Help",
+    is(o) {
+        return o && (o.$typeUrl === Help.typeUrl || Array.isArray(o.links) && (!o.links.length || Help_Link.is(o.links[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Help.typeUrl || Array.isArray(o.links) && (!o.links.length || Help_Link.isAmino(o.links[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.links) {
+            Help_Link.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 = createBaseHelp();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.links.push(Help_Link.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseHelp();
+        message.links = object.links?.map(e => Help_Link.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseHelp();
+        message.links = object.links?.map(e => Help_Link.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.links) {
+            obj.links = message.links.map(e => e ? Help_Link.toAmino(e) : undefined);
+        }
+        else {
+            obj.links = message.links;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Help.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Help.decode(message.value);
+    },
+    toProto(message) {
+        return Help.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.Help",
+            value: Help.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Help.typeUrl)) {
+            return;
+        }
+        Help_Link.registerTypeUrl();
+    }
+};
+function createBaseHelp_Link() {
+    return {
+        description: "",
+        url: ""
+    };
+}
+/**
+ * Describes a URL link.
+ * @name Help_Link
+ * @package google.rpc
+ * @see proto type: google.rpc.Link
+ */
+export const Help_Link = {
+    typeUrl: "/google.rpc.Link",
+    is(o) {
+        return o && (o.$typeUrl === Help_Link.typeUrl || typeof o.description === "string" && typeof o.url === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Help_Link.typeUrl || typeof o.description === "string" && typeof o.url === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.description !== "") {
+            writer.uint32(10).string(message.description);
+        }
+        if (message.url !== "") {
+            writer.uint32(18).string(message.url);
+        }
+        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 = createBaseHelp_Link();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.description = reader.string();
+                    break;
+                case 2:
+                    message.url = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseHelp_Link();
+        message.description = object.description ?? "";
+        message.url = object.url ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseHelp_Link();
+        if (object.description !== undefined && object.description !== null) {
+            message.description = object.description;
+        }
+        if (object.url !== undefined && object.url !== null) {
+            message.url = object.url;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.description = message.description === "" ? undefined : message.description;
+        obj.url = message.url === "" ? undefined : message.url;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Help_Link.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Help_Link.decode(message.value);
+    },
+    toProto(message) {
+        return Help_Link.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.Link",
+            value: Help_Link.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseLocalizedMessage() {
+    return {
+        locale: "",
+        message: ""
+    };
+}
+/**
+ * Provides a localized error message that is safe to return to the user
+ * which can be attached to an RPC error.
+ * @name LocalizedMessage
+ * @package google.rpc
+ * @see proto type: google.rpc.LocalizedMessage
+ */
+export const LocalizedMessage = {
+    typeUrl: "/google.rpc.LocalizedMessage",
+    is(o) {
+        return o && (o.$typeUrl === LocalizedMessage.typeUrl || typeof o.locale === "string" && typeof o.message === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === LocalizedMessage.typeUrl || typeof o.locale === "string" && typeof o.message === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.locale !== "") {
+            writer.uint32(10).string(message.locale);
+        }
+        if (message.message !== "") {
+            writer.uint32(18).string(message.message);
+        }
+        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 = createBaseLocalizedMessage();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.locale = reader.string();
+                    break;
+                case 2:
+                    message.message = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseLocalizedMessage();
+        message.locale = object.locale ?? "";
+        message.message = object.message ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseLocalizedMessage();
+        if (object.locale !== undefined && object.locale !== null) {
+            message.locale = object.locale;
+        }
+        if (object.message !== undefined && object.message !== null) {
+            message.message = object.message;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.locale = message.locale === "" ? undefined : message.locale;
+        obj.message = message.message === "" ? undefined : message.message;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return LocalizedMessage.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return LocalizedMessage.decode(message.value);
+    },
+    toProto(message) {
+        return LocalizedMessage.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.rpc.LocalizedMessage",
+            value: LocalizedMessage.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};