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

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

@@ -0,0 +1,4758 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var topology_manager_read_service_exports = {};
+__export(topology_manager_read_service_exports, {
+  BaseQuery: () => BaseQuery,
+  BaseQuery_TimeRange: () => BaseQuery_TimeRange,
+  BaseResult: () => BaseResult,
+  ExportTopologySnapshotRequest: () => ExportTopologySnapshotRequest,
+  ExportTopologySnapshotResponse: () => ExportTopologySnapshotResponse,
+  GenesisStateRequest: () => GenesisStateRequest,
+  GenesisStateResponse: () => GenesisStateResponse,
+  ListAllRequest: () => ListAllRequest,
+  ListAllResponse: () => ListAllResponse,
+  ListAvailableStoresRequest: () => ListAvailableStoresRequest,
+  ListAvailableStoresResponse: () => ListAvailableStoresResponse,
+  ListDecentralizedNamespaceDefinitionRequest: () => ListDecentralizedNamespaceDefinitionRequest,
+  ListDecentralizedNamespaceDefinitionResponse: () => ListDecentralizedNamespaceDefinitionResponse,
+  ListDecentralizedNamespaceDefinitionResponse_Result: () => ListDecentralizedNamespaceDefinitionResponse_Result,
+  ListMediatorSynchronizerStateRequest: () => ListMediatorSynchronizerStateRequest,
+  ListMediatorSynchronizerStateResponse: () => ListMediatorSynchronizerStateResponse,
+  ListMediatorSynchronizerStateResponse_Result: () => ListMediatorSynchronizerStateResponse_Result,
+  ListNamespaceDelegationRequest: () => ListNamespaceDelegationRequest,
+  ListNamespaceDelegationResponse: () => ListNamespaceDelegationResponse,
+  ListNamespaceDelegationResponse_Result: () => ListNamespaceDelegationResponse_Result,
+  ListOwnerToKeyMappingRequest: () => ListOwnerToKeyMappingRequest,
+  ListOwnerToKeyMappingResponse: () => ListOwnerToKeyMappingResponse,
+  ListOwnerToKeyMappingResponse_Result: () => ListOwnerToKeyMappingResponse_Result,
+  ListParticipantSynchronizerPermissionRequest: () => ListParticipantSynchronizerPermissionRequest,
+  ListParticipantSynchronizerPermissionResponse: () => ListParticipantSynchronizerPermissionResponse,
+  ListParticipantSynchronizerPermissionResponse_Result: () => ListParticipantSynchronizerPermissionResponse_Result,
+  ListPartyHostingLimitsRequest: () => ListPartyHostingLimitsRequest,
+  ListPartyHostingLimitsResponse: () => ListPartyHostingLimitsResponse,
+  ListPartyHostingLimitsResponse_Result: () => ListPartyHostingLimitsResponse_Result,
+  ListPartyToKeyMappingRequest: () => ListPartyToKeyMappingRequest,
+  ListPartyToKeyMappingResponse: () => ListPartyToKeyMappingResponse,
+  ListPartyToKeyMappingResponse_Result: () => ListPartyToKeyMappingResponse_Result,
+  ListPartyToParticipantRequest: () => ListPartyToParticipantRequest,
+  ListPartyToParticipantResponse: () => ListPartyToParticipantResponse,
+  ListPartyToParticipantResponse_Result: () => ListPartyToParticipantResponse_Result,
+  ListPurgeTopologyTransactionRequest: () => ListPurgeTopologyTransactionRequest,
+  ListPurgeTopologyTransactionResponse: () => ListPurgeTopologyTransactionResponse,
+  ListPurgeTopologyTransactionResponse_Result: () => ListPurgeTopologyTransactionResponse_Result,
+  ListSequencerSynchronizerStateRequest: () => ListSequencerSynchronizerStateRequest,
+  ListSequencerSynchronizerStateResponse: () => ListSequencerSynchronizerStateResponse,
+  ListSequencerSynchronizerStateResponse_Result: () => ListSequencerSynchronizerStateResponse_Result,
+  ListSynchronizerParametersStateRequest: () => ListSynchronizerParametersStateRequest,
+  ListSynchronizerParametersStateResponse: () => ListSynchronizerParametersStateResponse,
+  ListSynchronizerParametersStateResponse_Result: () => ListSynchronizerParametersStateResponse_Result,
+  ListSynchronizerTrustCertificateRequest: () => ListSynchronizerTrustCertificateRequest,
+  ListSynchronizerTrustCertificateResponse: () => ListSynchronizerTrustCertificateResponse,
+  ListSynchronizerTrustCertificateResponse_Result: () => ListSynchronizerTrustCertificateResponse_Result,
+  ListVettedPackagesRequest: () => ListVettedPackagesRequest,
+  ListVettedPackagesResponse: () => ListVettedPackagesResponse,
+  ListVettedPackagesResponse_Result: () => ListVettedPackagesResponse_Result,
+  TopologyManagerReadService: () => TopologyManagerReadService
+});
+module.exports = __toCommonJS(topology_manager_read_service_exports);
+var import_runtime_rpc = require("@protobuf-ts/runtime-rpc");
+var import_runtime = require("@protobuf-ts/runtime");
+var import_runtime2 = require("@protobuf-ts/runtime");
+var import_runtime3 = require("@protobuf-ts/runtime");
+var import_runtime4 = require("@protobuf-ts/runtime");
+var import_common = require("./common.cjs");
+var import_topology = require("../../../protocol/v30/topology.cjs");
+var import_topology2 = require("../../../protocol/v30/topology.cjs");
+var import_topology3 = require("../../../protocol/v30/topology.cjs");
+var import_synchronizer_parameters = require("../../../protocol/v30/synchronizer_parameters.cjs");
+var import_topology4 = require("../../../protocol/v30/topology.cjs");
+var import_topology5 = require("../../../protocol/v30/topology.cjs");
+var import_topology6 = require("../../../protocol/v30/topology.cjs");
+var import_topology7 = require("../../../protocol/v30/topology.cjs");
+var import_topology8 = require("../../../protocol/v30/topology.cjs");
+var import_topology9 = require("../../../protocol/v30/topology.cjs");
+var import_topology10 = require("../../../protocol/v30/topology.cjs");
+var import_topology11 = require("../../../protocol/v30/topology.cjs");
+var import_topology12 = require("../../../protocol/v30/topology.cjs");
+var import_empty = require("../../../../../../google/protobuf/empty.cjs");
+var import_timestamp = require("../../../../../../google/protobuf/timestamp.cjs");
+var import_topology13 = require("../../../protocol/v30/topology.cjs");
+var import_common2 = require("./common.cjs");
+class BaseQuery$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("com.digitalasset.canton.topology.admin.v30.BaseQuery", [
+      { no: 1, name: "store", kind: "message", T: () => import_common2.StoreId },
+      {
+        no: 2,
+        name: "proposals",
+        kind: "scalar",
+        T: 8
+      },
+      {
+        no: 3,
+        name: "operation",
+        kind: "enum",
+        T: () => [
+          "com.digitalasset.canton.protocol.v30.Enums.TopologyChangeOp",
+          import_topology13.Enums_TopologyChangeOp,
+          "TOPOLOGY_CHANGE_OP_"
+        ]
+      },
+      {
+        no: 5,
+        name: "snapshot",
+        kind: "message",
+        oneof: "timeQuery",
+        T: () => import_timestamp.Timestamp
+      },
+      {
+        no: 6,
+        name: "head_state",
+        kind: "message",
+        oneof: "timeQuery",
+        T: () => import_empty.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)
+      (0, import_runtime3.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 = import_common2.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: import_timestamp.Timestamp.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options,
+              message.timeQuery.snapshot
+            )
+          };
+          break;
+        case /* google.protobuf.Empty head_state */
+        6:
+          message.timeQuery = {
+            oneofKind: "headState",
+            headState: import_empty.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 ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.store)
+      import_common2.StoreId.internalBinaryWrite(
+        message.store,
+        writer.tag(1, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.proposals !== false)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.proposals);
+    if (message.operation !== 0)
+      writer.tag(3, import_runtime.WireType.Varint).int32(message.operation);
+    if (message.timeQuery.oneofKind === "snapshot")
+      import_timestamp.Timestamp.internalBinaryWrite(
+        message.timeQuery.snapshot,
+        writer.tag(5, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.timeQuery.oneofKind === "headState")
+      import_empty.Empty.internalBinaryWrite(
+        message.timeQuery.headState,
+        writer.tag(6, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.timeQuery.oneofKind === "range")
+      BaseQuery_TimeRange.internalBinaryWrite(
+        message.timeQuery.range,
+        writer.tag(7, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterSignedKey !== "")
+      writer.tag(8, import_runtime.WireType.LengthDelimited).string(message.filterSignedKey);
+    if (message.protocolVersion !== void 0)
+      writer.tag(9, import_runtime.WireType.Varint).int32(message.protocolVersion);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const BaseQuery = new BaseQuery$Type();
+class BaseQuery_TimeRange$Type extends import_runtime4.MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.BaseQuery.TimeRange",
+      [
+        { no: 1, name: "from", kind: "message", T: () => import_timestamp.Timestamp },
+        { no: 2, name: "until", kind: "message", T: () => import_timestamp.Timestamp }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_timestamp.Timestamp.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.from
+          );
+          break;
+        case /* google.protobuf.Timestamp until */
+        2:
+          message.until = import_timestamp.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 ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.from)
+      import_timestamp.Timestamp.internalBinaryWrite(
+        message.from,
+        writer.tag(1, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.until)
+      import_timestamp.Timestamp.internalBinaryWrite(
+        message.until,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const BaseQuery_TimeRange = new BaseQuery_TimeRange$Type();
+class BaseResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("com.digitalasset.canton.topology.admin.v30.BaseResult", [
+      { no: 1, name: "store", kind: "message", T: () => import_common2.StoreId },
+      { no: 2, name: "sequenced", kind: "message", T: () => import_timestamp.Timestamp },
+      { no: 3, name: "valid_from", kind: "message", T: () => import_timestamp.Timestamp },
+      { no: 4, name: "valid_until", kind: "message", T: () => import_timestamp.Timestamp },
+      {
+        no: 5,
+        name: "operation",
+        kind: "enum",
+        T: () => [
+          "com.digitalasset.canton.protocol.v30.Enums.TopologyChangeOp",
+          import_topology13.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)
+      (0, import_runtime3.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 = import_common2.StoreId.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.store
+          );
+          break;
+        case /* google.protobuf.Timestamp sequenced */
+        2:
+          message.sequenced = import_timestamp.Timestamp.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.sequenced
+          );
+          break;
+        case /* google.protobuf.Timestamp valid_from */
+        3:
+          message.validFrom = import_timestamp.Timestamp.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.validFrom
+          );
+          break;
+        case /* google.protobuf.Timestamp valid_until */
+        4:
+          message.validUntil = import_timestamp.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 ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.store)
+      import_common2.StoreId.internalBinaryWrite(
+        message.store,
+        writer.tag(1, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.sequenced)
+      import_timestamp.Timestamp.internalBinaryWrite(
+        message.sequenced,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.validFrom)
+      import_timestamp.Timestamp.internalBinaryWrite(
+        message.validFrom,
+        writer.tag(3, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.validUntil)
+      import_timestamp.Timestamp.internalBinaryWrite(
+        message.validUntil,
+        writer.tag(4, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.operation !== 0)
+      writer.tag(5, import_runtime.WireType.Varint).int32(message.operation);
+    if (message.transactionHash.length)
+      writer.tag(6, import_runtime.WireType.LengthDelimited).bytes(message.transactionHash);
+    if (message.serial !== 0)
+      writer.tag(7, import_runtime.WireType.Varint).int32(message.serial);
+    for (let i = 0; i < message.signedByFingerprints.length; i++)
+      writer.tag(8, import_runtime.WireType.LengthDelimited).string(message.signedByFingerprints[i]);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const BaseResult = new BaseResult$Type();
+class ListNamespaceDelegationRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterNamespace !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.filterNamespace);
+    if (message.filterTargetKeyFingerprint !== "")
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.filterTargetKeyFingerprint);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListNamespaceDelegationRequest = new ListNamespaceDelegationRequest$Type();
+class ListNamespaceDelegationResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListNamespaceDelegationResponse = new ListNamespaceDelegationResponse$Type();
+class ListNamespaceDelegationResponse_Result$Type extends import_runtime4.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: () => import_topology12.NamespaceDelegation
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_topology12.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      import_topology12.NamespaceDelegation.internalBinaryWrite(
+        message.item,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListNamespaceDelegationResponse_Result = new ListNamespaceDelegationResponse_Result$Type();
+class ListDecentralizedNamespaceDefinitionRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterNamespace !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.filterNamespace);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListDecentralizedNamespaceDefinitionRequest = new ListDecentralizedNamespaceDefinitionRequest$Type();
+class ListDecentralizedNamespaceDefinitionResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListDecentralizedNamespaceDefinitionResponse = new ListDecentralizedNamespaceDefinitionResponse$Type();
+class ListDecentralizedNamespaceDefinitionResponse_Result$Type extends import_runtime4.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: () => import_topology11.DecentralizedNamespaceDefinition
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_topology11.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      import_topology11.DecentralizedNamespaceDefinition.internalBinaryWrite(
+        message.item,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListDecentralizedNamespaceDefinitionResponse_Result = new ListDecentralizedNamespaceDefinitionResponse_Result$Type();
+class ListOwnerToKeyMappingRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterKeyOwnerType !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.filterKeyOwnerType);
+    if (message.filterKeyOwnerUid !== "")
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.filterKeyOwnerUid);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListOwnerToKeyMappingRequest = new ListOwnerToKeyMappingRequest$Type();
+class ListOwnerToKeyMappingResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListOwnerToKeyMappingResponse = new ListOwnerToKeyMappingResponse$Type();
+class ListOwnerToKeyMappingResponse_Result$Type extends import_runtime4.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: () => import_topology10.OwnerToKeyMapping
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_topology10.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      import_topology10.OwnerToKeyMapping.internalBinaryWrite(
+        message.item,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListOwnerToKeyMappingResponse_Result = new ListOwnerToKeyMappingResponse_Result$Type();
+class ListPartyToKeyMappingRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterParty !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.filterParty);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPartyToKeyMappingRequest = new ListPartyToKeyMappingRequest$Type();
+class ListPartyToKeyMappingResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPartyToKeyMappingResponse = new ListPartyToKeyMappingResponse$Type();
+class ListPartyToKeyMappingResponse_Result$Type extends import_runtime4.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: () => import_topology9.PartyToKeyMapping
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_topology9.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      import_topology9.PartyToKeyMapping.internalBinaryWrite(
+        message.item,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPartyToKeyMappingResponse_Result = new ListPartyToKeyMappingResponse_Result$Type();
+class ListSynchronizerTrustCertificateRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterUid !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.filterUid);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListSynchronizerTrustCertificateRequest = new ListSynchronizerTrustCertificateRequest$Type();
+class ListSynchronizerTrustCertificateResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListSynchronizerTrustCertificateResponse = new ListSynchronizerTrustCertificateResponse$Type();
+class ListSynchronizerTrustCertificateResponse_Result$Type extends import_runtime4.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: () => import_topology8.SynchronizerTrustCertificate
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_topology8.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      import_topology8.SynchronizerTrustCertificate.internalBinaryWrite(
+        message.item,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListSynchronizerTrustCertificateResponse_Result = new ListSynchronizerTrustCertificateResponse_Result$Type();
+class ListParticipantSynchronizerPermissionRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterUid !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.filterUid);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListParticipantSynchronizerPermissionRequest = new ListParticipantSynchronizerPermissionRequest$Type();
+class ListParticipantSynchronizerPermissionResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListParticipantSynchronizerPermissionResponse = new ListParticipantSynchronizerPermissionResponse$Type();
+class ListParticipantSynchronizerPermissionResponse_Result$Type extends import_runtime4.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: () => import_topology7.ParticipantSynchronizerPermission
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_topology7.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      import_topology7.ParticipantSynchronizerPermission.internalBinaryWrite(
+        message.item,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListParticipantSynchronizerPermissionResponse_Result = new ListParticipantSynchronizerPermissionResponse_Result$Type();
+class ListPartyHostingLimitsRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterUid !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.filterUid);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPartyHostingLimitsRequest = new ListPartyHostingLimitsRequest$Type();
+class ListPartyHostingLimitsResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPartyHostingLimitsResponse = new ListPartyHostingLimitsResponse$Type();
+class ListPartyHostingLimitsResponse_Result$Type extends import_runtime4.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: () => import_topology6.PartyHostingLimits
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_topology6.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      import_topology6.PartyHostingLimits.internalBinaryWrite(
+        message.item,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPartyHostingLimitsResponse_Result = new ListPartyHostingLimitsResponse_Result$Type();
+class ListVettedPackagesRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterParticipant !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.filterParticipant);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListVettedPackagesRequest = new ListVettedPackagesRequest$Type();
+class ListVettedPackagesResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListVettedPackagesResponse = new ListVettedPackagesResponse$Type();
+class ListVettedPackagesResponse_Result$Type extends import_runtime4.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: () => import_topology5.VettedPackages
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_topology5.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      import_topology5.VettedPackages.internalBinaryWrite(
+        message.item,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListVettedPackagesResponse_Result = new ListVettedPackagesResponse_Result$Type();
+class ListPartyToParticipantRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterParty !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.filterParty);
+    if (message.filterParticipant !== "")
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.filterParticipant);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPartyToParticipantRequest = new ListPartyToParticipantRequest$Type();
+class ListPartyToParticipantResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPartyToParticipantResponse = new ListPartyToParticipantResponse$Type();
+class ListPartyToParticipantResponse_Result$Type extends import_runtime4.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: () => import_topology4.PartyToParticipant
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_topology4.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      import_topology4.PartyToParticipant.internalBinaryWrite(
+        message.item,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPartyToParticipantResponse_Result = new ListPartyToParticipantResponse_Result$Type();
+class ListSynchronizerParametersStateRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterSynchronizerId !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.filterSynchronizerId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListSynchronizerParametersStateRequest = new ListSynchronizerParametersStateRequest$Type();
+class ListSynchronizerParametersStateResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListSynchronizerParametersStateResponse = new ListSynchronizerParametersStateResponse$Type();
+class ListSynchronizerParametersStateResponse_Result$Type extends import_runtime4.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: () => import_synchronizer_parameters.DynamicSynchronizerParameters
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_synchronizer_parameters.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      import_synchronizer_parameters.DynamicSynchronizerParameters.internalBinaryWrite(
+        message.item,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListSynchronizerParametersStateResponse_Result = new ListSynchronizerParametersStateResponse_Result$Type();
+class ListMediatorSynchronizerStateRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterSynchronizerId !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.filterSynchronizerId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListMediatorSynchronizerStateRequest = new ListMediatorSynchronizerStateRequest$Type();
+class ListMediatorSynchronizerStateResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListMediatorSynchronizerStateResponse = new ListMediatorSynchronizerStateResponse$Type();
+class ListMediatorSynchronizerStateResponse_Result$Type extends import_runtime4.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: () => import_topology3.MediatorSynchronizerState
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_topology3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      import_topology3.MediatorSynchronizerState.internalBinaryWrite(
+        message.item,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListMediatorSynchronizerStateResponse_Result = new ListMediatorSynchronizerStateResponse_Result$Type();
+class ListSequencerSynchronizerStateRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterSynchronizerId !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.filterSynchronizerId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListSequencerSynchronizerStateRequest = new ListSequencerSynchronizerStateRequest$Type();
+class ListSequencerSynchronizerStateResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListSequencerSynchronizerStateResponse = new ListSequencerSynchronizerStateResponse$Type();
+class ListSequencerSynchronizerStateResponse_Result$Type extends import_runtime4.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: () => import_topology2.SequencerSynchronizerState
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_topology2.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      import_topology2.SequencerSynchronizerState.internalBinaryWrite(
+        message.item,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListSequencerSynchronizerStateResponse_Result = new ListSequencerSynchronizerStateResponse_Result$Type();
+class ListPurgeTopologyTransactionRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.filterSynchronizerId !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.filterSynchronizerId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPurgeTopologyTransactionRequest = new ListPurgeTopologyTransactionRequest$Type();
+class ListPurgeTopologyTransactionResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPurgeTopologyTransactionResponse = new ListPurgeTopologyTransactionResponse$Type();
+class ListPurgeTopologyTransactionResponse_Result$Type extends import_runtime4.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: () => import_topology.PurgeTopologyTransaction
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_topology.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.item)
+      import_topology.PurgeTopologyTransaction.internalBinaryWrite(
+        message.item,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListPurgeTopologyTransactionResponse_Result = new ListPurgeTopologyTransactionResponse_Result$Type();
+class ListAvailableStoresRequest$Type extends import_runtime4.MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListAvailableStoresRequest",
+      []
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListAvailableStoresRequest = new ListAvailableStoresRequest$Type();
+class ListAvailableStoresResponse$Type extends import_runtime4.MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.ListAvailableStoresResponse",
+      [
+        {
+          no: 1,
+          name: "store_ids",
+          kind: "message",
+          repeat: 2,
+          T: () => import_common2.StoreId
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.storeIds = [];
+    if (value !== void 0)
+      (0, import_runtime3.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(
+            import_common2.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 ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.storeIds.length; i++)
+      import_common2.StoreId.internalBinaryWrite(
+        message.storeIds[i],
+        writer.tag(1, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListAvailableStoresResponse = new ListAvailableStoresResponse$Type();
+class ListAllRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.excludeMappings.length; i++)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.excludeMappings[i]);
+    if (message.filterNamespace !== "")
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.filterNamespace);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListAllRequest = new ListAllRequest$Type();
+class ExportTopologySnapshotRequest$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.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, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.excludeMappings.length; i++)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.excludeMappings[i]);
+    if (message.filterNamespace !== "")
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.filterNamespace);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ExportTopologySnapshotRequest = new ExportTopologySnapshotRequest$Type();
+class ListAllResponse$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("com.digitalasset.canton.topology.admin.v30.ListAllResponse", [
+      {
+        no: 1,
+        name: "result",
+        kind: "message",
+        T: () => import_common.TopologyTransactions
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_common.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 ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.result)
+      import_common.TopologyTransactions.internalBinaryWrite(
+        message.result,
+        writer.tag(1, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ListAllResponse = new ListAllResponse$Type();
+class ExportTopologySnapshotResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.chunk.length)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).bytes(message.chunk);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const ExportTopologySnapshotResponse = new ExportTopologySnapshotResponse$Type();
+class GenesisStateRequest$Type extends import_runtime4.MessageType {
+  constructor() {
+    super(
+      "com.digitalasset.canton.topology.admin.v30.GenesisStateRequest",
+      [
+        {
+          no: 1,
+          name: "synchronizer_store",
+          kind: "message",
+          T: () => import_common2.StoreId
+        },
+        {
+          no: 2,
+          name: "timestamp",
+          kind: "message",
+          T: () => import_timestamp.Timestamp
+        }
+      ]
+    );
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== void 0)
+      (0, import_runtime3.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 = import_common2.StoreId.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.synchronizerStore
+          );
+          break;
+        case /* google.protobuf.Timestamp timestamp */
+        2:
+          message.timestamp = import_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 ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.synchronizerStore)
+      import_common2.StoreId.internalBinaryWrite(
+        message.synchronizerStore,
+        writer.tag(1, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.timestamp)
+      import_timestamp.Timestamp.internalBinaryWrite(
+        message.timestamp,
+        writer.tag(2, import_runtime.WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const GenesisStateRequest = new GenesisStateRequest$Type();
+class GenesisStateResponse$Type extends import_runtime4.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)
+      (0, import_runtime3.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 ? import_runtime2.UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.chunk.length)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).bytes(message.chunk);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer
+      );
+    return writer;
+  }
+}
+const GenesisStateResponse = new GenesisStateResponse$Type();
+const TopologyManagerReadService = new import_runtime_rpc.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
+    }
+  ]
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.cjs.map