@canton-network/core-ledger-proto 0.1.0

package/dist/_proto/com/daml/ledger/api/v2/transaction_filter.js

@@ -0,0 +1,815 @@
+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 { Identifier } from './value.js';
+/**
+ * Event shape for Transactions.
+ * Shapes are exclusive and only one of them can be defined in queries.
+ *
+ * @generated from protobuf enum com.daml.ledger.api.v2.TransactionShape
+ */
+export var TransactionShape;
+(function (TransactionShape) {
+    /**
+     * Following official proto3 convention, not intended for actual use.
+     *
+     * @generated from protobuf enum value: TRANSACTION_SHAPE_UNSPECIFIED = 0;
+     */
+    TransactionShape[TransactionShape["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * Transaction shape that is sufficient to maintain an accurate ACS view.
+     * The field witness_parties in events are populated as stakeholders, transaction filter will apply accordingly.
+     * This translates to create and archive events.
+     *
+     * @generated from protobuf enum value: TRANSACTION_SHAPE_ACS_DELTA = 1;
+     */
+    TransactionShape[TransactionShape["ACS_DELTA"] = 1] = "ACS_DELTA";
+    /**
+     * Transaction shape that allows maintaining an ACS and also conveys detailed information about
+     * all exercises.
+     * The field witness_parties in events are populated as cumulative informees, transaction filter will apply accordingly.
+     * This translates to create, consuming exercise and non-consuming exercise.
+     *
+     * @generated from protobuf enum value: TRANSACTION_SHAPE_LEDGER_EFFECTS = 2;
+     */
+    TransactionShape[TransactionShape["LEDGER_EFFECTS"] = 2] = "LEDGER_EFFECTS";
+})(TransactionShape || (TransactionShape = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class Filters$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.Filters', [
+            {
+                no: 1,
+                name: 'cumulative',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => CumulativeFilter,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.cumulative = [];
+        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 com.daml.ledger.api.v2.CumulativeFilter cumulative */ 1:
+                    message.cumulative.push(CumulativeFilter.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 com.daml.ledger.api.v2.CumulativeFilter cumulative = 1; */
+        for (let i = 0; i < message.cumulative.length; i++)
+            CumulativeFilter.internalBinaryWrite(message.cumulative[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 com.daml.ledger.api.v2.Filters
+ */
+export const Filters = new Filters$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CumulativeFilter$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.CumulativeFilter', [
+            {
+                no: 1,
+                name: 'wildcard_filter',
+                kind: 'message',
+                oneof: 'identifierFilter',
+                T: () => WildcardFilter,
+            },
+            {
+                no: 2,
+                name: 'interface_filter',
+                kind: 'message',
+                oneof: 'identifierFilter',
+                T: () => InterfaceFilter,
+            },
+            {
+                no: 3,
+                name: 'template_filter',
+                kind: 'message',
+                oneof: 'identifierFilter',
+                T: () => TemplateFilter,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.identifierFilter = { oneofKind: undefined };
+        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 /* com.daml.ledger.api.v2.WildcardFilter wildcard_filter */ 1:
+                    message.identifierFilter = {
+                        oneofKind: 'wildcardFilter',
+                        wildcardFilter: WildcardFilter.internalBinaryRead(reader, reader.uint32(), options, message.identifierFilter.wildcardFilter),
+                    };
+                    break;
+                case /* com.daml.ledger.api.v2.InterfaceFilter interface_filter */ 2:
+                    message.identifierFilter = {
+                        oneofKind: 'interfaceFilter',
+                        interfaceFilter: InterfaceFilter.internalBinaryRead(reader, reader.uint32(), options, message.identifierFilter.interfaceFilter),
+                    };
+                    break;
+                case /* com.daml.ledger.api.v2.TemplateFilter template_filter */ 3:
+                    message.identifierFilter = {
+                        oneofKind: 'templateFilter',
+                        templateFilter: TemplateFilter.internalBinaryRead(reader, reader.uint32(), options, message.identifierFilter.templateFilter),
+                    };
+                    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) {
+        /* com.daml.ledger.api.v2.WildcardFilter wildcard_filter = 1; */
+        if (message.identifierFilter.oneofKind === 'wildcardFilter')
+            WildcardFilter.internalBinaryWrite(message.identifierFilter.wildcardFilter, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* com.daml.ledger.api.v2.InterfaceFilter interface_filter = 2; */
+        if (message.identifierFilter.oneofKind === 'interfaceFilter')
+            InterfaceFilter.internalBinaryWrite(message.identifierFilter.interfaceFilter, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* com.daml.ledger.api.v2.TemplateFilter template_filter = 3; */
+        if (message.identifierFilter.oneofKind === 'templateFilter')
+            TemplateFilter.internalBinaryWrite(message.identifierFilter.templateFilter, writer.tag(3, 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 com.daml.ledger.api.v2.CumulativeFilter
+ */
+export const CumulativeFilter = new CumulativeFilter$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class WildcardFilter$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.WildcardFilter', [
+            {
+                no: 1,
+                name: 'include_created_event_blob',
+                kind: 'scalar',
+                T: 8 /*ScalarType.BOOL*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.includeCreatedEventBlob = false;
+        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 /* bool include_created_event_blob */ 1:
+                    message.includeCreatedEventBlob = reader.bool();
+                    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) {
+        /* bool include_created_event_blob = 1; */
+        if (message.includeCreatedEventBlob !== false)
+            writer.tag(1, WireType.Varint).bool(message.includeCreatedEventBlob);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.WildcardFilter
+ */
+export const WildcardFilter = new WildcardFilter$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class InterfaceFilter$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.InterfaceFilter', [
+            {
+                no: 1,
+                name: 'interface_id',
+                kind: 'message',
+                T: () => Identifier,
+            },
+            {
+                no: 2,
+                name: 'include_interface_view',
+                kind: 'scalar',
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 3,
+                name: 'include_created_event_blob',
+                kind: 'scalar',
+                T: 8 /*ScalarType.BOOL*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.includeInterfaceView = false;
+        message.includeCreatedEventBlob = false;
+        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 /* com.daml.ledger.api.v2.Identifier interface_id */ 1:
+                    message.interfaceId = Identifier.internalBinaryRead(reader, reader.uint32(), options, message.interfaceId);
+                    break;
+                case /* bool include_interface_view */ 2:
+                    message.includeInterfaceView = reader.bool();
+                    break;
+                case /* bool include_created_event_blob */ 3:
+                    message.includeCreatedEventBlob = reader.bool();
+                    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) {
+        /* com.daml.ledger.api.v2.Identifier interface_id = 1; */
+        if (message.interfaceId)
+            Identifier.internalBinaryWrite(message.interfaceId, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* bool include_interface_view = 2; */
+        if (message.includeInterfaceView !== false)
+            writer.tag(2, WireType.Varint).bool(message.includeInterfaceView);
+        /* bool include_created_event_blob = 3; */
+        if (message.includeCreatedEventBlob !== false)
+            writer.tag(3, WireType.Varint).bool(message.includeCreatedEventBlob);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.InterfaceFilter
+ */
+export const InterfaceFilter = new InterfaceFilter$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TemplateFilter$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.TemplateFilter', [
+            {
+                no: 1,
+                name: 'template_id',
+                kind: 'message',
+                T: () => Identifier,
+            },
+            {
+                no: 2,
+                name: 'include_created_event_blob',
+                kind: 'scalar',
+                T: 8 /*ScalarType.BOOL*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.includeCreatedEventBlob = false;
+        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 /* com.daml.ledger.api.v2.Identifier template_id */ 1:
+                    message.templateId = Identifier.internalBinaryRead(reader, reader.uint32(), options, message.templateId);
+                    break;
+                case /* bool include_created_event_blob */ 2:
+                    message.includeCreatedEventBlob = reader.bool();
+                    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) {
+        /* com.daml.ledger.api.v2.Identifier template_id = 1; */
+        if (message.templateId)
+            Identifier.internalBinaryWrite(message.templateId, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* bool include_created_event_blob = 2; */
+        if (message.includeCreatedEventBlob !== false)
+            writer.tag(2, WireType.Varint).bool(message.includeCreatedEventBlob);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.TemplateFilter
+ */
+export const TemplateFilter = new TemplateFilter$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TransactionFilter$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.TransactionFilter', [
+            {
+                no: 1,
+                name: 'filters_by_party',
+                kind: 'map',
+                K: 9 /*ScalarType.STRING*/,
+                V: { kind: 'message', T: () => Filters },
+            },
+            {
+                no: 2,
+                name: 'filters_for_any_party',
+                kind: 'message',
+                T: () => Filters,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.filtersByParty = {};
+        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 /* map<string, com.daml.ledger.api.v2.Filters> filters_by_party */ 1:
+                    this.binaryReadMap1(message.filtersByParty, reader, options);
+                    break;
+                case /* com.daml.ledger.api.v2.Filters filters_for_any_party */ 2:
+                    message.filtersForAnyParty = Filters.internalBinaryRead(reader, reader.uint32(), options, message.filtersForAnyParty);
+                    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;
+    }
+    binaryReadMap1(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 = Filters.internalBinaryRead(reader, reader.uint32(), options);
+                    break;
+                default:
+                    throw new globalThis.Error('unknown map entry field for com.daml.ledger.api.v2.TransactionFilter.filters_by_party');
+            }
+        }
+        map[key ?? ''] = val ?? Filters.create();
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* map<string, com.daml.ledger.api.v2.Filters> filters_by_party = 1; */
+        for (let k of globalThis.Object.keys(message.filtersByParty)) {
+            writer
+                .tag(1, WireType.LengthDelimited)
+                .fork()
+                .tag(1, WireType.LengthDelimited)
+                .string(k);
+            writer.tag(2, WireType.LengthDelimited).fork();
+            Filters.internalBinaryWrite(message.filtersByParty[k], writer, options);
+            writer.join().join();
+        }
+        /* com.daml.ledger.api.v2.Filters filters_for_any_party = 2; */
+        if (message.filtersForAnyParty)
+            Filters.internalBinaryWrite(message.filtersForAnyParty, writer.tag(2, 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 com.daml.ledger.api.v2.TransactionFilter
+ */
+export const TransactionFilter = new TransactionFilter$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EventFormat$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.EventFormat', [
+            {
+                no: 1,
+                name: 'filters_by_party',
+                kind: 'map',
+                K: 9 /*ScalarType.STRING*/,
+                V: { kind: 'message', T: () => Filters },
+            },
+            {
+                no: 2,
+                name: 'filters_for_any_party',
+                kind: 'message',
+                T: () => Filters,
+            },
+            {
+                no: 3,
+                name: 'verbose',
+                kind: 'scalar',
+                T: 8 /*ScalarType.BOOL*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.filtersByParty = {};
+        message.verbose = false;
+        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 /* map<string, com.daml.ledger.api.v2.Filters> filters_by_party */ 1:
+                    this.binaryReadMap1(message.filtersByParty, reader, options);
+                    break;
+                case /* com.daml.ledger.api.v2.Filters filters_for_any_party */ 2:
+                    message.filtersForAnyParty = Filters.internalBinaryRead(reader, reader.uint32(), options, message.filtersForAnyParty);
+                    break;
+                case /* bool verbose */ 3:
+                    message.verbose = reader.bool();
+                    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;
+    }
+    binaryReadMap1(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 = Filters.internalBinaryRead(reader, reader.uint32(), options);
+                    break;
+                default:
+                    throw new globalThis.Error('unknown map entry field for com.daml.ledger.api.v2.EventFormat.filters_by_party');
+            }
+        }
+        map[key ?? ''] = val ?? Filters.create();
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* map<string, com.daml.ledger.api.v2.Filters> filters_by_party = 1; */
+        for (let k of globalThis.Object.keys(message.filtersByParty)) {
+            writer
+                .tag(1, WireType.LengthDelimited)
+                .fork()
+                .tag(1, WireType.LengthDelimited)
+                .string(k);
+            writer.tag(2, WireType.LengthDelimited).fork();
+            Filters.internalBinaryWrite(message.filtersByParty[k], writer, options);
+            writer.join().join();
+        }
+        /* com.daml.ledger.api.v2.Filters filters_for_any_party = 2; */
+        if (message.filtersForAnyParty)
+            Filters.internalBinaryWrite(message.filtersForAnyParty, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* bool verbose = 3; */
+        if (message.verbose !== false)
+            writer.tag(3, WireType.Varint).bool(message.verbose);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.EventFormat
+ */
+export const EventFormat = new EventFormat$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TransactionFormat$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.TransactionFormat', [
+            {
+                no: 1,
+                name: 'event_format',
+                kind: 'message',
+                T: () => EventFormat,
+            },
+            {
+                no: 2,
+                name: 'transaction_shape',
+                kind: 'enum',
+                T: () => [
+                    'com.daml.ledger.api.v2.TransactionShape',
+                    TransactionShape,
+                    'TRANSACTION_SHAPE_',
+                ],
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.transactionShape = 0;
+        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 /* com.daml.ledger.api.v2.EventFormat event_format */ 1:
+                    message.eventFormat = EventFormat.internalBinaryRead(reader, reader.uint32(), options, message.eventFormat);
+                    break;
+                case /* com.daml.ledger.api.v2.TransactionShape transaction_shape */ 2:
+                    message.transactionShape = reader.int32();
+                    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) {
+        /* com.daml.ledger.api.v2.EventFormat event_format = 1; */
+        if (message.eventFormat)
+            EventFormat.internalBinaryWrite(message.eventFormat, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* com.daml.ledger.api.v2.TransactionShape transaction_shape = 2; */
+        if (message.transactionShape !== 0)
+            writer.tag(2, WireType.Varint).int32(message.transactionShape);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.TransactionFormat
+ */
+export const TransactionFormat = new TransactionFormat$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TopologyFormat$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.TopologyFormat', [
+            {
+                no: 1,
+                name: 'include_participant_authorization_events',
+                kind: 'message',
+                T: () => ParticipantAuthorizationTopologyFormat,
+            },
+        ]);
+    }
+    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 /* com.daml.ledger.api.v2.ParticipantAuthorizationTopologyFormat include_participant_authorization_events */ 1:
+                    message.includeParticipantAuthorizationEvents =
+                        ParticipantAuthorizationTopologyFormat.internalBinaryRead(reader, reader.uint32(), options, message.includeParticipantAuthorizationEvents);
+                    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) {
+        /* com.daml.ledger.api.v2.ParticipantAuthorizationTopologyFormat include_participant_authorization_events = 1; */
+        if (message.includeParticipantAuthorizationEvents)
+            ParticipantAuthorizationTopologyFormat.internalBinaryWrite(message.includeParticipantAuthorizationEvents, 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 com.daml.ledger.api.v2.TopologyFormat
+ */
+export const TopologyFormat = new TopologyFormat$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ParticipantAuthorizationTopologyFormat$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.ParticipantAuthorizationTopologyFormat', [
+            {
+                no: 1,
+                name: 'parties',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.parties = [];
+        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 parties */ 1:
+                    message.parties.push(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 parties = 1; */
+        for (let i = 0; i < message.parties.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.parties[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.ParticipantAuthorizationTopologyFormat
+ */
+export const ParticipantAuthorizationTopologyFormat = new ParticipantAuthorizationTopologyFormat$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UpdateFormat$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.UpdateFormat', [
+            {
+                no: 1,
+                name: 'include_transactions',
+                kind: 'message',
+                T: () => TransactionFormat,
+            },
+            {
+                no: 2,
+                name: 'include_reassignments',
+                kind: 'message',
+                T: () => EventFormat,
+            },
+            {
+                no: 3,
+                name: 'include_topology_events',
+                kind: 'message',
+                T: () => TopologyFormat,
+            },
+        ]);
+    }
+    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 /* com.daml.ledger.api.v2.TransactionFormat include_transactions */ 1:
+                    message.includeTransactions =
+                        TransactionFormat.internalBinaryRead(reader, reader.uint32(), options, message.includeTransactions);
+                    break;
+                case /* com.daml.ledger.api.v2.EventFormat include_reassignments */ 2:
+                    message.includeReassignments =
+                        EventFormat.internalBinaryRead(reader, reader.uint32(), options, message.includeReassignments);
+                    break;
+                case /* com.daml.ledger.api.v2.TopologyFormat include_topology_events */ 3:
+                    message.includeTopologyEvents =
+                        TopologyFormat.internalBinaryRead(reader, reader.uint32(), options, message.includeTopologyEvents);
+                    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) {
+        /* com.daml.ledger.api.v2.TransactionFormat include_transactions = 1; */
+        if (message.includeTransactions)
+            TransactionFormat.internalBinaryWrite(message.includeTransactions, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* com.daml.ledger.api.v2.EventFormat include_reassignments = 2; */
+        if (message.includeReassignments)
+            EventFormat.internalBinaryWrite(message.includeReassignments, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* com.daml.ledger.api.v2.TopologyFormat include_topology_events = 3; */
+        if (message.includeTopologyEvents)
+            TopologyFormat.internalBinaryWrite(message.includeTopologyEvents, writer.tag(3, 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 com.daml.ledger.api.v2.UpdateFormat
+ */
+export const UpdateFormat = new UpdateFormat$Type();