@canton-network/core-ledger-proto 0.1.0

package/dist/_proto/google/rpc/error_details.js

@@ -0,0 +1,918 @@
+import { WireType } from '@protobuf-ts/runtime';
+import { UnknownFieldHandler } from '@protobuf-ts/runtime';
+import { reflectionMergePartial } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+import { Duration } from '../protobuf/duration.js';
+// @generated message type with reflection information, may provide speed optimized methods
+class ErrorInfo$Type extends MessageType {
+    constructor() {
+        super('google.rpc.ErrorInfo', [
+            {
+                no: 1,
+                name: 'reason',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'domain',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 3,
+                name: 'metadata',
+                kind: 'map',
+                K: 9 /*ScalarType.STRING*/,
+                V: { kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.reason = '';
+        message.domain = '';
+        message.metadata = {};
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string reason */ 1:
+                    message.reason = reader.string();
+                    break;
+                case /* string domain */ 2:
+                    message.domain = reader.string();
+                    break;
+                case /* map<string, string> metadata */ 3:
+                    this.binaryReadMap3(message.metadata, reader, options);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    binaryReadMap3(map, reader, options) {
+        let len = reader.uint32(), end = reader.pos + len, key, val;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = reader.string();
+                    break;
+                default:
+                    throw new globalThis.Error('unknown map entry field for google.rpc.ErrorInfo.metadata');
+            }
+        }
+        map[key ?? ''] = val ?? '';
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string reason = 1; */
+        if (message.reason !== '')
+            writer.tag(1, WireType.LengthDelimited).string(message.reason);
+        /* string domain = 2; */
+        if (message.domain !== '')
+            writer.tag(2, WireType.LengthDelimited).string(message.domain);
+        /* map<string, string> metadata = 3; */
+        for (let k of globalThis.Object.keys(message.metadata))
+            writer
+                .tag(3, WireType.LengthDelimited)
+                .fork()
+                .tag(1, WireType.LengthDelimited)
+                .string(k)
+                .tag(2, WireType.LengthDelimited)
+                .string(message.metadata[k])
+                .join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.ErrorInfo
+ */
+export const ErrorInfo = new ErrorInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RetryInfo$Type extends MessageType {
+    constructor() {
+        super('google.rpc.RetryInfo', [
+            { no: 1, name: 'retry_delay', kind: 'message', T: () => Duration },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* google.protobuf.Duration retry_delay */ 1:
+                    message.retryDelay = Duration.internalBinaryRead(reader, reader.uint32(), options, message.retryDelay);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* google.protobuf.Duration retry_delay = 1; */
+        if (message.retryDelay)
+            Duration.internalBinaryWrite(message.retryDelay, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.RetryInfo
+ */
+export const RetryInfo = new RetryInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DebugInfo$Type extends MessageType {
+    constructor() {
+        super('google.rpc.DebugInfo', [
+            {
+                no: 1,
+                name: 'stack_entries',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'detail',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.stackEntries = [];
+        message.detail = '';
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated string stack_entries */ 1:
+                    message.stackEntries.push(reader.string());
+                    break;
+                case /* string detail */ 2:
+                    message.detail = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated string stack_entries = 1; */
+        for (let i = 0; i < message.stackEntries.length; i++)
+            writer
+                .tag(1, WireType.LengthDelimited)
+                .string(message.stackEntries[i]);
+        /* string detail = 2; */
+        if (message.detail !== '')
+            writer.tag(2, WireType.LengthDelimited).string(message.detail);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.DebugInfo
+ */
+export const DebugInfo = new DebugInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class QuotaFailure$Type extends MessageType {
+    constructor() {
+        super('google.rpc.QuotaFailure', [
+            {
+                no: 1,
+                name: 'violations',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => QuotaFailure_Violation,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.violations = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated google.rpc.QuotaFailure.Violation violations */ 1:
+                    message.violations.push(QuotaFailure_Violation.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated google.rpc.QuotaFailure.Violation violations = 1; */
+        for (let i = 0; i < message.violations.length; i++)
+            QuotaFailure_Violation.internalBinaryWrite(message.violations[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.QuotaFailure
+ */
+export const QuotaFailure = new QuotaFailure$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class QuotaFailure_Violation$Type extends MessageType {
+    constructor() {
+        super('google.rpc.QuotaFailure.Violation', [
+            {
+                no: 1,
+                name: 'subject',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'description',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.subject = '';
+        message.description = '';
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string subject */ 1:
+                    message.subject = reader.string();
+                    break;
+                case /* string description */ 2:
+                    message.description = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string subject = 1; */
+        if (message.subject !== '')
+            writer.tag(1, WireType.LengthDelimited).string(message.subject);
+        /* string description = 2; */
+        if (message.description !== '')
+            writer.tag(2, WireType.LengthDelimited).string(message.description);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.QuotaFailure.Violation
+ */
+export const QuotaFailure_Violation = new QuotaFailure_Violation$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PreconditionFailure$Type extends MessageType {
+    constructor() {
+        super('google.rpc.PreconditionFailure', [
+            {
+                no: 1,
+                name: 'violations',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => PreconditionFailure_Violation,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.violations = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated google.rpc.PreconditionFailure.Violation violations */ 1:
+                    message.violations.push(PreconditionFailure_Violation.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated google.rpc.PreconditionFailure.Violation violations = 1; */
+        for (let i = 0; i < message.violations.length; i++)
+            PreconditionFailure_Violation.internalBinaryWrite(message.violations[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.PreconditionFailure
+ */
+export const PreconditionFailure = new PreconditionFailure$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PreconditionFailure_Violation$Type extends MessageType {
+    constructor() {
+        super('google.rpc.PreconditionFailure.Violation', [
+            { no: 1, name: 'type', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            {
+                no: 2,
+                name: 'subject',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 3,
+                name: 'description',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.type = '';
+        message.subject = '';
+        message.description = '';
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string type */ 1:
+                    message.type = reader.string();
+                    break;
+                case /* string subject */ 2:
+                    message.subject = reader.string();
+                    break;
+                case /* string description */ 3:
+                    message.description = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string type = 1; */
+        if (message.type !== '')
+            writer.tag(1, WireType.LengthDelimited).string(message.type);
+        /* string subject = 2; */
+        if (message.subject !== '')
+            writer.tag(2, WireType.LengthDelimited).string(message.subject);
+        /* string description = 3; */
+        if (message.description !== '')
+            writer.tag(3, WireType.LengthDelimited).string(message.description);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.PreconditionFailure.Violation
+ */
+export const PreconditionFailure_Violation = new PreconditionFailure_Violation$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class BadRequest$Type extends MessageType {
+    constructor() {
+        super('google.rpc.BadRequest', [
+            {
+                no: 1,
+                name: 'field_violations',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => BadRequest_FieldViolation,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.fieldViolations = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated google.rpc.BadRequest.FieldViolation field_violations */ 1:
+                    message.fieldViolations.push(BadRequest_FieldViolation.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated google.rpc.BadRequest.FieldViolation field_violations = 1; */
+        for (let i = 0; i < message.fieldViolations.length; i++)
+            BadRequest_FieldViolation.internalBinaryWrite(message.fieldViolations[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.BadRequest
+ */
+export const BadRequest = new BadRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class BadRequest_FieldViolation$Type extends MessageType {
+    constructor() {
+        super('google.rpc.BadRequest.FieldViolation', [
+            {
+                no: 1,
+                name: 'field',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'description',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.field = '';
+        message.description = '';
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string field */ 1:
+                    message.field = reader.string();
+                    break;
+                case /* string description */ 2:
+                    message.description = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string field = 1; */
+        if (message.field !== '')
+            writer.tag(1, WireType.LengthDelimited).string(message.field);
+        /* string description = 2; */
+        if (message.description !== '')
+            writer.tag(2, WireType.LengthDelimited).string(message.description);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.BadRequest.FieldViolation
+ */
+export const BadRequest_FieldViolation = new BadRequest_FieldViolation$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RequestInfo$Type extends MessageType {
+    constructor() {
+        super('google.rpc.RequestInfo', [
+            {
+                no: 1,
+                name: 'request_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'serving_data',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.requestId = '';
+        message.servingData = '';
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string request_id */ 1:
+                    message.requestId = reader.string();
+                    break;
+                case /* string serving_data */ 2:
+                    message.servingData = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string request_id = 1; */
+        if (message.requestId !== '')
+            writer.tag(1, WireType.LengthDelimited).string(message.requestId);
+        /* string serving_data = 2; */
+        if (message.servingData !== '')
+            writer.tag(2, WireType.LengthDelimited).string(message.servingData);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.RequestInfo
+ */
+export const RequestInfo = new RequestInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResourceInfo$Type extends MessageType {
+    constructor() {
+        super('google.rpc.ResourceInfo', [
+            {
+                no: 1,
+                name: 'resource_type',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'resource_name',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 3,
+                name: 'owner',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 4,
+                name: 'description',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.resourceType = '';
+        message.resourceName = '';
+        message.owner = '';
+        message.description = '';
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string resource_type */ 1:
+                    message.resourceType = reader.string();
+                    break;
+                case /* string resource_name */ 2:
+                    message.resourceName = reader.string();
+                    break;
+                case /* string owner */ 3:
+                    message.owner = reader.string();
+                    break;
+                case /* string description */ 4:
+                    message.description = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string resource_type = 1; */
+        if (message.resourceType !== '')
+            writer.tag(1, WireType.LengthDelimited).string(message.resourceType);
+        /* string resource_name = 2; */
+        if (message.resourceName !== '')
+            writer.tag(2, WireType.LengthDelimited).string(message.resourceName);
+        /* string owner = 3; */
+        if (message.owner !== '')
+            writer.tag(3, WireType.LengthDelimited).string(message.owner);
+        /* string description = 4; */
+        if (message.description !== '')
+            writer.tag(4, WireType.LengthDelimited).string(message.description);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.ResourceInfo
+ */
+export const ResourceInfo = new ResourceInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Help$Type extends MessageType {
+    constructor() {
+        super('google.rpc.Help', [
+            {
+                no: 1,
+                name: 'links',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => Help_Link,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.links = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated google.rpc.Help.Link links */ 1:
+                    message.links.push(Help_Link.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated google.rpc.Help.Link links = 1; */
+        for (let i = 0; i < message.links.length; i++)
+            Help_Link.internalBinaryWrite(message.links[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.Help
+ */
+export const Help = new Help$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Help_Link$Type extends MessageType {
+    constructor() {
+        super('google.rpc.Help.Link', [
+            {
+                no: 1,
+                name: 'description',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            { no: 2, name: 'url', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.description = '';
+        message.url = '';
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string description */ 1:
+                    message.description = reader.string();
+                    break;
+                case /* string url */ 2:
+                    message.url = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string description = 1; */
+        if (message.description !== '')
+            writer.tag(1, WireType.LengthDelimited).string(message.description);
+        /* string url = 2; */
+        if (message.url !== '')
+            writer.tag(2, WireType.LengthDelimited).string(message.url);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.Help.Link
+ */
+export const Help_Link = new Help_Link$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LocalizedMessage$Type extends MessageType {
+    constructor() {
+        super('google.rpc.LocalizedMessage', [
+            {
+                no: 1,
+                name: 'locale',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'message',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.locale = '';
+        message.message = '';
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string locale */ 1:
+                    message.locale = reader.string();
+                    break;
+                case /* string message */ 2:
+                    message.message = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string locale = 1; */
+        if (message.locale !== '')
+            writer.tag(1, WireType.LengthDelimited).string(message.locale);
+        /* string message = 2; */
+        if (message.message !== '')
+            writer.tag(2, WireType.LengthDelimited).string(message.message);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.LocalizedMessage
+ */
+export const LocalizedMessage = new LocalizedMessage$Type();