@canton-network/core-ledger-proto 0.10.0 → 0.12.0

package/dist/esm/_proto/com/digitalasset/canton/topology/admin/v30/topology_manager_read_service.js

@@ -0,0 +1,4684 @@
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+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 { TopologyTransactions } from "./common.js";
+import { PurgeTopologyTransaction } from "../../../protocol/v30/topology.js";
+import { SequencerSynchronizerState } from "../../../protocol/v30/topology.js";
+import { MediatorSynchronizerState } from "../../../protocol/v30/topology.js";
+import { DynamicSynchronizerParameters } from "../../../protocol/v30/synchronizer_parameters.js";
+import { PartyToParticipant } from "../../../protocol/v30/topology.js";
+import { VettedPackages } from "../../../protocol/v30/topology.js";
+import { PartyHostingLimits } from "../../../protocol/v30/topology.js";
+import { ParticipantSynchronizerPermission } from "../../../protocol/v30/topology.js";
+import { SynchronizerTrustCertificate } from "../../../protocol/v30/topology.js";
+import { PartyToKeyMapping } from "../../../protocol/v30/topology.js";
+import { OwnerToKeyMapping } from "../../../protocol/v30/topology.js";
+import { DecentralizedNamespaceDefinition } from "../../../protocol/v30/topology.js";
+import { NamespaceDelegation } from "../../../protocol/v30/topology.js";
+import { Empty } from "../../../../../../google/protobuf/empty.js";
+import { Timestamp } from "../../../../../../google/protobuf/timestamp.js";
+import { Enums_TopologyChangeOp } from "../../../protocol/v30/topology.js";
+import { StoreId } from "./common.js";
+class BaseQuery$Type extends MessageType {
+  constructor() {
+    super("com.digitalasset.canton.topology.admin.v30.BaseQuery", [
+      { no: 1, name: "store", kind: "message", T: () => StoreId },
+      {
+        no: 2,
+        name: "proposals",
+        kind: "scalar",
+        T: 8
+      },
+      {
+        no: 3,
+        name: "operation",
+        kind: "enum",
+        T: () => [
+          "com.digitalasset.canton.protocol.v30.Enums.TopologyChangeOp",
+          Enums_TopologyChangeOp,
+          "TOPOLOGY_CHANGE_OP_"
+        ]
+      },
+      {
+        no: 5,
+        name: "snapshot",
+        kind: "message",
+        oneof: "timeQuery",
+        T: () => Timestamp
+      },
+      {
+        no: 6,
+        name: "head_state",
+        kind: "message",
+        oneof: "timeQuery",
+        T: () => Empty
+      },
+      {
+        no: 7,
+        name: "range",
+        kind: "message",
+        oneof: "timeQuery",
+        T: () => BaseQuery_TimeRange
+      },
+      {
+        no: 8,
+        name: "filter_signed_key",
+        kind: "scalar",
+        T: 9
+      },
+      {
+        no: 9,
+        name: "protocol_version",
+        kind: "scalar",
+        opt: true,
+        T: 5
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.proposals = false;
+    message.operation = 0;
+    message.timeQuery = { oneofKind: void 0 };
+    message.filterSignedKey = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.StoreId store */
+        1:
+          message.store = StoreId.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.store
+          );
+          break;
+        case /* bool proposals */
+        2:
+          message.proposals = reader.bool();
+          break;
+        case /* com.digitalasset.canton.protocol.v30.Enums.TopologyChangeOp operation */
+        3:
+          message.operation = reader.int32();
+          break;
+        case /* google.protobuf.Timestamp snapshot */
+        5:
+          message.timeQuery = {
+            oneofKind: "snapshot",
+            snapshot: Timestamp.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options,
+              message.timeQuery.snapshot
+            )
+          };
+          break;
+        case /* google.protobuf.Empty head_state */
+        6:
+          message.timeQuery = {
+            oneofKind: "headState",
+            headState: Empty.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options,
+              message.timeQuery.headState
+            )
+          };
+          break;
+        case /* com.digitalasset.canton.topology.admin.v30.BaseQuery.TimeRange range */
+        7:
+          message.timeQuery = {
+            oneofKind: "range",
+            range: BaseQuery_TimeRange.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options,
+              message.timeQuery.range
+            )
+          };
+          break;
+        case /* string filter_signed_key */
+        8:
+          message.filterSignedKey = reader.string();
+          break;
+        case /* optional int32 protocol_version */
+        9:
+          message.protocolVersion = 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) {
+    if (message.store)
+      StoreId.internalBinaryWrite(
+        message.store,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.proposals !== false)
+      writer.tag(2, WireType.Varint).bool(message.proposals);
+    if (message.operation !== 0)
+      writer.tag(3, WireType.Varint).int32(message.operation);
+    if (message.timeQuery.oneofKind === "snapshot")
+      Timestamp.internalBinaryWrite(
+        message.timeQuery.snapshot,
+        writer.tag(5, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.timeQuery.oneofKind === "headState")
+      Empty.internalBinaryWrite(
+        message.timeQuery.headState,
+        writer.tag(6, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.timeQuery.oneofKind === "range")
+      BaseQuery_TimeRange.internalBinaryWrite(
+        message.timeQuery.range,
+        writer.tag(7, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterSignedKey !== "")
+      writer.tag(8, WireType.LengthDelimited).string(message.filterSignedKey);
+    if (message.protocolVersion !== void 0)
+      writer.tag(9, WireType.Varint).int32(message.protocolVersion);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const BaseQuery = new BaseQuery$Type();
+class BaseQuery_TimeRange$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.BaseQuery.TimeRange",
+      [
+        { no: 1, name: "from", kind: "message", T: () => Timestamp },
+        { no: 2, name: "until", kind: "message", T: () => Timestamp }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.Timestamp from */
+        1:
+          message.from = Timestamp.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.from
+          );
+          break;
+        case /* google.protobuf.Timestamp until */
+        2:
+          message.until = Timestamp.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.until
+          );
+          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) {
+    if (message.from)
+      Timestamp.internalBinaryWrite(
+        message.from,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.until)
+      Timestamp.internalBinaryWrite(
+        message.until,
+        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;
+  }
+}
+const BaseQuery_TimeRange = new BaseQuery_TimeRange$Type();
+class BaseResult$Type extends MessageType {
+  constructor() {
+    super("com.digitalasset.canton.topology.admin.v30.BaseResult", [
+      { no: 1, name: "store", kind: "message", T: () => StoreId },
+      { no: 2, name: "sequenced", kind: "message", T: () => Timestamp },
+      { no: 3, name: "valid_from", kind: "message", T: () => Timestamp },
+      { no: 4, name: "valid_until", kind: "message", T: () => Timestamp },
+      {
+        no: 5,
+        name: "operation",
+        kind: "enum",
+        T: () => [
+          "com.digitalasset.canton.protocol.v30.Enums.TopologyChangeOp",
+          Enums_TopologyChangeOp,
+          "TOPOLOGY_CHANGE_OP_"
+        ]
+      },
+      {
+        no: 6,
+        name: "transaction_hash",
+        kind: "scalar",
+        T: 12
+      },
+      {
+        no: 7,
+        name: "serial",
+        kind: "scalar",
+        T: 5
+      },
+      {
+        no: 8,
+        name: "signed_by_fingerprints",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.operation = 0;
+    message.transactionHash = new Uint8Array(0);
+    message.serial = 0;
+    message.signedByFingerprints = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.StoreId store */
+        1:
+          message.store = StoreId.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.store
+          );
+          break;
+        case /* google.protobuf.Timestamp sequenced */
+        2:
+          message.sequenced = Timestamp.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.sequenced
+          );
+          break;
+        case /* google.protobuf.Timestamp valid_from */
+        3:
+          message.validFrom = Timestamp.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.validFrom
+          );
+          break;
+        case /* google.protobuf.Timestamp valid_until */
+        4:
+          message.validUntil = Timestamp.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.validUntil
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.Enums.TopologyChangeOp operation */
+        5:
+          message.operation = reader.int32();
+          break;
+        case /* bytes transaction_hash */
+        6:
+          message.transactionHash = reader.bytes();
+          break;
+        case /* int32 serial */
+        7:
+          message.serial = reader.int32();
+          break;
+        case /* repeated string signed_by_fingerprints */
+        8:
+          message.signedByFingerprints.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) {
+    if (message.store)
+      StoreId.internalBinaryWrite(
+        message.store,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.sequenced)
+      Timestamp.internalBinaryWrite(
+        message.sequenced,
+        writer.tag(2, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.validFrom)
+      Timestamp.internalBinaryWrite(
+        message.validFrom,
+        writer.tag(3, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.validUntil)
+      Timestamp.internalBinaryWrite(
+        message.validUntil,
+        writer.tag(4, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.operation !== 0)
+      writer.tag(5, WireType.Varint).int32(message.operation);
+    if (message.transactionHash.length)
+      writer.tag(6, WireType.LengthDelimited).bytes(message.transactionHash);
+    if (message.serial !== 0)
+      writer.tag(7, WireType.Varint).int32(message.serial);
+    for (let i = 0; i < message.signedByFingerprints.length; i++)
+      writer.tag(8, WireType.LengthDelimited).string(message.signedByFingerprints[i]);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const BaseResult = new BaseResult$Type();
+class ListNamespaceDelegationRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListNamespaceDelegationRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "filter_namespace",
+          kind: "scalar",
+          T: 9
+        },
+        {
+          no: 3,
+          name: "filter_target_key_fingerprint",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.filterNamespace = "";
+    message.filterTargetKeyFingerprint = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* string filter_namespace */
+        2:
+          message.filterNamespace = reader.string();
+          break;
+        case /* string filter_target_key_fingerprint */
+        3:
+          message.filterTargetKeyFingerprint = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterNamespace !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.filterNamespace);
+    if (message.filterTargetKeyFingerprint !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.filterTargetKeyFingerprint);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListNamespaceDelegationRequest = new ListNamespaceDelegationRequest$Type();
+class ListNamespaceDelegationResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListNamespaceDelegationResponse",
+      [
+        {
+          no: 1,
+          name: "results",
+          kind: "message",
+          repeat: 2,
+          T: () => ListNamespaceDelegationResponse_Result
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.results = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.ListNamespaceDelegationResponse.Result results */
+        1:
+          message.results.push(
+            ListNamespaceDelegationResponse_Result.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) {
+    for (let i = 0; i < message.results.length; i++)
+      ListNamespaceDelegationResponse_Result.internalBinaryWrite(
+        message.results[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;
+  }
+}
+const ListNamespaceDelegationResponse = new ListNamespaceDelegationResponse$Type();
+class ListNamespaceDelegationResponse_Result$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListNamespaceDelegationResponse.Result",
+      [
+        {
+          no: 1,
+          name: "context",
+          kind: "message",
+          T: () => BaseResult
+        },
+        {
+          no: 2,
+          name: "item",
+          kind: "message",
+          T: () => NamespaceDelegation
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseResult context */
+        1:
+          message.context = BaseResult.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.context
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.NamespaceDelegation item */
+        2:
+          message.item = NamespaceDelegation.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.item
+          );
+          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) {
+    if (message.context)
+      BaseResult.internalBinaryWrite(
+        message.context,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      NamespaceDelegation.internalBinaryWrite(
+        message.item,
+        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;
+  }
+}
+const ListNamespaceDelegationResponse_Result = new ListNamespaceDelegationResponse_Result$Type();
+class ListDecentralizedNamespaceDefinitionRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListDecentralizedNamespaceDefinitionRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "filter_namespace",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.filterNamespace = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* string filter_namespace */
+        2:
+          message.filterNamespace = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterNamespace !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.filterNamespace);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListDecentralizedNamespaceDefinitionRequest = new ListDecentralizedNamespaceDefinitionRequest$Type();
+class ListDecentralizedNamespaceDefinitionResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListDecentralizedNamespaceDefinitionResponse",
+      [
+        {
+          no: 1,
+          name: "results",
+          kind: "message",
+          repeat: 2,
+          T: () => ListDecentralizedNamespaceDefinitionResponse_Result
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.results = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.ListDecentralizedNamespaceDefinitionResponse.Result results */
+        1:
+          message.results.push(
+            ListDecentralizedNamespaceDefinitionResponse_Result.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) {
+    for (let i = 0; i < message.results.length; i++)
+      ListDecentralizedNamespaceDefinitionResponse_Result.internalBinaryWrite(
+        message.results[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;
+  }
+}
+const ListDecentralizedNamespaceDefinitionResponse = new ListDecentralizedNamespaceDefinitionResponse$Type();
+class ListDecentralizedNamespaceDefinitionResponse_Result$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListDecentralizedNamespaceDefinitionResponse.Result",
+      [
+        {
+          no: 1,
+          name: "context",
+          kind: "message",
+          T: () => BaseResult
+        },
+        {
+          no: 2,
+          name: "item",
+          kind: "message",
+          T: () => DecentralizedNamespaceDefinition
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseResult context */
+        1:
+          message.context = BaseResult.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.context
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.DecentralizedNamespaceDefinition item */
+        2:
+          message.item = DecentralizedNamespaceDefinition.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.item
+          );
+          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) {
+    if (message.context)
+      BaseResult.internalBinaryWrite(
+        message.context,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      DecentralizedNamespaceDefinition.internalBinaryWrite(
+        message.item,
+        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;
+  }
+}
+const ListDecentralizedNamespaceDefinitionResponse_Result = new ListDecentralizedNamespaceDefinitionResponse_Result$Type();
+class ListOwnerToKeyMappingRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListOwnerToKeyMappingRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "filter_key_owner_type",
+          kind: "scalar",
+          T: 9
+        },
+        {
+          no: 3,
+          name: "filter_key_owner_uid",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.filterKeyOwnerType = "";
+    message.filterKeyOwnerUid = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* string filter_key_owner_type */
+        2:
+          message.filterKeyOwnerType = reader.string();
+          break;
+        case /* string filter_key_owner_uid */
+        3:
+          message.filterKeyOwnerUid = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterKeyOwnerType !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.filterKeyOwnerType);
+    if (message.filterKeyOwnerUid !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.filterKeyOwnerUid);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListOwnerToKeyMappingRequest = new ListOwnerToKeyMappingRequest$Type();
+class ListOwnerToKeyMappingResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListOwnerToKeyMappingResponse",
+      [
+        {
+          no: 1,
+          name: "results",
+          kind: "message",
+          repeat: 2,
+          T: () => ListOwnerToKeyMappingResponse_Result
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.results = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.ListOwnerToKeyMappingResponse.Result results */
+        1:
+          message.results.push(
+            ListOwnerToKeyMappingResponse_Result.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) {
+    for (let i = 0; i < message.results.length; i++)
+      ListOwnerToKeyMappingResponse_Result.internalBinaryWrite(
+        message.results[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;
+  }
+}
+const ListOwnerToKeyMappingResponse = new ListOwnerToKeyMappingResponse$Type();
+class ListOwnerToKeyMappingResponse_Result$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListOwnerToKeyMappingResponse.Result",
+      [
+        {
+          no: 1,
+          name: "context",
+          kind: "message",
+          T: () => BaseResult
+        },
+        {
+          no: 2,
+          name: "item",
+          kind: "message",
+          T: () => OwnerToKeyMapping
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseResult context */
+        1:
+          message.context = BaseResult.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.context
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.OwnerToKeyMapping item */
+        2:
+          message.item = OwnerToKeyMapping.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.item
+          );
+          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) {
+    if (message.context)
+      BaseResult.internalBinaryWrite(
+        message.context,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      OwnerToKeyMapping.internalBinaryWrite(
+        message.item,
+        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;
+  }
+}
+const ListOwnerToKeyMappingResponse_Result = new ListOwnerToKeyMappingResponse_Result$Type();
+class ListPartyToKeyMappingRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListPartyToKeyMappingRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "filter_party",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.filterParty = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* string filter_party */
+        2:
+          message.filterParty = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterParty !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.filterParty);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPartyToKeyMappingRequest = new ListPartyToKeyMappingRequest$Type();
+class ListPartyToKeyMappingResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListPartyToKeyMappingResponse",
+      [
+        {
+          no: 1,
+          name: "results",
+          kind: "message",
+          repeat: 2,
+          T: () => ListPartyToKeyMappingResponse_Result
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.results = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.ListPartyToKeyMappingResponse.Result results */
+        1:
+          message.results.push(
+            ListPartyToKeyMappingResponse_Result.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) {
+    for (let i = 0; i < message.results.length; i++)
+      ListPartyToKeyMappingResponse_Result.internalBinaryWrite(
+        message.results[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;
+  }
+}
+const ListPartyToKeyMappingResponse = new ListPartyToKeyMappingResponse$Type();
+class ListPartyToKeyMappingResponse_Result$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListPartyToKeyMappingResponse.Result",
+      [
+        {
+          no: 1,
+          name: "context",
+          kind: "message",
+          T: () => BaseResult
+        },
+        {
+          no: 2,
+          name: "item",
+          kind: "message",
+          T: () => PartyToKeyMapping
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseResult context */
+        1:
+          message.context = BaseResult.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.context
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.PartyToKeyMapping item */
+        2:
+          message.item = PartyToKeyMapping.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.item
+          );
+          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) {
+    if (message.context)
+      BaseResult.internalBinaryWrite(
+        message.context,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      PartyToKeyMapping.internalBinaryWrite(
+        message.item,
+        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;
+  }
+}
+const ListPartyToKeyMappingResponse_Result = new ListPartyToKeyMappingResponse_Result$Type();
+class ListSynchronizerTrustCertificateRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListSynchronizerTrustCertificateRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "filter_uid",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.filterUid = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* string filter_uid */
+        2:
+          message.filterUid = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterUid !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.filterUid);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListSynchronizerTrustCertificateRequest = new ListSynchronizerTrustCertificateRequest$Type();
+class ListSynchronizerTrustCertificateResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListSynchronizerTrustCertificateResponse",
+      [
+        {
+          no: 1,
+          name: "results",
+          kind: "message",
+          repeat: 2,
+          T: () => ListSynchronizerTrustCertificateResponse_Result
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.results = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.ListSynchronizerTrustCertificateResponse.Result results */
+        1:
+          message.results.push(
+            ListSynchronizerTrustCertificateResponse_Result.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) {
+    for (let i = 0; i < message.results.length; i++)
+      ListSynchronizerTrustCertificateResponse_Result.internalBinaryWrite(
+        message.results[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;
+  }
+}
+const ListSynchronizerTrustCertificateResponse = new ListSynchronizerTrustCertificateResponse$Type();
+class ListSynchronizerTrustCertificateResponse_Result$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListSynchronizerTrustCertificateResponse.Result",
+      [
+        {
+          no: 1,
+          name: "context",
+          kind: "message",
+          T: () => BaseResult
+        },
+        {
+          no: 2,
+          name: "item",
+          kind: "message",
+          T: () => SynchronizerTrustCertificate
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseResult context */
+        1:
+          message.context = BaseResult.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.context
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.SynchronizerTrustCertificate item */
+        2:
+          message.item = SynchronizerTrustCertificate.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.item
+          );
+          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) {
+    if (message.context)
+      BaseResult.internalBinaryWrite(
+        message.context,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      SynchronizerTrustCertificate.internalBinaryWrite(
+        message.item,
+        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;
+  }
+}
+const ListSynchronizerTrustCertificateResponse_Result = new ListSynchronizerTrustCertificateResponse_Result$Type();
+class ListParticipantSynchronizerPermissionRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListParticipantSynchronizerPermissionRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "filter_uid",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.filterUid = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* string filter_uid */
+        2:
+          message.filterUid = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterUid !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.filterUid);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListParticipantSynchronizerPermissionRequest = new ListParticipantSynchronizerPermissionRequest$Type();
+class ListParticipantSynchronizerPermissionResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListParticipantSynchronizerPermissionResponse",
+      [
+        {
+          no: 1,
+          name: "results",
+          kind: "message",
+          repeat: 2,
+          T: () => ListParticipantSynchronizerPermissionResponse_Result
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.results = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.ListParticipantSynchronizerPermissionResponse.Result results */
+        1:
+          message.results.push(
+            ListParticipantSynchronizerPermissionResponse_Result.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) {
+    for (let i = 0; i < message.results.length; i++)
+      ListParticipantSynchronizerPermissionResponse_Result.internalBinaryWrite(
+        message.results[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;
+  }
+}
+const ListParticipantSynchronizerPermissionResponse = new ListParticipantSynchronizerPermissionResponse$Type();
+class ListParticipantSynchronizerPermissionResponse_Result$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListParticipantSynchronizerPermissionResponse.Result",
+      [
+        {
+          no: 1,
+          name: "context",
+          kind: "message",
+          T: () => BaseResult
+        },
+        {
+          no: 2,
+          name: "item",
+          kind: "message",
+          T: () => ParticipantSynchronizerPermission
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseResult context */
+        1:
+          message.context = BaseResult.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.context
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.ParticipantSynchronizerPermission item */
+        2:
+          message.item = ParticipantSynchronizerPermission.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.item
+          );
+          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) {
+    if (message.context)
+      BaseResult.internalBinaryWrite(
+        message.context,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      ParticipantSynchronizerPermission.internalBinaryWrite(
+        message.item,
+        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;
+  }
+}
+const ListParticipantSynchronizerPermissionResponse_Result = new ListParticipantSynchronizerPermissionResponse_Result$Type();
+class ListPartyHostingLimitsRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListPartyHostingLimitsRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "filter_uid",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.filterUid = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* string filter_uid */
+        2:
+          message.filterUid = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterUid !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.filterUid);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPartyHostingLimitsRequest = new ListPartyHostingLimitsRequest$Type();
+class ListPartyHostingLimitsResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListPartyHostingLimitsResponse",
+      [
+        {
+          no: 1,
+          name: "results",
+          kind: "message",
+          repeat: 2,
+          T: () => ListPartyHostingLimitsResponse_Result
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.results = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.ListPartyHostingLimitsResponse.Result results */
+        1:
+          message.results.push(
+            ListPartyHostingLimitsResponse_Result.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) {
+    for (let i = 0; i < message.results.length; i++)
+      ListPartyHostingLimitsResponse_Result.internalBinaryWrite(
+        message.results[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;
+  }
+}
+const ListPartyHostingLimitsResponse = new ListPartyHostingLimitsResponse$Type();
+class ListPartyHostingLimitsResponse_Result$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListPartyHostingLimitsResponse.Result",
+      [
+        {
+          no: 1,
+          name: "context",
+          kind: "message",
+          T: () => BaseResult
+        },
+        {
+          no: 2,
+          name: "item",
+          kind: "message",
+          T: () => PartyHostingLimits
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseResult context */
+        1:
+          message.context = BaseResult.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.context
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.PartyHostingLimits item */
+        2:
+          message.item = PartyHostingLimits.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.item
+          );
+          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) {
+    if (message.context)
+      BaseResult.internalBinaryWrite(
+        message.context,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      PartyHostingLimits.internalBinaryWrite(
+        message.item,
+        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;
+  }
+}
+const ListPartyHostingLimitsResponse_Result = new ListPartyHostingLimitsResponse_Result$Type();
+class ListVettedPackagesRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListVettedPackagesRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "filter_participant",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.filterParticipant = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* string filter_participant */
+        2:
+          message.filterParticipant = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterParticipant !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.filterParticipant);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListVettedPackagesRequest = new ListVettedPackagesRequest$Type();
+class ListVettedPackagesResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListVettedPackagesResponse",
+      [
+        {
+          no: 1,
+          name: "results",
+          kind: "message",
+          repeat: 2,
+          T: () => ListVettedPackagesResponse_Result
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.results = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.ListVettedPackagesResponse.Result results */
+        1:
+          message.results.push(
+            ListVettedPackagesResponse_Result.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) {
+    for (let i = 0; i < message.results.length; i++)
+      ListVettedPackagesResponse_Result.internalBinaryWrite(
+        message.results[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;
+  }
+}
+const ListVettedPackagesResponse = new ListVettedPackagesResponse$Type();
+class ListVettedPackagesResponse_Result$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListVettedPackagesResponse.Result",
+      [
+        {
+          no: 1,
+          name: "context",
+          kind: "message",
+          T: () => BaseResult
+        },
+        {
+          no: 2,
+          name: "item",
+          kind: "message",
+          T: () => VettedPackages
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseResult context */
+        1:
+          message.context = BaseResult.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.context
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.VettedPackages item */
+        2:
+          message.item = VettedPackages.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.item
+          );
+          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) {
+    if (message.context)
+      BaseResult.internalBinaryWrite(
+        message.context,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      VettedPackages.internalBinaryWrite(
+        message.item,
+        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;
+  }
+}
+const ListVettedPackagesResponse_Result = new ListVettedPackagesResponse_Result$Type();
+class ListPartyToParticipantRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListPartyToParticipantRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "filter_party",
+          kind: "scalar",
+          T: 9
+        },
+        {
+          no: 3,
+          name: "filter_participant",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.filterParty = "";
+    message.filterParticipant = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* string filter_party */
+        2:
+          message.filterParty = reader.string();
+          break;
+        case /* string filter_participant */
+        3:
+          message.filterParticipant = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterParty !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.filterParty);
+    if (message.filterParticipant !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.filterParticipant);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPartyToParticipantRequest = new ListPartyToParticipantRequest$Type();
+class ListPartyToParticipantResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListPartyToParticipantResponse",
+      [
+        {
+          no: 2,
+          name: "results",
+          kind: "message",
+          repeat: 2,
+          T: () => ListPartyToParticipantResponse_Result
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.results = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.ListPartyToParticipantResponse.Result results */
+        2:
+          message.results.push(
+            ListPartyToParticipantResponse_Result.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) {
+    for (let i = 0; i < message.results.length; i++)
+      ListPartyToParticipantResponse_Result.internalBinaryWrite(
+        message.results[i],
+        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;
+  }
+}
+const ListPartyToParticipantResponse = new ListPartyToParticipantResponse$Type();
+class ListPartyToParticipantResponse_Result$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListPartyToParticipantResponse.Result",
+      [
+        {
+          no: 1,
+          name: "context",
+          kind: "message",
+          T: () => BaseResult
+        },
+        {
+          no: 2,
+          name: "item",
+          kind: "message",
+          T: () => PartyToParticipant
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseResult context */
+        1:
+          message.context = BaseResult.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.context
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.PartyToParticipant item */
+        2:
+          message.item = PartyToParticipant.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.item
+          );
+          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) {
+    if (message.context)
+      BaseResult.internalBinaryWrite(
+        message.context,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      PartyToParticipant.internalBinaryWrite(
+        message.item,
+        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;
+  }
+}
+const ListPartyToParticipantResponse_Result = new ListPartyToParticipantResponse_Result$Type();
+class ListSynchronizerParametersStateRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListSynchronizerParametersStateRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "filter_synchronizer_id",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.filterSynchronizerId = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* string filter_synchronizer_id */
+        2:
+          message.filterSynchronizerId = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterSynchronizerId !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.filterSynchronizerId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListSynchronizerParametersStateRequest = new ListSynchronizerParametersStateRequest$Type();
+class ListSynchronizerParametersStateResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListSynchronizerParametersStateResponse",
+      [
+        {
+          no: 1,
+          name: "results",
+          kind: "message",
+          repeat: 2,
+          T: () => ListSynchronizerParametersStateResponse_Result
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.results = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.ListSynchronizerParametersStateResponse.Result results */
+        1:
+          message.results.push(
+            ListSynchronizerParametersStateResponse_Result.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) {
+    for (let i = 0; i < message.results.length; i++)
+      ListSynchronizerParametersStateResponse_Result.internalBinaryWrite(
+        message.results[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;
+  }
+}
+const ListSynchronizerParametersStateResponse = new ListSynchronizerParametersStateResponse$Type();
+class ListSynchronizerParametersStateResponse_Result$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListSynchronizerParametersStateResponse.Result",
+      [
+        {
+          no: 1,
+          name: "context",
+          kind: "message",
+          T: () => BaseResult
+        },
+        {
+          no: 2,
+          name: "item",
+          kind: "message",
+          T: () => DynamicSynchronizerParameters
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseResult context */
+        1:
+          message.context = BaseResult.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.context
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.DynamicSynchronizerParameters item */
+        2:
+          message.item = DynamicSynchronizerParameters.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.item
+          );
+          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) {
+    if (message.context)
+      BaseResult.internalBinaryWrite(
+        message.context,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      DynamicSynchronizerParameters.internalBinaryWrite(
+        message.item,
+        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;
+  }
+}
+const ListSynchronizerParametersStateResponse_Result = new ListSynchronizerParametersStateResponse_Result$Type();
+class ListMediatorSynchronizerStateRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListMediatorSynchronizerStateRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "filter_synchronizer_id",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.filterSynchronizerId = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* string filter_synchronizer_id */
+        2:
+          message.filterSynchronizerId = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterSynchronizerId !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.filterSynchronizerId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListMediatorSynchronizerStateRequest = new ListMediatorSynchronizerStateRequest$Type();
+class ListMediatorSynchronizerStateResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListMediatorSynchronizerStateResponse",
+      [
+        {
+          no: 1,
+          name: "results",
+          kind: "message",
+          repeat: 2,
+          T: () => ListMediatorSynchronizerStateResponse_Result
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.results = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.ListMediatorSynchronizerStateResponse.Result results */
+        1:
+          message.results.push(
+            ListMediatorSynchronizerStateResponse_Result.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) {
+    for (let i = 0; i < message.results.length; i++)
+      ListMediatorSynchronizerStateResponse_Result.internalBinaryWrite(
+        message.results[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;
+  }
+}
+const ListMediatorSynchronizerStateResponse = new ListMediatorSynchronizerStateResponse$Type();
+class ListMediatorSynchronizerStateResponse_Result$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListMediatorSynchronizerStateResponse.Result",
+      [
+        {
+          no: 1,
+          name: "context",
+          kind: "message",
+          T: () => BaseResult
+        },
+        {
+          no: 2,
+          name: "item",
+          kind: "message",
+          T: () => MediatorSynchronizerState
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseResult context */
+        1:
+          message.context = BaseResult.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.context
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.MediatorSynchronizerState item */
+        2:
+          message.item = MediatorSynchronizerState.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.item
+          );
+          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) {
+    if (message.context)
+      BaseResult.internalBinaryWrite(
+        message.context,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      MediatorSynchronizerState.internalBinaryWrite(
+        message.item,
+        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;
+  }
+}
+const ListMediatorSynchronizerStateResponse_Result = new ListMediatorSynchronizerStateResponse_Result$Type();
+class ListSequencerSynchronizerStateRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListSequencerSynchronizerStateRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "filter_synchronizer_id",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.filterSynchronizerId = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* string filter_synchronizer_id */
+        2:
+          message.filterSynchronizerId = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterSynchronizerId !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.filterSynchronizerId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListSequencerSynchronizerStateRequest = new ListSequencerSynchronizerStateRequest$Type();
+class ListSequencerSynchronizerStateResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListSequencerSynchronizerStateResponse",
+      [
+        {
+          no: 1,
+          name: "results",
+          kind: "message",
+          repeat: 2,
+          T: () => ListSequencerSynchronizerStateResponse_Result
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.results = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.ListSequencerSynchronizerStateResponse.Result results */
+        1:
+          message.results.push(
+            ListSequencerSynchronizerStateResponse_Result.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) {
+    for (let i = 0; i < message.results.length; i++)
+      ListSequencerSynchronizerStateResponse_Result.internalBinaryWrite(
+        message.results[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;
+  }
+}
+const ListSequencerSynchronizerStateResponse = new ListSequencerSynchronizerStateResponse$Type();
+class ListSequencerSynchronizerStateResponse_Result$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListSequencerSynchronizerStateResponse.Result",
+      [
+        {
+          no: 1,
+          name: "context",
+          kind: "message",
+          T: () => BaseResult
+        },
+        {
+          no: 2,
+          name: "item",
+          kind: "message",
+          T: () => SequencerSynchronizerState
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseResult context */
+        1:
+          message.context = BaseResult.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.context
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.SequencerSynchronizerState item */
+        2:
+          message.item = SequencerSynchronizerState.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.item
+          );
+          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) {
+    if (message.context)
+      BaseResult.internalBinaryWrite(
+        message.context,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      SequencerSynchronizerState.internalBinaryWrite(
+        message.item,
+        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;
+  }
+}
+const ListSequencerSynchronizerStateResponse_Result = new ListSequencerSynchronizerStateResponse_Result$Type();
+class ListPurgeTopologyTransactionRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListPurgeTopologyTransactionRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "filter_synchronizer_id",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.filterSynchronizerId = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* string filter_synchronizer_id */
+        2:
+          message.filterSynchronizerId = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterSynchronizerId !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.filterSynchronizerId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPurgeTopologyTransactionRequest = new ListPurgeTopologyTransactionRequest$Type();
+class ListPurgeTopologyTransactionResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListPurgeTopologyTransactionResponse",
+      [
+        {
+          no: 1,
+          name: "results",
+          kind: "message",
+          repeat: 2,
+          T: () => ListPurgeTopologyTransactionResponse_Result
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.results = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.ListPurgeTopologyTransactionResponse.Result results */
+        1:
+          message.results.push(
+            ListPurgeTopologyTransactionResponse_Result.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) {
+    for (let i = 0; i < message.results.length; i++)
+      ListPurgeTopologyTransactionResponse_Result.internalBinaryWrite(
+        message.results[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;
+  }
+}
+const ListPurgeTopologyTransactionResponse = new ListPurgeTopologyTransactionResponse$Type();
+class ListPurgeTopologyTransactionResponse_Result$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListPurgeTopologyTransactionResponse.Result",
+      [
+        {
+          no: 1,
+          name: "context",
+          kind: "message",
+          T: () => BaseResult
+        },
+        {
+          no: 2,
+          name: "item",
+          kind: "message",
+          T: () => PurgeTopologyTransaction
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseResult context */
+        1:
+          message.context = BaseResult.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.context
+          );
+          break;
+        case /* com.digitalasset.canton.protocol.v30.PurgeTopologyTransaction item */
+        2:
+          message.item = PurgeTopologyTransaction.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.item
+          );
+          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) {
+    if (message.context)
+      BaseResult.internalBinaryWrite(
+        message.context,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      PurgeTopologyTransaction.internalBinaryWrite(
+        message.item,
+        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;
+  }
+}
+const ListPurgeTopologyTransactionResponse_Result = new ListPurgeTopologyTransactionResponse_Result$Type();
+class ListAvailableStoresRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListAvailableStoresRequest",
+      []
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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) {
+        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) {
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListAvailableStoresRequest = new ListAvailableStoresRequest$Type();
+class ListAvailableStoresResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListAvailableStoresResponse",
+      [
+        {
+          no: 1,
+          name: "store_ids",
+          kind: "message",
+          repeat: 2,
+          T: () => StoreId
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.storeIds = [];
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.StoreId store_ids */
+        1:
+          message.storeIds.push(
+            StoreId.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) {
+    for (let i = 0; i < message.storeIds.length; i++)
+      StoreId.internalBinaryWrite(
+        message.storeIds[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;
+  }
+}
+const ListAvailableStoresResponse = new ListAvailableStoresResponse$Type();
+class ListAllRequest$Type extends MessageType {
+  constructor() {
+    super("com.digitalasset.canton.topology.admin.v30.ListAllRequest", [
+      { no: 1, name: "base_query", kind: "message", T: () => BaseQuery },
+      {
+        no: 2,
+        name: "exclude_mappings",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+      },
+      {
+        no: 3,
+        name: "filter_namespace",
+        kind: "scalar",
+        T: 9
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.excludeMappings = [];
+    message.filterNamespace = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* repeated string exclude_mappings */
+        2:
+          message.excludeMappings.push(reader.string());
+          break;
+        case /* string filter_namespace */
+        3:
+          message.filterNamespace = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.excludeMappings.length; i++)
+      writer.tag(2, WireType.LengthDelimited).string(message.excludeMappings[i]);
+    if (message.filterNamespace !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.filterNamespace);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListAllRequest = new ListAllRequest$Type();
+class ExportTopologySnapshotRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ExportTopologySnapshotRequest",
+      [
+        {
+          no: 1,
+          name: "base_query",
+          kind: "message",
+          T: () => BaseQuery
+        },
+        {
+          no: 2,
+          name: "exclude_mappings",
+          kind: "scalar",
+          repeat: 2,
+          T: 9
+        },
+        {
+          no: 3,
+          name: "filter_namespace",
+          kind: "scalar",
+          T: 9
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.excludeMappings = [];
+    message.filterNamespace = "";
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.BaseQuery base_query */
+        1:
+          message.baseQuery = BaseQuery.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.baseQuery
+          );
+          break;
+        case /* repeated string exclude_mappings */
+        2:
+          message.excludeMappings.push(reader.string());
+          break;
+        case /* string filter_namespace */
+        3:
+          message.filterNamespace = 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) {
+    if (message.baseQuery)
+      BaseQuery.internalBinaryWrite(
+        message.baseQuery,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.excludeMappings.length; i++)
+      writer.tag(2, WireType.LengthDelimited).string(message.excludeMappings[i]);
+    if (message.filterNamespace !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.filterNamespace);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ExportTopologySnapshotRequest = new ExportTopologySnapshotRequest$Type();
+class ListAllResponse$Type extends MessageType {
+  constructor() {
+    super("com.digitalasset.canton.topology.admin.v30.ListAllResponse", [
+      {
+        no: 1,
+        name: "result",
+        kind: "message",
+        T: () => TopologyTransactions
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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.digitalasset.canton.topology.admin.v30.TopologyTransactions result */
+        1:
+          message.result = TopologyTransactions.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.result
+          );
+          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) {
+    if (message.result)
+      TopologyTransactions.internalBinaryWrite(
+        message.result,
+        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;
+  }
+}
+const ListAllResponse = new ListAllResponse$Type();
+class ExportTopologySnapshotResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ExportTopologySnapshotResponse",
+      [
+        {
+          no: 1,
+          name: "chunk",
+          kind: "scalar",
+          T: 12
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.chunk = new Uint8Array(0);
+    if (value !== void 0)
+      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 /* bytes chunk */
+        1:
+          message.chunk = reader.bytes();
+          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) {
+    if (message.chunk.length)
+      writer.tag(1, WireType.LengthDelimited).bytes(message.chunk);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ExportTopologySnapshotResponse = new ExportTopologySnapshotResponse$Type();
+class GenesisStateRequest$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.GenesisStateRequest",
+      [
+        {
+          no: 1,
+          name: "synchronizer_store",
+          kind: "message",
+          T: () => StoreId
+        },
+        {
+          no: 2,
+          name: "timestamp",
+          kind: "message",
+          T: () => Timestamp
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      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 /* optional com.digitalasset.canton.topology.admin.v30.StoreId synchronizer_store */
+        1:
+          message.synchronizerStore = StoreId.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.synchronizerStore
+          );
+          break;
+        case /* google.protobuf.Timestamp timestamp */
+        2:
+          message.timestamp = Timestamp.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.timestamp
+          );
+          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) {
+    if (message.synchronizerStore)
+      StoreId.internalBinaryWrite(
+        message.synchronizerStore,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.timestamp)
+      Timestamp.internalBinaryWrite(
+        message.timestamp,
+        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;
+  }
+}
+const GenesisStateRequest = new GenesisStateRequest$Type();
+class GenesisStateResponse$Type extends MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.GenesisStateResponse",
+      [
+        {
+          no: 1,
+          name: "chunk",
+          kind: "scalar",
+          T: 12
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.chunk = new Uint8Array(0);
+    if (value !== void 0)
+      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 /* bytes chunk */
+        1:
+          message.chunk = reader.bytes();
+          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) {
+    if (message.chunk.length)
+      writer.tag(1, WireType.LengthDelimited).bytes(message.chunk);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const GenesisStateResponse = new GenesisStateResponse$Type();
+const TopologyManagerReadService = new ServiceType(
+  "com.digitalasset.canton.topology.admin.v30.TopologyManagerReadService",
+  [
+    {
+      name: "ListNamespaceDelegation",
+      options: {},
+      I: ListNamespaceDelegationRequest,
+      O: ListNamespaceDelegationResponse
+    },
+    {
+      name: "ListDecentralizedNamespaceDefinition",
+      options: {},
+      I: ListDecentralizedNamespaceDefinitionRequest,
+      O: ListDecentralizedNamespaceDefinitionResponse
+    },
+    {
+      name: "ListOwnerToKeyMapping",
+      options: {},
+      I: ListOwnerToKeyMappingRequest,
+      O: ListOwnerToKeyMappingResponse
+    },
+    {
+      name: "ListPartyToKeyMapping",
+      options: {},
+      I: ListPartyToKeyMappingRequest,
+      O: ListPartyToKeyMappingResponse
+    },
+    {
+      name: "ListSynchronizerTrustCertificate",
+      options: {},
+      I: ListSynchronizerTrustCertificateRequest,
+      O: ListSynchronizerTrustCertificateResponse
+    },
+    {
+      name: "ListParticipantSynchronizerPermission",
+      options: {},
+      I: ListParticipantSynchronizerPermissionRequest,
+      O: ListParticipantSynchronizerPermissionResponse
+    },
+    {
+      name: "ListPartyHostingLimits",
+      options: {},
+      I: ListPartyHostingLimitsRequest,
+      O: ListPartyHostingLimitsResponse
+    },
+    {
+      name: "ListVettedPackages",
+      options: {},
+      I: ListVettedPackagesRequest,
+      O: ListVettedPackagesResponse
+    },
+    {
+      name: "ListPartyToParticipant",
+      options: {},
+      I: ListPartyToParticipantRequest,
+      O: ListPartyToParticipantResponse
+    },
+    {
+      name: "ListSynchronizerParametersState",
+      options: {},
+      I: ListSynchronizerParametersStateRequest,
+      O: ListSynchronizerParametersStateResponse
+    },
+    {
+      name: "ListMediatorSynchronizerState",
+      options: {},
+      I: ListMediatorSynchronizerStateRequest,
+      O: ListMediatorSynchronizerStateResponse
+    },
+    {
+      name: "ListSequencerSynchronizerState",
+      options: {},
+      I: ListSequencerSynchronizerStateRequest,
+      O: ListSequencerSynchronizerStateResponse
+    },
+    {
+      name: "ListPurgeTopologyTransaction",
+      options: {},
+      I: ListPurgeTopologyTransactionRequest,
+      O: ListPurgeTopologyTransactionResponse
+    },
+    {
+      name: "ListAvailableStores",
+      options: {},
+      I: ListAvailableStoresRequest,
+      O: ListAvailableStoresResponse
+    },
+    { name: "ListAll", options: {}, I: ListAllRequest, O: ListAllResponse },
+    {
+      name: "ExportTopologySnapshot",
+      serverStreaming: true,
+      options: {},
+      I: ExportTopologySnapshotRequest,
+      O: ExportTopologySnapshotResponse
+    },
+    {
+      name: "GenesisState",
+      serverStreaming: true,
+      options: {},
+      I: GenesisStateRequest,
+      O: GenesisStateResponse
+    }
+  ]
+);
+export {
+  BaseQuery,
+  BaseQuery_TimeRange,
+  BaseResult,
+  ExportTopologySnapshotRequest,
+  ExportTopologySnapshotResponse,
+  GenesisStateRequest,
+  GenesisStateResponse,
+  ListAllRequest,
+  ListAllResponse,
+  ListAvailableStoresRequest,
+  ListAvailableStoresResponse,
+  ListDecentralizedNamespaceDefinitionRequest,
+  ListDecentralizedNamespaceDefinitionResponse,
+  ListDecentralizedNamespaceDefinitionResponse_Result,
+  ListMediatorSynchronizerStateRequest,
+  ListMediatorSynchronizerStateResponse,
+  ListMediatorSynchronizerStateResponse_Result,
+  ListNamespaceDelegationRequest,
+  ListNamespaceDelegationResponse,
+  ListNamespaceDelegationResponse_Result,
+  ListOwnerToKeyMappingRequest,
+  ListOwnerToKeyMappingResponse,
+  ListOwnerToKeyMappingResponse_Result,
+  ListParticipantSynchronizerPermissionRequest,
+  ListParticipantSynchronizerPermissionResponse,
+  ListParticipantSynchronizerPermissionResponse_Result,
+  ListPartyHostingLimitsRequest,
+  ListPartyHostingLimitsResponse,
+  ListPartyHostingLimitsResponse_Result,
+  ListPartyToKeyMappingRequest,
+  ListPartyToKeyMappingResponse,
+  ListPartyToKeyMappingResponse_Result,
+  ListPartyToParticipantRequest,
+  ListPartyToParticipantResponse,
+  ListPartyToParticipantResponse_Result,
+  ListPurgeTopologyTransactionRequest,
+  ListPurgeTopologyTransactionResponse,
+  ListPurgeTopologyTransactionResponse_Result,
+  ListSequencerSynchronizerStateRequest,
+  ListSequencerSynchronizerStateResponse,
+  ListSequencerSynchronizerStateResponse_Result,
+  ListSynchronizerParametersStateRequest,
+  ListSynchronizerParametersStateResponse,
+  ListSynchronizerParametersStateResponse_Result,
+  ListSynchronizerTrustCertificateRequest,
+  ListSynchronizerTrustCertificateResponse,
+  ListSynchronizerTrustCertificateResponse_Result,
+  ListVettedPackagesRequest,
+  ListVettedPackagesResponse,
+  ListVettedPackagesResponse_Result,
+  TopologyManagerReadService
+};
+//# sourceMappingURL=topology_manager_read_service.js.map