@distrohelena/canton-typescript-sdk 0.1.0

package/dist/core/types/topology/dynamic-synchronizer-parameters.js

@@ -0,0 +1,74 @@
+export var OnboardingRestriction;
+(function (OnboardingRestriction) {
+    OnboardingRestriction["unspecified"] = "unspecified";
+    OnboardingRestriction["unrestrictedOpen"] = "unrestrictedOpen";
+    OnboardingRestriction["unrestrictedLocked"] = "unrestrictedLocked";
+    OnboardingRestriction["restrictedOpen"] = "restrictedOpen";
+    OnboardingRestriction["restrictedLocked"] = "restrictedLocked";
+})(OnboardingRestriction || (OnboardingRestriction = {}));
+export class TrafficControlParameters {
+    maxBaseTrafficAmount;
+    maxBaseTrafficAccumulationDuration;
+    readVsWriteScalingFactor;
+    setBalanceRequestSubmissionWindowSize;
+    enforceRateLimiting;
+    baseEventCost;
+    freeConfirmationResponses;
+    constructor(init = {}) {
+        this.maxBaseTrafficAmount = init.maxBaseTrafficAmount ?? "0";
+        this.maxBaseTrafficAccumulationDuration =
+            init.maxBaseTrafficAccumulationDuration;
+        this.readVsWriteScalingFactor = init.readVsWriteScalingFactor ?? 0;
+        this.setBalanceRequestSubmissionWindowSize =
+            init.setBalanceRequestSubmissionWindowSize;
+        this.enforceRateLimiting = init.enforceRateLimiting ?? false;
+        this.baseEventCost = init.baseEventCost;
+        this.freeConfirmationResponses =
+            init.freeConfirmationResponses ?? false;
+    }
+}
+export class AcsCommitmentsCatchUpConfig {
+    catchupIntervalSkip;
+    nrIntervalsToTriggerCatchup;
+    constructor(init = {}) {
+        this.catchupIntervalSkip = init.catchupIntervalSkip ?? 0;
+        this.nrIntervalsToTriggerCatchup =
+            init.nrIntervalsToTriggerCatchup ?? 0;
+    }
+}
+export class DynamicSynchronizerParameters {
+    confirmationResponseTimeout;
+    mediatorReactionTimeout;
+    assignmentExclusivityTimeout;
+    ledgerTimeRecordTimeTolerance;
+    reconciliationInterval;
+    mediatorDeduplicationTimeout;
+    maxRequestSize;
+    onboardingRestriction;
+    participantSynchronizerLimits;
+    sequencerAggregateSubmissionTimeout;
+    trafficControl;
+    acsCommitmentsCatchup;
+    preparationTimeRecordTimeTolerance;
+    constructor(init = {}) {
+        this.confirmationResponseTimeout = init.confirmationResponseTimeout;
+        this.mediatorReactionTimeout = init.mediatorReactionTimeout;
+        this.assignmentExclusivityTimeout = init.assignmentExclusivityTimeout;
+        this.ledgerTimeRecordTimeTolerance =
+            init.ledgerTimeRecordTimeTolerance;
+        this.reconciliationInterval = init.reconciliationInterval;
+        this.mediatorDeduplicationTimeout =
+            init.mediatorDeduplicationTimeout;
+        this.maxRequestSize = init.maxRequestSize ?? 0;
+        this.onboardingRestriction =
+            init.onboardingRestriction ?? OnboardingRestriction.unspecified;
+        this.participantSynchronizerLimits =
+            init.participantSynchronizerLimits;
+        this.sequencerAggregateSubmissionTimeout =
+            init.sequencerAggregateSubmissionTimeout;
+        this.trafficControl = init.trafficControl;
+        this.acsCommitmentsCatchup = init.acsCommitmentsCatchup;
+        this.preparationTimeRecordTimeTolerance =
+            init.preparationTimeRecordTimeTolerance;
+    }
+}

