@distrohelena/canton-typescript-sdk 0.1.0

package/dist/client/service-registry.js

@@ -0,0 +1,1029 @@
+import { TransportError } from "../core/errors/transport-error.js";
+import { ObjectDisposedError } from "../core/errors/object-disposed-error.js";
+import { TransportKind } from "../core/types/transport-kind.js";
+import { EndpointNotConfiguredError } from "../core/errors/endpoint-not-configured-error.js";
+import { GrpcChannelSecurity } from "../core/types/grpc-channel-security.js";
+import { CommandCompletionServiceClient } from "../services/command-completion/command-completion-service-client.js";
+import { CommandInspectionServiceClient } from "../services/command-inspection/command-inspection-service-client.js";
+import { CommandServiceClient } from "../services/command/command-service-client.js";
+import { CommandSubmissionServiceClient } from "../services/command-submission/command-submission-service-client.js";
+import { ContractServiceClient } from "../services/contract/contract-service-client.js";
+import { EventQueryServiceClient } from "../services/event-query/event-query-service-client.js";
+import { HealthServiceClient } from "../services/health/health-service-client.js";
+import { IdentityInitializationServiceClient } from "../services/identity-initialization/identity-initialization-service-client.js";
+import { IdentityProviderConfigServiceClient } from "../services/identity-provider-config/identity-provider-config-service-client.js";
+import { PackageManagementServiceClient } from "../services/package-management/package-management-service-client.js";
+import { PackageServiceClient } from "../services/package/package-service-client.js";
+import { ParticipantInspectionServiceClient } from "../services/participant-inspection/participant-inspection-service-client.js";
+import { ParticipantPartyManagementServiceClient } from "../services/participant-party-management/participant-party-management-service-client.js";
+import { ParticipantPackageServiceClient } from "../services/participant-package/participant-package-service-client.js";
+import { ParticipantRepairServiceClient } from "../services/participant-repair/participant-repair-service-client.js";
+import { ParticipantStatusServiceClient } from "../services/participant-status/participant-status-service-client.js";
+import { PartyManagementServiceClient } from "../services/party-management/party-management-service-client.js";
+import { PruningServiceClient } from "../services/pruning/pruning-service-client.js";
+import { ResourceManagementServiceClient } from "../services/resource-management/resource-management-service-client.js";
+import { StateServiceClient } from "../services/state/state-service-client.js";
+import { TopologyAggregationServiceClient } from "../services/topology-aggregation/topology-aggregation-service-client.js";
+import { TopologyManagerReadServiceClient } from "../services/topology-manager-read/topology-manager-read-service-client.js";
+import { TrafficControlServiceClient } from "../services/traffic-control/traffic-control-service-client.js";
+import { UpdateServiceClient } from "../services/update/update-service-client.js";
+import { UserManagementServiceClient } from "../services/user-management/user-management-service-client.js";
+import { VersionServiceClient } from "../services/version/version-service-client.js";
+import { SynchronizerConnectivityServiceClient } from "../services/synchronizer-connectivity/synchronizer-connectivity-service-client.js";
+import { createJsonTransport } from "../transports/json/json-transport-factory.js";
+import { createGrpcTransport } from "../transports/grpc/grpc-transport-factory.js";
+class PlaceholderTransport {
+    disposed = false;
+    features;
+    constructor(options) {
+        this.features = {
+            supportsCommandSigning: options.transportKind === TransportKind.grpc,
+        };
+    }
+    async disposeAsync() {
+        this.disposed = true;
+    }
+    async getLedgerApiVersionAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("ledger api version is not available yet");
+    }
+    async checkHealthAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("gRPC health checks are not available yet");
+    }
+    async allocatePartyAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("party allocation is not available yet");
+    }
+    async listKnownPartiesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("known party listing is not available yet");
+    }
+    async getParticipantIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("participant id reads are not available yet");
+    }
+    async getPartiesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("party detail reads are not available yet");
+    }
+    async grantUserRightsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("user rights management is not available yet");
+    }
+    async getCommandStatusAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("command inspection reads are not available yet");
+    }
+    async getUserAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("user reads are not available yet");
+    }
+    async listUsersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("user listing is not available yet");
+    }
+    async listUserRightsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("user rights reads are not available yet");
+    }
+    async uploadDarFileAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("dar upload is not available yet");
+    }
+    async listKnownPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("known package listing is not available yet");
+    }
+    async getIdentityProviderConfigAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("identity provider config reads are not available yet");
+    }
+    async listIdentityProviderConfigsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("identity provider config listing is not available yet");
+    }
+    async listPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("ledger package listing is not available yet");
+    }
+    async getPackageAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("ledger package reads are not available yet");
+    }
+    async getPackageStatusAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("ledger package status is not available yet");
+    }
+    async listVettedPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("vetted package reads are not available yet");
+    }
+    async listParticipantPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("participant package listing is not available yet");
+    }
+    async getParticipantPackageContentsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("participant package contents are not available yet");
+    }
+    async getParticipantPackageReferencesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("participant package references are not available yet");
+    }
+    async getParticipantDarAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("participant dar reads are not available yet");
+    }
+    async listParticipantDarsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("participant dar listing is not available yet");
+    }
+    async getParticipantDarContentsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("participant dar contents are not available yet");
+    }
+    async getParticipantStatusAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("participant status is not available yet");
+    }
+    async lookupOffsetByTimeAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("lookup offset by time is not available yet");
+    }
+    async openCommitmentAsync(_request, _observer, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("open commitment inspection is not available yet");
+    }
+    async inspectCommitmentContractsAsync(_request, _observer, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("commitment contract inspection is not available yet");
+    }
+    async countInFlightAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("count in flight is not available yet");
+    }
+    async getConfigForSlowCounterParticipantsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("slow counter participant config is not available yet");
+    }
+    async getIntervalsBehindForCounterParticipantsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("intervals behind for counter participants is not available yet");
+    }
+    async lookupSentAcsCommitmentsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("sent ACS commitment inspection is not available yet");
+    }
+    async lookupReceivedAcsCommitmentsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("received ACS commitment inspection is not available yet");
+    }
+    async getHighestOffsetByTimestampAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("highest offset by timestamp is not available yet");
+    }
+    async getSafePruningOffsetAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("safe pruning offset is not available yet");
+    }
+    async getPruningScheduleAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("pruning schedule is not available yet");
+    }
+    async getParticipantPruningScheduleAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("participant pruning schedule is not available yet");
+    }
+    async getNoWaitCommitmentsFromAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("no-wait commitments configuration is not available yet");
+    }
+    async trafficControlStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("traffic control state is not available yet");
+    }
+    async listConnectedSynchronizersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("list connected synchronizers is not available yet");
+    }
+    async getSynchronizerIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("get synchronizer id is not available yet");
+    }
+    async listRegisteredSynchronizersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("registered synchronizer listing is not available yet");
+    }
+    async listPendingOperationsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("pending operation listing is not available yet");
+    }
+    async getResourceLimitsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("resource limits are not available yet");
+    }
+    async getIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("identity initialization id is not available yet");
+    }
+    async currentTimeAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("identity initialization current time is not available yet");
+    }
+    async getContractAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("contract reads are not available yet");
+    }
+    async getEventsByContractIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("event query reads are not available yet");
+    }
+    async listNamespaceDelegationAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology namespace delegations are not available yet");
+    }
+    async listDecentralizedNamespaceDefinitionAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology decentralized namespaces are not available yet");
+    }
+    async listOwnerToKeyMappingAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology owner-to-key mappings are not available yet");
+    }
+    async listPartyToKeyMappingAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology party-to-key mappings are not available yet");
+    }
+    async listSynchronizerTrustCertificateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology synchronizer trust certificates are not available yet");
+    }
+    async listParticipantSynchronizerPermissionAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology participant synchronizer permissions are not available yet");
+    }
+    async listPartyHostingLimitsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology party hosting limits are not available yet");
+    }
+    async topologyListVettedPackagesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology vetted packages are not available yet");
+    }
+    async listPartyToParticipantAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology party-to-participant mappings are not available yet");
+    }
+    async listSynchronizerParametersStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology synchronizer parameters are not available yet");
+    }
+    async listSequencingParametersStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology sequencing parameters are not available yet");
+    }
+    async listMediatorSynchronizerStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology mediator synchronizer state is not available yet");
+    }
+    async listSequencerSynchronizerStateAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology sequencer synchronizer state is not available yet");
+    }
+    async listLsuAnnouncementAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology lsu announcements are not available yet");
+    }
+    async listLsuSequencerConnectionSuccessorAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology lsu sequencer connection successors are not available yet");
+    }
+    async listAvailableStoresAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology stores are not available yet");
+    }
+    async listAllAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology list-all is not available yet");
+    }
+    async listAllV2Async(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology list-all-v2 is not available yet");
+    }
+    async topologyListPartiesAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology list parties is not available yet");
+    }
+    async listKeyOwnersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("topology key owners are not available yet");
+    }
+    async getActiveContractsPageAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("StateService.GetActiveContractsPage is not available yet");
+    }
+    async getConnectedSynchronizersAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("StateService.GetConnectedSynchronizers is not available yet");
+    }
+    async getLedgerEndAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("StateService.GetLedgerEnd is not available yet");
+    }
+    async getLatestPrunedOffsetsAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("StateService.GetLatestPrunedOffsets is not available yet");
+    }
+    async getActiveContractsAsync(_request, _observer, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("StateService.GetActiveContracts is not available yet");
+    }
+    async getUpdatesAsync(_request, _observer, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("UpdateService.GetUpdates is not available yet");
+    }
+    async getUpdateByOffsetAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("UpdateService.GetUpdateByOffset is not available yet");
+    }
+    async getUpdateByIdAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("UpdateService.GetUpdateById is not available yet");
+    }
+    async getUpdateByHashAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("UpdateService.GetUpdateByHash is not available yet");
+    }
+    async getUpdatesPageAsync(_request, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("UpdateService.GetUpdatesPage is not available yet");
+    }
+    async getCompletionsAsync(_request, _observer, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("CommandCompletionService.GetCompletions is not available yet");
+    }
+    async submitCommandAsync(_request, _signed, _options) {
+        this.throwIfDisposed();
+        throw new TransportError("command submission is not available yet");
+    }
+    throwIfDisposed() {
+        if (this.disposed) {
+            throw new ObjectDisposedError("The client or transport has been disposed.");
+        }
+    }
+}
+class MissingEndpointTransport {
+    serviceName;
+    surfaceName;
+    features;
+    constructor(serviceName, surfaceName, transportKind) {
+        this.serviceName = serviceName;
+        this.surfaceName = surfaceName;
+        this.features = {
+            supportsCommandSigning: transportKind === TransportKind.grpc,
+        };
+    }
+    async disposeAsync() {
+        return;
+    }
+    async getLedgerApiVersionAsync() {
+        this.throwMissingEndpoint();
+    }
+    async checkHealthAsync() {
+        this.throwMissingEndpoint();
+    }
+    async allocatePartyAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listKnownPartiesAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getParticipantIdAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getPartiesAsync() {
+        this.throwMissingEndpoint();
+    }
+    async grantUserRightsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getCommandStatusAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getUserAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listUsersAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listUserRightsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async uploadDarFileAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listKnownPackagesAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getIdentityProviderConfigAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listIdentityProviderConfigsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listPackagesAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getPackageAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getPackageStatusAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listVettedPackagesAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listParticipantPackagesAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getParticipantPackageContentsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getParticipantPackageReferencesAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getParticipantDarAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listParticipantDarsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getParticipantDarContentsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getParticipantStatusAsync() {
+        this.throwMissingEndpoint();
+    }
+    async lookupOffsetByTimeAsync() {
+        this.throwMissingEndpoint();
+    }
+    async openCommitmentAsync() {
+        this.throwMissingEndpoint();
+    }
+    async inspectCommitmentContractsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async countInFlightAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getConfigForSlowCounterParticipantsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getIntervalsBehindForCounterParticipantsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async lookupSentAcsCommitmentsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async lookupReceivedAcsCommitmentsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getHighestOffsetByTimestampAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getSafePruningOffsetAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getPruningScheduleAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getParticipantPruningScheduleAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getNoWaitCommitmentsFromAsync() {
+        this.throwMissingEndpoint();
+    }
+    async trafficControlStateAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listConnectedSynchronizersAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getSynchronizerIdAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listRegisteredSynchronizersAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listPendingOperationsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getResourceLimitsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getIdAsync() {
+        this.throwMissingEndpoint();
+    }
+    async currentTimeAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getContractAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getEventsByContractIdAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listNamespaceDelegationAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listDecentralizedNamespaceDefinitionAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listOwnerToKeyMappingAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listPartyToKeyMappingAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listSynchronizerTrustCertificateAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listParticipantSynchronizerPermissionAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listPartyHostingLimitsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async topologyListVettedPackagesAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listPartyToParticipantAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listSynchronizerParametersStateAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listSequencingParametersStateAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listMediatorSynchronizerStateAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listSequencerSynchronizerStateAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listLsuAnnouncementAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listLsuSequencerConnectionSuccessorAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listAvailableStoresAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listAllAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listAllV2Async() {
+        this.throwMissingEndpoint();
+    }
+    async topologyListPartiesAsync() {
+        this.throwMissingEndpoint();
+    }
+    async listKeyOwnersAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getActiveContractsPageAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getConnectedSynchronizersAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getLedgerEndAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getLatestPrunedOffsetsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getActiveContractsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getUpdatesAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getUpdateByOffsetAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getUpdateByIdAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getUpdateByHashAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getUpdatesPageAsync() {
+        this.throwMissingEndpoint();
+    }
+    async getCompletionsAsync() {
+        this.throwMissingEndpoint();
+    }
+    async submitCommandAsync() {
+        this.throwMissingEndpoint();
+    }
+    throwMissingEndpoint() {
+        throw new EndpointNotConfiguredError(`The ${this.surfaceName} endpoint is not configured for ${this.serviceName}.`);
+    }
+}
+class CompositeTransport {
+    transports;
+    features;
+    constructor(transports) {
+        this.transports = transports;
+        this.features = {
+            supportsCommandSigning: transports.some((transport) => transport.features.supportsCommandSigning),
+        };
+    }
+    async disposeAsync() {
+        await Promise.all(this.transports.map((transport) => transport.disposeAsync()));
+    }
+    async getLedgerApiVersionAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async checkHealthAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async allocatePartyAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listKnownPartiesAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getParticipantIdAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getPartiesAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async grantUserRightsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getCommandStatusAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getUserAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listUsersAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listUserRightsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async uploadDarFileAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listKnownPackagesAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getIdentityProviderConfigAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listIdentityProviderConfigsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listPackagesAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getPackageAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getPackageStatusAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listVettedPackagesAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listParticipantPackagesAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getParticipantPackageContentsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getParticipantPackageReferencesAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getParticipantDarAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listParticipantDarsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getParticipantDarContentsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getParticipantStatusAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async lookupOffsetByTimeAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async openCommitmentAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async inspectCommitmentContractsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async countInFlightAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getConfigForSlowCounterParticipantsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getIntervalsBehindForCounterParticipantsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async lookupSentAcsCommitmentsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async lookupReceivedAcsCommitmentsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getHighestOffsetByTimestampAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getSafePruningOffsetAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getPruningScheduleAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getParticipantPruningScheduleAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getNoWaitCommitmentsFromAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async trafficControlStateAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listConnectedSynchronizersAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getSynchronizerIdAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listRegisteredSynchronizersAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listPendingOperationsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getResourceLimitsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getIdAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async currentTimeAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getContractAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getEventsByContractIdAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listNamespaceDelegationAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listDecentralizedNamespaceDefinitionAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listOwnerToKeyMappingAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listPartyToKeyMappingAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listSynchronizerTrustCertificateAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listParticipantSynchronizerPermissionAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listPartyHostingLimitsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async topologyListVettedPackagesAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listPartyToParticipantAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listSynchronizerParametersStateAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listSequencingParametersStateAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listMediatorSynchronizerStateAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listSequencerSynchronizerStateAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listLsuAnnouncementAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listLsuSequencerConnectionSuccessorAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listAvailableStoresAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listAllAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listAllV2Async() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async topologyListPartiesAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async listKeyOwnersAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getActiveContractsPageAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getConnectedSynchronizersAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getLedgerEndAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getLatestPrunedOffsetsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getActiveContractsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getUpdatesAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getUpdateByOffsetAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getUpdateByIdAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getUpdateByHashAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getUpdatesPageAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async getCompletionsAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+    async submitCommandAsync() {
+        throw new TransportError("Composite transport does not forward service calls.");
+    }
+}
+function createTransportForEndpoint(options, endpoint, grpcChannelSecurity, authProvider) {
+    return options.transportKind === TransportKind.json
+        ? createJsonTransport(options, endpoint, authProvider)
+        : options.transportKind === TransportKind.grpc
+            ? createGrpcTransport(options, endpoint, grpcChannelSecurity ?? options.grpcChannelSecurity)
+            : new PlaceholderTransport(options);
+}
+function createLedgerTransport(options) {
+    return options.ledgerEndpoint === undefined
+        ? new MissingEndpointTransport("versionService", "ledger", options.transportKind)
+        : createTransportForEndpoint(options, options.ledgerEndpoint, options.ledgerGrpcChannelSecurity
+            ?? options.grpcChannelSecurity
+            ?? GrpcChannelSecurity.tls, options.ledgerAuthProvider);
+}
+function createLedgerAdminTransport(options) {
+    return options.ledgerAdminEndpoint === undefined
+        ? new MissingEndpointTransport("partyManagementService", "ledger admin", options.transportKind)
+        : createTransportForEndpoint(options, options.ledgerAdminEndpoint, options.ledgerAdminGrpcChannelSecurity
+            ?? options.grpcChannelSecurity
+            ?? GrpcChannelSecurity.tls, options.ledgerAdminAuthProvider);
+}
+function createParticipantAdminTransport(options) {
+    return options.participantAdminEndpoint === undefined
+        ? new MissingEndpointTransport("participantPackageService", "participant admin", options.transportKind)
+        : createTransportForEndpoint(options, options.participantAdminEndpoint, options.participantAdminGrpcChannelSecurity
+            ?? options.grpcChannelSecurity
+            ?? GrpcChannelSecurity.tls, options.participantAdminAuthProvider);
+}
+function createMissingLedgerTransport(options, serviceName) {
+    return new MissingEndpointTransport(serviceName, "ledger", options.transportKind);
+}
+function createMissingLedgerAdminTransport(options, serviceName) {
+    return new MissingEndpointTransport(serviceName, "ledger admin", options.transportKind);
+}
+function createMissingParticipantAdminTransport(options, serviceName) {
+    return new MissingEndpointTransport(serviceName, "participant admin", options.transportKind);
+}
+export function createServiceRegistry(options) {
+    const ledgerTransport = options.ledgerEndpoint === undefined
+        ? undefined
+        : createLedgerTransport(options);
+    const ledgerAdminTransport = options.ledgerAdminEndpoint === undefined
+        ? undefined
+        : createLedgerAdminTransport(options);
+    const participantAdminTransport = options.participantAdminEndpoint === undefined
+        ? undefined
+        : createParticipantAdminTransport(options);
+    const versionTransport = ledgerTransport
+        ?? createMissingLedgerTransport(options, "versionService");
+    const healthTransport = ledgerTransport
+        ?? createMissingLedgerTransport(options, "healthService");
+    const packageTransport = ledgerTransport
+        ?? createMissingLedgerTransport(options, "packageService");
+    const commandTransport = ledgerTransport
+        ?? createMissingLedgerTransport(options, "commandService");
+    const commandSubmissionTransport = ledgerTransport
+        ?? createMissingLedgerTransport(options, "commandSubmissionService");
+    const commandCompletionTransport = ledgerTransport
+        ?? createMissingLedgerTransport(options, "commandCompletionService");
+    const stateTransport = ledgerTransport
+        ?? createMissingLedgerTransport(options, "stateService");
+    const updateTransport = ledgerTransport
+        ?? createMissingLedgerTransport(options, "updateService");
+    const eventQueryTransport = ledgerTransport
+        ?? createMissingLedgerTransport(options, "eventQueryService");
+    const contractTransport = ledgerTransport
+        ?? createMissingLedgerTransport(options, "contractService");
+    const partyManagementTransport = ledgerAdminTransport
+        ?? createMissingLedgerAdminTransport(options, "partyManagementService");
+    const userManagementTransport = ledgerAdminTransport
+        ?? createMissingLedgerAdminTransport(options, "userManagementService");
+    const commandInspectionTransport = ledgerAdminTransport
+        ?? createMissingLedgerAdminTransport(options, "commandInspectionService");
+    const identityProviderConfigTransport = ledgerAdminTransport
+        ?? createMissingLedgerAdminTransport(options, "identityProviderConfigService");
+    const participantPackageTransport = participantAdminTransport
+        ?? createMissingParticipantAdminTransport(options, "participantPackageService");
+    const participantInspectionTransport = participantAdminTransport
+        ?? createMissingParticipantAdminTransport(options, "participantInspectionService");
+    const participantPartyManagementTransport = participantAdminTransport
+        ?? createMissingParticipantAdminTransport(options, "participantPartyManagementService");
+    const participantRepairTransport = participantAdminTransport
+        ?? createMissingParticipantAdminTransport(options, "participantRepairService");
+    const packageManagementTransport = ledgerAdminTransport
+        ?? createMissingLedgerAdminTransport(options, "packageManagementService");
+    const participantStatusTransport = participantAdminTransport
+        ?? createMissingParticipantAdminTransport(options, "participantStatusService");
+    const pruningTransport = participantAdminTransport
+        ?? createMissingParticipantAdminTransport(options, "pruningService");
+    const resourceManagementTransport = participantAdminTransport
+        ?? createMissingParticipantAdminTransport(options, "resourceManagementService");
+    const identityInitializationTransport = participantAdminTransport
+        ?? createMissingParticipantAdminTransport(options, "identityInitializationService");
+    const synchronizerConnectivityTransport = participantAdminTransport
+        ?? createMissingParticipantAdminTransport(options, "synchronizerConnectivityService");
+    const trafficControlTransport = participantAdminTransport
+        ?? createMissingParticipantAdminTransport(options, "trafficControlService");
+    const topologyManagerReadTransport = participantAdminTransport
+        ?? createMissingParticipantAdminTransport(options, "topologyManagerReadService");
+    const topologyAggregationTransport = participantAdminTransport
+        ?? createMissingParticipantAdminTransport(options, "topologyAggregationService");
+    const transport = new CompositeTransport([
+        ledgerTransport,
+        ledgerAdminTransport,
+        participantAdminTransport,
+    ].filter((item) => item !== undefined));
+    return {
+        transport,
+        versionService: new VersionServiceClient(versionTransport),
+        healthService: new HealthServiceClient(healthTransport),
+        partyManagementService: new PartyManagementServiceClient(partyManagementTransport),
+        userManagementService: new UserManagementServiceClient(userManagementTransport),
+        commandInspectionService: new CommandInspectionServiceClient(commandInspectionTransport),
+        identityProviderConfigService: new IdentityProviderConfigServiceClient(identityProviderConfigTransport),
+        packageService: new PackageServiceClient(packageTransport),
+        packageManagementService: new PackageManagementServiceClient(packageManagementTransport),
+        participantPackageService: new ParticipantPackageServiceClient(participantPackageTransport),
+        participantInspectionService: new ParticipantInspectionServiceClient(participantInspectionTransport),
+        participantPartyManagementService: new ParticipantPartyManagementServiceClient(participantPartyManagementTransport),
+        participantRepairService: new ParticipantRepairServiceClient(participantRepairTransport),
+        participantStatusService: new ParticipantStatusServiceClient(participantStatusTransport),
+        pruningService: new PruningServiceClient(pruningTransport),
+        resourceManagementService: new ResourceManagementServiceClient(resourceManagementTransport),
+        identityInitializationService: new IdentityInitializationServiceClient(identityInitializationTransport),
+        synchronizerConnectivityService: new SynchronizerConnectivityServiceClient(synchronizerConnectivityTransport),
+        topologyManagerReadService: new TopologyManagerReadServiceClient(topologyManagerReadTransport),
+        trafficControlService: new TrafficControlServiceClient(trafficControlTransport),
+        topologyAggregationService: new TopologyAggregationServiceClient(topologyAggregationTransport),
+        commandService: new CommandServiceClient(commandTransport, options.commandSigner),
+        commandSubmissionService: new CommandSubmissionServiceClient(commandSubmissionTransport),
+        commandCompletionService: new CommandCompletionServiceClient(commandCompletionTransport),
+        stateService: new StateServiceClient(stateTransport),
+        updateService: new UpdateServiceClient(updateTransport),
+        eventQueryService: new EventQueryServiceClient(eventQueryTransport),
+        contractService: new ContractServiceClient(contractTransport),
+    };
+}