package/dist/core/types/topology/lsu-announcement.d.ts

@@ -0,0 +1,8 @@
+export declare class LsuAnnouncement {
+    readonly successorPhysicalSynchronizerId: string;
+    readonly upgradeTime?: Date;
+    constructor(init: {
+        successorPhysicalSynchronizerId: string;
+        upgradeTime?: Date;
+    });
+}

package/dist/core/types/topology/lsu-announcement.js

@@ -0,0 +1,9 @@
+export class LsuAnnouncement {
+    successorPhysicalSynchronizerId;
+    upgradeTime;
+    constructor(init) {
+        this.successorPhysicalSynchronizerId =
+            init.successorPhysicalSynchronizerId;
+        this.upgradeTime = init.upgradeTime;
+    }
+}

package/dist/core/types/topology/lsu-sequencer-connection-successor.d.ts

@@ -0,0 +1,18 @@
+export declare class LsuSequencerConnection {
+    readonly endpoints: string[];
+    readonly customTrustCertificates?: Uint8Array;
+    constructor(init?: {
+        endpoints?: string[];
+        customTrustCertificates?: Uint8Array;
+    });
+}
+export declare class LsuSequencerConnectionSuccessor {
+    readonly sequencerId: string;
+    readonly successorPhysicalSynchronizerId: string;
+    readonly connection?: LsuSequencerConnection;
+    constructor(init: {
+        sequencerId: string;
+        successorPhysicalSynchronizerId: string;
+        connection?: LsuSequencerConnection;
+    });
+}

package/dist/core/types/topology/lsu-sequencer-connection-successor.js

@@ -0,0 +1,22 @@
+export class LsuSequencerConnection {
+    endpoints;
+    customTrustCertificates;
+    constructor(init = {}) {
+        this.endpoints = [...(init.endpoints ?? [])];
+        this.customTrustCertificates =
+            init.customTrustCertificates === undefined
+                ? undefined
+                : new Uint8Array(init.customTrustCertificates);
+    }
+}
+export class LsuSequencerConnectionSuccessor {
+    sequencerId;
+    successorPhysicalSynchronizerId;
+    connection;
+    constructor(init) {
+        this.sequencerId = init.sequencerId;
+        this.successorPhysicalSynchronizerId =
+            init.successorPhysicalSynchronizerId;
+        this.connection = init.connection;
+    }
+}

package/dist/core/types/topology/mediator-synchronizer-state.d.ts

@@ -0,0 +1,14 @@
+export declare class MediatorSynchronizerState {
+    readonly synchronizerId: string;
+    readonly group: number;
+    readonly threshold: number;
+    readonly active: string[];
+    readonly observers: string[];
+    constructor(init: {
+        synchronizerId: string;
+        group?: number;
+        threshold?: number;
+        active?: string[];
+        observers?: string[];
+    });
+}

package/dist/core/types/topology/mediator-synchronizer-state.js

@@ -0,0 +1,14 @@
+export class MediatorSynchronizerState {
+    synchronizerId;
+    group;
+    threshold;
+    active;
+    observers;
+    constructor(init) {
+        this.synchronizerId = init.synchronizerId;
+        this.group = init.group ?? 0;
+        this.threshold = init.threshold ?? 0;
+        this.active = [...(init.active ?? [])];
+        this.observers = [...(init.observers ?? [])];
+    }
+}

package/dist/core/types/topology/namespace-delegation.d.ts

@@ -0,0 +1,27 @@
+import { TopologySigningPublicKey } from "./topology-public-key.js";
+import { TopologyMappingCode } from "./topology-mapping-code.js";
+export declare enum NamespaceDelegationRestrictionKind {
+    canSignAllMappings = "canSignAllMappings",
+    canSignAllButNamespaceDelegations = "canSignAllButNamespaceDelegations",
+    canSignSpecificMappings = "canSignSpecificMappings"
+}
+export declare class NamespaceDelegationRestriction {
+    readonly kind: NamespaceDelegationRestrictionKind;
+    readonly mappings: TopologyMappingCode[];
+    constructor(init: {
+        kind: NamespaceDelegationRestrictionKind;
+        mappings?: TopologyMappingCode[];
+    });
+}
+export declare class NamespaceDelegation {
+    readonly namespace: string;
+    readonly targetKey?: TopologySigningPublicKey;
+    readonly isRootDelegation: boolean;
+    readonly restriction?: NamespaceDelegationRestriction;
+    constructor(init: {
+        namespace: string;
+        targetKey?: TopologySigningPublicKey;
+        isRootDelegation?: boolean;
+        restriction?: NamespaceDelegationRestriction;
+    });
+}

package/dist/core/types/topology/namespace-delegation.js

@@ -0,0 +1,26 @@
+export var NamespaceDelegationRestrictionKind;
+(function (NamespaceDelegationRestrictionKind) {
+    NamespaceDelegationRestrictionKind["canSignAllMappings"] = "canSignAllMappings";
+    NamespaceDelegationRestrictionKind["canSignAllButNamespaceDelegations"] = "canSignAllButNamespaceDelegations";
+    NamespaceDelegationRestrictionKind["canSignSpecificMappings"] = "canSignSpecificMappings";
+})(NamespaceDelegationRestrictionKind || (NamespaceDelegationRestrictionKind = {}));
+export class NamespaceDelegationRestriction {
+    kind;
+    mappings;
+    constructor(init) {
+        this.kind = init.kind;
+        this.mappings = [...(init.mappings ?? [])];
+    }
+}
+export class NamespaceDelegation {
+    namespace;
+    targetKey;
+    isRootDelegation;
+    restriction;
+    constructor(init) {
+        this.namespace = init.namespace;
+        this.targetKey = init.targetKey;
+        this.isRootDelegation = init.isRootDelegation ?? false;
+        this.restriction = init.restriction;
+    }
+}

package/dist/core/types/topology/owner-to-key-mapping.d.ts

@@ -0,0 +1,9 @@
+import { TopologyPublicKey } from "./topology-public-key.js";
+export declare class OwnerToKeyMapping {
+    readonly member: string;
+    readonly publicKeys: TopologyPublicKey[];
+    constructor(init: {
+        member: string;
+        publicKeys?: TopologyPublicKey[];
+    });
+}

package/dist/core/types/topology/owner-to-key-mapping.js

@@ -0,0 +1,8 @@
+export class OwnerToKeyMapping {
+    member;
+    publicKeys;
+    constructor(init) {
+        this.member = init.member;
+        this.publicKeys = [...(init.publicKeys ?? [])];
+    }
+}

package/dist/core/types/topology/participant-permission.d.ts

@@ -0,0 +1,6 @@
+export declare enum ParticipantPermission {
+    unspecified = "unspecified",
+    submission = "submission",
+    confirmation = "confirmation",
+    observation = "observation"
+}

package/dist/core/types/topology/participant-permission.js

@@ -0,0 +1,7 @@
+export var ParticipantPermission;
+(function (ParticipantPermission) {
+    ParticipantPermission["unspecified"] = "unspecified";
+    ParticipantPermission["submission"] = "submission";
+    ParticipantPermission["confirmation"] = "confirmation";
+    ParticipantPermission["observation"] = "observation";
+})(ParticipantPermission || (ParticipantPermission = {}));

package/dist/core/types/topology/participant-synchronizer-permission.d.ts

@@ -0,0 +1,21 @@
+import { ParticipantPermission } from "./participant-permission.js";
+export declare class ParticipantSynchronizerLimits {
+    readonly confirmationRequestsMaxRate: number;
+    constructor(init?: {
+        confirmationRequestsMaxRate?: number;
+    });
+}
+export declare class ParticipantSynchronizerPermission {
+    readonly synchronizerId: string;
+    readonly participantUid: string;
+    readonly permission: ParticipantPermission;
+    readonly limits?: ParticipantSynchronizerLimits;
+    readonly loginAfter?: string;
+    constructor(init: {
+        synchronizerId: string;
+        participantUid: string;
+        permission?: ParticipantPermission;
+        limits?: ParticipantSynchronizerLimits;
+        loginAfter?: string;
+    });
+}

package/dist/core/types/topology/participant-synchronizer-permission.js

@@ -0,0 +1,22 @@
+import { ParticipantPermission } from "./participant-permission.js";
+export class ParticipantSynchronizerLimits {
+    confirmationRequestsMaxRate;
+    constructor(init = {}) {
+        this.confirmationRequestsMaxRate =
+            init.confirmationRequestsMaxRate ?? 0;
+    }
+}
+export class ParticipantSynchronizerPermission {
+    synchronizerId;
+    participantUid;
+    permission;
+    limits;
+    loginAfter;
+    constructor(init) {
+        this.synchronizerId = init.synchronizerId;
+        this.participantUid = init.participantUid;
+        this.permission = init.permission ?? ParticipantPermission.unspecified;
+        this.limits = init.limits;
+        this.loginAfter = init.loginAfter;
+    }
+}

package/dist/core/types/topology/party-hosting-limits.d.ts

@@ -0,0 +1,8 @@
+export declare class PartyHostingLimits {
+    readonly synchronizerId: string;
+    readonly party: string;
+    constructor(init: {
+        synchronizerId: string;
+        party: string;
+    });
+}

package/dist/core/types/topology/party-hosting-limits.js

@@ -0,0 +1,8 @@
+export class PartyHostingLimits {
+    synchronizerId;
+    party;
+    constructor(init) {
+        this.synchronizerId = init.synchronizerId;
+        this.party = init.party;
+    }
+}

package/dist/core/types/topology/party-to-key-mapping.d.ts

@@ -0,0 +1,11 @@
+import { TopologySigningPublicKey } from "./topology-public-key.js";
+export declare class PartyToKeyMapping {
+    readonly party: string;
+    readonly threshold: number;
+    readonly signingKeys: TopologySigningPublicKey[];
+    constructor(init: {
+        party: string;
+        threshold?: number;
+        signingKeys?: TopologySigningPublicKey[];
+    });
+}

package/dist/core/types/topology/party-to-key-mapping.js

@@ -0,0 +1,10 @@
+export class PartyToKeyMapping {
+    party;
+    threshold;
+    signingKeys;
+    constructor(init) {
+        this.party = init.party;
+        this.threshold = init.threshold ?? 0;
+        this.signingKeys = [...(init.signingKeys ?? [])];
+    }
+}

package/dist/core/types/topology/party-to-participant.d.ts

@@ -0,0 +1,27 @@
+import { ParticipantPermission } from "./participant-permission.js";
+import { TopologySigningKeysWithThreshold } from "./topology-public-key.js";
+export declare class PartyToParticipantOnboarding {
+    constructor(_init?: Record<string, never>);
+}
+export declare class PartyToParticipantParticipant {
+    readonly participantUid: string;
+    readonly permission: ParticipantPermission;
+    readonly onboarding?: PartyToParticipantOnboarding;
+    constructor(init: {
+        participantUid: string;
+        permission?: ParticipantPermission;
+        onboarding?: PartyToParticipantOnboarding;
+    });
+}
+export declare class PartyToParticipant {
+    readonly party: string;
+    readonly threshold: number;
+    readonly participants: PartyToParticipantParticipant[];
+    readonly partySigningKeys?: TopologySigningKeysWithThreshold;
+    constructor(init: {
+        party: string;
+        threshold?: number;
+        participants?: PartyToParticipantParticipant[];
+        partySigningKeys?: TopologySigningKeysWithThreshold;
+    });
+}

package/dist/core/types/topology/party-to-participant.js

@@ -0,0 +1,28 @@
+import { ParticipantPermission } from "./participant-permission.js";
+export class PartyToParticipantOnboarding {
+    constructor(_init = {}) {
+        void _init;
+    }
+}
+export class PartyToParticipantParticipant {
+    participantUid;
+    permission;
+    onboarding;
+    constructor(init) {
+        this.participantUid = init.participantUid;
+        this.permission = init.permission ?? ParticipantPermission.unspecified;
+        this.onboarding = init.onboarding;
+    }
+}
+export class PartyToParticipant {
+    party;
+    threshold;
+    participants;
+    partySigningKeys;
+    constructor(init) {
+        this.party = init.party;
+        this.threshold = init.threshold ?? 0;
+        this.participants = [...(init.participants ?? [])];
+        this.partySigningKeys = init.partySigningKeys;
+    }
+}

package/dist/core/types/topology/sequencer-synchronizer-state.d.ts

@@ -0,0 +1,12 @@
+export declare class SequencerSynchronizerState {
+    readonly synchronizerId: string;
+    readonly threshold: number;
+    readonly active: string[];
+    readonly observers: string[];
+    constructor(init: {
+        synchronizerId: string;
+        threshold?: number;
+        active?: string[];
+        observers?: string[];
+    });
+}

package/dist/core/types/topology/sequencer-synchronizer-state.js

@@ -0,0 +1,12 @@
+export class SequencerSynchronizerState {
+    synchronizerId;
+    threshold;
+    active;
+    observers;
+    constructor(init) {
+        this.synchronizerId = init.synchronizerId;
+        this.threshold = init.threshold ?? 0;
+        this.active = [...(init.active ?? [])];
+        this.observers = [...(init.observers ?? [])];
+    }
+}

package/dist/core/types/topology/synchronizer-trust-certificate.d.ts

@@ -0,0 +1,10 @@
+export declare class SynchronizerTrustCertificate {
+    readonly participantUid: string;
+    readonly synchronizerId: string;
+    readonly featureFlags: string[];
+    constructor(init: {
+        participantUid: string;
+        synchronizerId: string;
+        featureFlags?: string[];
+    });
+}

package/dist/core/types/topology/synchronizer-trust-certificate.js

@@ -0,0 +1,10 @@
+export class SynchronizerTrustCertificate {
+    participantUid;
+    synchronizerId;
+    featureFlags;
+    constructor(init) {
+        this.participantUid = init.participantUid;
+        this.synchronizerId = init.synchronizerId;
+        this.featureFlags = [...(init.featureFlags ?? [])];
+    }
+}

package/dist/core/types/topology/topology-base-query.d.ts

@@ -0,0 +1,30 @@
+import { TopologyMappingOperation } from "./topology-mapping-operation.js";
+import { TopologyStoreId } from "./topology-store-id.js";
+export declare class TopologyTimeRange {
+    readonly from?: Date;
+    readonly until?: Date;
+    constructor(init?: {
+        from?: Date;
+        until?: Date;
+    });
+}
+export declare class TopologyBaseQuery {
+    readonly storeId?: TopologyStoreId;
+    readonly includeProposals: boolean;
+    readonly operation: TopologyMappingOperation;
+    readonly snapshot?: Date;
+    readonly headState?: boolean;
+    readonly timeRange?: TopologyTimeRange;
+    readonly signedKeyFingerprint?: string;
+    readonly protocolVersion?: number;
+    constructor(init?: {
+        storeId?: TopologyStoreId;
+        includeProposals?: boolean;
+        operation?: TopologyMappingOperation;
+        snapshot?: Date;
+        headState?: boolean;
+        timeRange?: TopologyTimeRange;
+        signedKeyFingerprint?: string;
+        protocolVersion?: number;
+    });
+}

package/dist/core/types/topology/topology-base-query.js

@@ -0,0 +1,29 @@
+import { TopologyMappingOperation } from "./topology-mapping-operation.js";
+export class TopologyTimeRange {
+    from;
+    until;
+    constructor(init = {}) {
+        this.from = init.from;
+        this.until = init.until;
+    }
+}
+export class TopologyBaseQuery {
+    storeId;
+    includeProposals;
+    operation;
+    snapshot;
+    headState;
+    timeRange;
+    signedKeyFingerprint;
+    protocolVersion;
+    constructor(init = {}) {
+        this.storeId = init.storeId;
+        this.includeProposals = init.includeProposals ?? false;
+        this.operation = init.operation ?? TopologyMappingOperation.unspecified;
+        this.snapshot = init.snapshot;
+        this.headState = init.headState;
+        this.timeRange = init.timeRange;
+        this.signedKeyFingerprint = init.signedKeyFingerprint;
+        this.protocolVersion = init.protocolVersion;
+    }
+}

package/dist/core/types/topology/topology-base-result.d.ts

@@ -0,0 +1,22 @@
+import { TopologyMappingOperation } from "./topology-mapping-operation.js";
+import { TopologyStoreId } from "./topology-store-id.js";
+export declare class TopologyBaseResult {
+    readonly storeId?: TopologyStoreId;
+    readonly sequencedAt?: Date;
+    readonly validFrom?: Date;
+    readonly validUntil?: Date;
+    readonly operation: TopologyMappingOperation;
+    readonly transactionHash: Uint8Array;
+    readonly serial: number;
+    readonly signedByFingerprints: string[];
+    constructor(init?: {
+        storeId?: TopologyStoreId;
+        sequencedAt?: Date;
+        validFrom?: Date;
+        validUntil?: Date;
+        operation?: TopologyMappingOperation;
+        transactionHash?: Uint8Array;
+        serial?: number;
+        signedByFingerprints?: string[];
+    });
+}

package/dist/core/types/topology/topology-base-result.js

@@ -0,0 +1,21 @@
+import { TopologyMappingOperation } from "./topology-mapping-operation.js";
+export class TopologyBaseResult {
+    storeId;
+    sequencedAt;
+    validFrom;
+    validUntil;
+    operation;
+    transactionHash;
+    serial;
+    signedByFingerprints;
+    constructor(init = {}) {
+        this.storeId = init.storeId;
+        this.sequencedAt = init.sequencedAt;
+        this.validFrom = init.validFrom;
+        this.validUntil = init.validUntil;
+        this.operation = init.operation ?? TopologyMappingOperation.unspecified;
+        this.transactionHash = new Uint8Array(init.transactionHash ?? []);
+        this.serial = init.serial ?? 0;
+        this.signedByFingerprints = [...(init.signedByFingerprints ?? [])];
+    }
+}

package/dist/core/types/topology/topology-duration.d.ts

@@ -0,0 +1,8 @@
+export declare class TopologyDuration {
+    readonly seconds: string;
+    readonly nanos: number;
+    constructor(init?: {
+        seconds?: string;
+        nanos?: number;
+    });
+}

package/dist/core/types/topology/topology-duration.js

@@ -0,0 +1,8 @@
+export class TopologyDuration {
+    seconds;
+    nanos;
+    constructor(init = {}) {
+        this.seconds = init.seconds ?? "0";
+        this.nanos = init.nanos ?? 0;
+    }
+}

package/dist/core/types/topology/topology-key-owner-result.d.ts

@@ -0,0 +1,15 @@
+import { TopologyEncryptionPublicKey, TopologySigningPublicKey } from "./topology-public-key.js";
+export declare class TopologyKeyOwnerResult {
+    readonly synchronizerId: string;
+    readonly keyOwner: string;
+    readonly signingKeys: TopologySigningPublicKey[];
+    readonly encryptionKeys: TopologyEncryptionPublicKey[];
+    readonly physicalSynchronizerId: string;
+    constructor(init: {
+        synchronizerId: string;
+        keyOwner: string;
+        signingKeys?: TopologySigningPublicKey[];
+        encryptionKeys?: TopologyEncryptionPublicKey[];
+        physicalSynchronizerId?: string;
+    });
+}

package/dist/core/types/topology/topology-key-owner-result.js

@@ -0,0 +1,14 @@
+export class TopologyKeyOwnerResult {
+    synchronizerId;
+    keyOwner;
+    signingKeys;
+    encryptionKeys;
+    physicalSynchronizerId;
+    constructor(init) {
+        this.synchronizerId = init.synchronizerId;
+        this.keyOwner = init.keyOwner;
+        this.signingKeys = [...(init.signingKeys ?? [])];
+        this.encryptionKeys = [...(init.encryptionKeys ?? [])];
+        this.physicalSynchronizerId = init.physicalSynchronizerId ?? "";
+    }
+}

package/dist/core/types/topology/topology-mapping-code.d.ts

@@ -0,0 +1,18 @@
+export declare enum TopologyMappingCode {
+    unspecified = "unspecified",
+    namespaceDelegation = "namespaceDelegation",
+    decentralizedNamespaceDefinition = "decentralizedNamespaceDefinition",
+    ownerToKeyMapping = "ownerToKeyMapping",
+    synchronizerTrustCertificate = "synchronizerTrustCertificate",
+    participantPermission = "participantPermission",
+    partyHostingLimits = "partyHostingLimits",
+    vettedPackages = "vettedPackages",
+    partyToParticipant = "partyToParticipant",
+    synchronizerParametersState = "synchronizerParametersState",
+    mediatorSynchronizerState = "mediatorSynchronizerState",
+    sequencerSynchronizerState = "sequencerSynchronizerState",
+    sequencingDynamicParametersState = "sequencingDynamicParametersState",
+    partyToKeyMapping = "partyToKeyMapping",
+    lsuAnnouncement = "lsuAnnouncement",
+    sequencerConnectionSuccessor = "sequencerConnectionSuccessor"
+}

package/dist/core/types/topology/topology-mapping-code.js

@@ -0,0 +1,19 @@
+export var TopologyMappingCode;
+(function (TopologyMappingCode) {
+    TopologyMappingCode["unspecified"] = "unspecified";
+    TopologyMappingCode["namespaceDelegation"] = "namespaceDelegation";
+    TopologyMappingCode["decentralizedNamespaceDefinition"] = "decentralizedNamespaceDefinition";
+    TopologyMappingCode["ownerToKeyMapping"] = "ownerToKeyMapping";
+    TopologyMappingCode["synchronizerTrustCertificate"] = "synchronizerTrustCertificate";
+    TopologyMappingCode["participantPermission"] = "participantPermission";
+    TopologyMappingCode["partyHostingLimits"] = "partyHostingLimits";
+    TopologyMappingCode["vettedPackages"] = "vettedPackages";
+    TopologyMappingCode["partyToParticipant"] = "partyToParticipant";
+    TopologyMappingCode["synchronizerParametersState"] = "synchronizerParametersState";
+    TopologyMappingCode["mediatorSynchronizerState"] = "mediatorSynchronizerState";
+    TopologyMappingCode["sequencerSynchronizerState"] = "sequencerSynchronizerState";
+    TopologyMappingCode["sequencingDynamicParametersState"] = "sequencingDynamicParametersState";
+    TopologyMappingCode["partyToKeyMapping"] = "partyToKeyMapping";
+    TopologyMappingCode["lsuAnnouncement"] = "lsuAnnouncement";
+    TopologyMappingCode["sequencerConnectionSuccessor"] = "sequencerConnectionSuccessor";
+})(TopologyMappingCode || (TopologyMappingCode = {}));